// 
// Decompiled by Procyon v0.6.0
// 

package org.bouncycastle.jcajce.provider.asymmetric.slhdsa;

import org.bouncycastle.crypto.CipherParameters;
import org.bouncycastle.pqc.crypto.slhdsa.SLHDSAPublicKeyParameters;
import org.bouncycastle.pqc.crypto.slhdsa.SLHDSAPrivateKeyParameters;
import java.security.SignatureException;
import java.security.SecureRandom;
import java.security.PrivateKey;
import java.security.InvalidKeyException;
import java.security.PublicKey;
import org.bouncycastle.pqc.crypto.slhdsa.HashSLHDSASigner;
import org.bouncycastle.jcajce.provider.asymmetric.util.BaseDeterministicOrRandomSignature;

public class HashSignatureSpi extends BaseDeterministicOrRandomSignature
{
    private final HashSLHDSASigner signer;
    
    protected HashSignatureSpi(final HashSLHDSASigner signer) {
        super("HASH-SLH-DSA");
        this.signer = signer;
    }
    
    @Override
    protected void verifyInit(final PublicKey publicKey) throws InvalidKeyException {
        if (publicKey instanceof BCSLHDSAPublicKey) {
            this.keyParams = ((BCSLHDSAPublicKey)publicKey).getKeyParams();
            return;
        }
        throw new InvalidKeyException("unknown public key passed to SLH-DSA");
    }
    
    @Override
    protected void signInit(final PrivateKey privateKey, final SecureRandom appRandom) throws InvalidKeyException {
        this.appRandom = appRandom;
        if (privateKey instanceof BCSLHDSAPrivateKey) {
            this.keyParams = ((BCSLHDSAPrivateKey)privateKey).getKeyParams();
            return;
        }
        throw new InvalidKeyException("unknown private key passed to SLH-DSA");
    }
    
    @Override
    protected void updateEngine(final byte b) throws SignatureException {
        this.signer.update(b);
    }
    
    @Override
    protected void updateEngine(final byte[] array, final int n, final int n2) throws SignatureException {
        this.signer.update(array, n, n2);
    }
    
    @Override
    protected byte[] engineSign() throws SignatureException {
        if (!(this.keyParams instanceof SLHDSAPrivateKeyParameters)) {
            throw new SignatureException("engine initialized for verification");
        }
        try {
            return this.signer.generateSignature();
        }
        catch (final Exception ex) {
            throw new SignatureException(ex.toString());
        }
        finally {
            this.isInitState = true;
        }
    }
    
    @Override
    protected boolean engineVerify(final byte[] array) throws SignatureException {
        if (!(this.keyParams instanceof SLHDSAPublicKeyParameters)) {
            throw new SignatureException("engine initialized for signing");
        }
        try {
            return this.signer.verifySignature(array);
        }
        finally {
            this.isInitState = true;
        }
    }
    
    @Override
    protected void reInitialize(final boolean b, final CipherParameters cipherParameters) {
        this.signer.init(b, cipherParameters);
    }
    
    public static class Direct extends HashSignatureSpi
    {
        public Direct() {
            super(new HashSLHDSASigner());
        }
    }
}