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

package org.bouncycastle.crypto.signers;

import java.io.ByteArrayOutputStream;
import org.bouncycastle.crypto.CryptoServicesRegistrar;
import org.bouncycastle.crypto.params.ParametersWithRandom;
import org.bouncycastle.crypto.CipherParameters;
import org.bouncycastle.util.Arrays;
import org.bouncycastle.crypto.params.Ed448PublicKeyParameters;
import org.bouncycastle.crypto.params.Ed448PrivateKeyParameters;
import org.bouncycastle.crypto.Signer;

public class Ed448Signer implements Signer
{
    private final Buffer buffer;
    private final byte[] context;
    private boolean forSigning;
    private Ed448PrivateKeyParameters privateKey;
    private Ed448PublicKeyParameters publicKey;
    
    public Ed448Signer(final byte[] array) {
        this.buffer = new Buffer();
        if (null == array) {
            throw new NullPointerException("'context' cannot be null");
        }
        this.context = Arrays.clone(array);
    }
    
    @Override
    public void init(final boolean forSigning, CipherParameters parameters) {
        this.forSigning = forSigning;
        if (parameters instanceof ParametersWithRandom) {
            parameters = ((ParametersWithRandom)parameters).getParameters();
        }
        if (forSigning) {
            this.privateKey = (Ed448PrivateKeyParameters)parameters;
            this.publicKey = null;
        }
        else {
            this.privateKey = null;
            this.publicKey = (Ed448PublicKeyParameters)parameters;
        }
        CryptoServicesRegistrar.checkConstraints(Utils.getDefaultProperties("Ed448", 224, parameters, forSigning));
        this.reset();
    }
    
    @Override
    public void update(final byte b) {
        this.buffer.write(b);
    }
    
    @Override
    public void update(final byte[] b, final int off, final int len) {
        this.buffer.write(b, off, len);
    }
    
    @Override
    public byte[] generateSignature() {
        if (!this.forSigning || null == this.privateKey) {
            throw new IllegalStateException("Ed448Signer not initialised for signature generation.");
        }
        return this.buffer.generateSignature(this.privateKey, this.context);
    }
    
    @Override
    public boolean verifySignature(final byte[] array) {
        if (this.forSigning || null == this.publicKey) {
            throw new IllegalStateException("Ed448Signer not initialised for verification");
        }
        return this.buffer.verifySignature(this.publicKey, this.context, array);
    }
    
    @Override
    public void reset() {
        this.buffer.reset();
    }
    
    private static final class Buffer extends ByteArrayOutputStream
    {
        synchronized byte[] generateSignature(final Ed448PrivateKeyParameters ed448PrivateKeyParameters, final byte[] array) {
            final byte[] array2 = new byte[114];
            ed448PrivateKeyParameters.sign(0, array, this.buf, 0, this.count, array2, 0);
            this.reset();
            return array2;
        }
        
        synchronized boolean verifySignature(final Ed448PublicKeyParameters ed448PublicKeyParameters, final byte[] array, final byte[] array2) {
            if (114 != array2.length) {
                this.reset();
                return false;
            }
            final boolean verify = ed448PublicKeyParameters.verify(0, array, this.buf, 0, this.count, array2, 0);
            this.reset();
            return verify;
        }
        
        @Override
        public synchronized void reset() {
            Arrays.fill(this.buf, 0, this.count, (byte)0);
            this.count = 0;
        }
    }
}