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

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

import java.security.spec.AlgorithmParameterSpec;
import org.bouncycastle.pqc.crypto.lms.LMSContext;
import org.bouncycastle.pqc.crypto.ExhaustedPrivateKeyException;
import java.security.SignatureException;
import java.security.PrivateKey;
import java.security.InvalidKeyException;
import org.bouncycastle.crypto.digests.NullDigest;
import java.security.PublicKey;
import org.bouncycastle.pqc.crypto.lms.LMSContextBasedVerifier;
import org.bouncycastle.pqc.crypto.lms.LMSContextBasedSigner;
import java.security.SecureRandom;
import org.bouncycastle.pqc.crypto.MessageSigner;
import org.bouncycastle.crypto.Digest;
import java.security.Signature;

public class LMSSignatureSpi extends Signature
{
    private Digest digest;
    private MessageSigner signer;
    private SecureRandom random;
    private LMSContextBasedSigner lmOtsSigner;
    private LMSContextBasedVerifier lmOtsVerifier;
    
    protected LMSSignatureSpi(final String algorithm) {
        super(algorithm);
    }
    
    protected LMSSignatureSpi(final String algorithm, final Digest digest) {
        super(algorithm);
        this.digest = digest;
    }
    
    @Override
    protected void engineInitVerify(final PublicKey publicKey) throws InvalidKeyException {
        if (publicKey instanceof BCLMSPublicKey) {
            (this.digest = new NullDigest()).reset();
            this.lmOtsVerifier = (LMSContextBasedVerifier)((BCLMSPublicKey)publicKey).getKeyParams();
            return;
        }
        throw new InvalidKeyException("unknown public key passed to LMS");
    }
    
    @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 BCLMSPrivateKey)) {
            throw new InvalidKeyException("unknown private key passed to LMS");
        }
        this.lmOtsSigner = (LMSContextBasedSigner)((BCLMSPrivateKey)privateKey).getKeyParams();
        if (this.lmOtsSigner.getUsagesRemaining() == 0L) {
            throw new InvalidKeyException("private key exhausted");
        }
        this.digest = null;
    }
    
    @Override
    protected void engineUpdate(final byte b) throws SignatureException {
        if (this.digest == null) {
            this.digest = this.getSigner();
        }
        this.digest.update(b);
    }
    
    @Override
    protected void engineUpdate(final byte[] array, final int n, final int n2) throws SignatureException {
        if (this.digest == null) {
            this.digest = this.getSigner();
        }
        this.digest.update(array, n, n2);
    }
    
    private Digest getSigner() throws SignatureException {
        try {
            return this.lmOtsSigner.generateLMSContext();
        }
        catch (final ExhaustedPrivateKeyException cause) {
            throw new SignatureException(cause.getMessage(), cause);
        }
    }
    
    @Override
    protected byte[] engineSign() throws SignatureException {
        if (this.digest == null) {
            this.digest = this.getSigner();
        }
        try {
            final byte[] generateSignature = this.lmOtsSigner.generateSignature((LMSContext)this.digest);
            this.digest = null;
            return generateSignature;
        }
        catch (final Exception ex) {
            if (ex instanceof IllegalStateException) {
                throw new SignatureException(ex.getMessage(), ex);
            }
            throw new SignatureException(ex.toString(), ex);
        }
    }
    
    @Override
    protected boolean engineVerify(final byte[] array) throws SignatureException {
        final LMSContext generateLMSContext = this.lmOtsVerifier.generateLMSContext(array);
        final byte[] digestResult = DigestUtil.getDigestResult(this.digest);
        generateLMSContext.update(digestResult, 0, digestResult.length);
        return this.lmOtsVerifier.verify(generateLMSContext);
    }
    
    @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 generic extends LMSSignatureSpi
    {
        public generic() {
            super("LMS", new NullDigest());
        }
    }
}