// 
// 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.SLHDSASigner;
import java.io.ByteArrayOutputStream;
import org.bouncycastle.jcajce.provider.asymmetric.util.BaseDeterministicOrRandomSignature;

public class SignatureSpi extends BaseDeterministicOrRandomSignature
{
    private final ByteArrayOutputStream bOut;
    private final SLHDSASigner signer;
    
    protected SignatureSpi(final SLHDSASigner signer) {
        super("SLH-DSA");
        this.bOut = new ByteArrayOutputStream();
        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.bOut.write(b);
    }
    
    @Override
    protected void updateEngine(final byte[] b, final int off, final int len) throws SignatureException {
        this.bOut.write(b, off, len);
    }
    
    @Override
    protected byte[] engineSign() throws SignatureException {
        if (!(this.keyParams instanceof SLHDSAPrivateKeyParameters)) {
            throw new SignatureException("engine initialized for verification");
        }
        try {
            return this.signer.generateSignature(this.bOut.toByteArray());
        }
        catch (final Exception ex) {
            throw new SignatureException(ex.toString());
        }
        finally {
            this.isInitState = true;
            this.bOut.reset();
        }
    }
    
    @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(this.bOut.toByteArray(), array);
        }
        finally {
            this.isInitState = true;
            this.bOut.reset();
        }
    }
    
    @Override
    protected void reInitialize(final boolean b, final CipherParameters cipherParameters) {
        this.signer.init(b, cipherParameters);
        this.bOut.reset();
    }
    
    public static class Direct extends SignatureSpi
    {
        public Direct() {
            super(new SLHDSASigner());
        }
    }
}