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

package org.bouncycastle.pqc.crypto.newhope;

import org.bouncycastle.pqc.crypto.ExchangePair;
import org.bouncycastle.crypto.params.AsymmetricKeyParameter;
import org.bouncycastle.crypto.CipherParameters;
import org.bouncycastle.crypto.KeyGenerationParameters;
import java.security.SecureRandom;
import org.bouncycastle.crypto.AsymmetricCipherKeyPair;
import org.bouncycastle.util.Arrays;
import org.bouncycastle.crypto.digests.SHAKEDigest;
import org.bouncycastle.crypto.Xof;

public class NHSecretKeyProcessor
{
    private final Xof xof;
    
    private NHSecretKeyProcessor(final byte[] array, final byte[] array2) {
        (this.xof = new SHAKEDigest(256)).update(array, 0, array.length);
        if (array2 != null) {
            this.xof.update(array2, 0, array2.length);
        }
        Arrays.fill(array, (byte)0);
    }
    
    public byte[] processKey(final byte[] array) {
        final byte[] array2 = new byte[array.length];
        this.xof.doFinal(array2, 0, array2.length);
        xor(array, array2);
        Arrays.fill(array2, (byte)0);
        return array;
    }
    
    private static void xor(final byte[] array, final byte[] array2) {
        for (int i = 0; i != array.length; ++i) {
            final int n = i;
            array[n] ^= array2[i];
        }
    }
    
    public static class PartyUBuilder
    {
        private final AsymmetricCipherKeyPair aKp;
        private final NHAgreement agreement;
        private byte[] sharedInfo;
        private boolean used;
        
        public PartyUBuilder(final SecureRandom secureRandom) {
            this.agreement = new NHAgreement();
            this.sharedInfo = null;
            this.used = false;
            final NHKeyPairGenerator nhKeyPairGenerator = new NHKeyPairGenerator();
            nhKeyPairGenerator.init(new KeyGenerationParameters(secureRandom, 2048));
            this.aKp = nhKeyPairGenerator.generateKeyPair();
            this.agreement.init(this.aKp.getPrivate());
        }
        
        public PartyUBuilder withSharedInfo(final byte[] array) {
            this.sharedInfo = Arrays.clone(array);
            return this;
        }
        
        public byte[] getPartA() {
            return ((NHPublicKeyParameters)this.aKp.getPublic()).getPubData();
        }
        
        public NHSecretKeyProcessor build(final byte[] array) {
            if (this.used) {
                throw new IllegalStateException("builder already used");
            }
            this.used = true;
            return new NHSecretKeyProcessor(this.agreement.calculateAgreement(new NHPublicKeyParameters(array)), this.sharedInfo, null);
        }
    }
    
    public static class PartyVBuilder
    {
        protected final SecureRandom random;
        private byte[] sharedInfo;
        private byte[] sharedSecret;
        private boolean used;
        
        public PartyVBuilder(final SecureRandom random) {
            this.sharedInfo = null;
            this.sharedSecret = null;
            this.used = false;
            this.random = random;
        }
        
        public PartyVBuilder withSharedInfo(final byte[] array) {
            this.sharedInfo = Arrays.clone(array);
            return this;
        }
        
        public byte[] getPartB(final byte[] array) {
            final ExchangePair generateExchange = new NHExchangePairGenerator(this.random).generateExchange(new NHPublicKeyParameters(array));
            this.sharedSecret = generateExchange.getSharedValue();
            return ((NHPublicKeyParameters)generateExchange.getPublicKey()).getPubData();
        }
        
        public NHSecretKeyProcessor build() {
            if (this.used) {
                throw new IllegalStateException("builder already used");
            }
            this.used = true;
            return new NHSecretKeyProcessor(this.sharedSecret, this.sharedInfo, null);
        }
    }
}