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

package org.bouncycastle.pqc.jcajce.provider.picnic;

import org.bouncycastle.crypto.digests.SHAKEDigest;
import org.bouncycastle.crypto.digests.SHA512Digest;
import org.bouncycastle.crypto.digests.SHA3Digest;
import org.bouncycastle.crypto.digests.NullDigest;
import java.security.spec.AlgorithmParameterSpec;
import java.security.SignatureException;
import org.bouncycastle.pqc.crypto.picnic.PicnicPrivateKeyParameters;
import java.security.PrivateKey;
import org.bouncycastle.pqc.crypto.picnic.PicnicPublicKeyParameters;
import java.security.InvalidKeyException;
import org.bouncycastle.crypto.CipherParameters;
import java.security.PublicKey;
import org.bouncycastle.pqc.crypto.picnic.PicnicSigner;
import org.bouncycastle.crypto.Digest;
import java.security.SecureRandom;
import java.security.Signature;

public class SignatureSpi extends Signature
{
    private SecureRandom random;
    private Digest digest;
    private PicnicSigner signer;
    
    protected SignatureSpi(final Digest digest, final PicnicSigner signer) {
        super("Picnic");
        this.digest = digest;
        this.signer = signer;
    }
    
    @Override
    protected void engineInitVerify(final PublicKey publicKey) throws InvalidKeyException {
        if (publicKey instanceof BCPicnicPublicKey) {
            final PicnicPublicKeyParameters keyParams = ((BCPicnicPublicKey)publicKey).getKeyParams();
            this.digest.reset();
            this.signer.init(false, keyParams);
            return;
        }
        throw new InvalidKeyException("unknown public key passed to Picnic");
    }
    
    @Override
    protected void engineInitSign(final PrivateKey privateKey, final SecureRandom random) throws InvalidKeyException {
        this.random = random;
        this.engineInitSign(privateKey);
    }
    
    @Override
    protected void engineInitSign(final PrivateKey privateKey) throws InvalidKeyException {
        if (privateKey instanceof BCPicnicPrivateKey) {
            final PicnicPrivateKeyParameters keyParams = ((BCPicnicPrivateKey)privateKey).getKeyParams();
            this.digest.reset();
            this.signer.init(true, keyParams);
            return;
        }
        throw new InvalidKeyException("unknown private key passed to Picnic");
    }
    
    @Override
    protected void engineUpdate(final byte b) throws SignatureException {
        this.digest.update(b);
    }
    
    @Override
    protected void engineUpdate(final byte[] array, final int n, final int n2) throws SignatureException {
        this.digest.update(array, n, n2);
    }
    
    @Override
    protected byte[] engineSign() throws SignatureException {
        final byte[] array = new byte[this.digest.getDigestSize()];
        this.digest.doFinal(array, 0);
        try {
            return this.signer.generateSignature(array);
        }
        catch (final Exception ex) {
            throw new SignatureException(ex.toString());
        }
    }
    
    @Override
    protected boolean engineVerify(final byte[] array) throws SignatureException {
        final byte[] array2 = new byte[this.digest.getDigestSize()];
        this.digest.doFinal(array2, 0);
        return this.signer.verifySignature(array2, array);
    }
    
    @Override
    protected void engineSetParameter(final AlgorithmParameterSpec algorithmParameterSpec) {
        throw new UnsupportedOperationException("engineSetParameter unsupported");
    }
    
    @Override
    @Deprecated
    protected void engineSetParameter(final String s, final Object o) {
        throw new UnsupportedOperationException("engineSetParameter unsupported");
    }
    
    @Override
    @Deprecated
    protected Object engineGetParameter(final String s) {
        throw new UnsupportedOperationException("engineSetParameter unsupported");
    }
    
    public static class Base extends SignatureSpi
    {
        public Base() {
            super(new NullDigest(), new PicnicSigner());
        }
    }
    
    public static class withSha3512 extends SignatureSpi
    {
        public withSha3512() {
            super(new SHA3Digest(512), new PicnicSigner());
        }
    }
    
    public static class withSha512 extends SignatureSpi
    {
        public withSha512() {
            super(new SHA512Digest(), new PicnicSigner());
        }
    }
    
    public static class withShake256 extends SignatureSpi
    {
        public withShake256() {
            super(new SHAKEDigest(256), new PicnicSigner());
        }
    }
}