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

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

import org.bouncycastle.crypto.SecretWithEncapsulation;
import org.bouncycastle.pqc.crypto.ntru.NTRUKEMExtractor;
import javax.security.auth.DestroyFailedException;
import org.bouncycastle.jcajce.SecretKeyWithEncapsulation;
import javax.crypto.spec.SecretKeySpec;
import org.bouncycastle.util.Arrays;
import org.bouncycastle.crypto.params.AsymmetricKeyParameter;
import org.bouncycastle.pqc.crypto.ntru.NTRUKEMGenerator;
import javax.crypto.SecretKey;
import java.security.InvalidAlgorithmParameterException;
import java.security.spec.AlgorithmParameterSpec;
import org.bouncycastle.jcajce.spec.KEMExtractSpec;
import java.security.SecureRandom;
import org.bouncycastle.jcajce.spec.KEMGenerateSpec;
import javax.crypto.KeyGeneratorSpi;

public class NTRUKeyGeneratorSpi extends KeyGeneratorSpi
{
    private KEMGenerateSpec genSpec;
    private SecureRandom random;
    private KEMExtractSpec extSpec;
    
    @Override
    protected void engineInit(final SecureRandom secureRandom) {
        throw new UnsupportedOperationException("Operation not supported");
    }
    
    @Override
    protected void engineInit(final AlgorithmParameterSpec algorithmParameterSpec, final SecureRandom random) throws InvalidAlgorithmParameterException {
        this.random = random;
        if (algorithmParameterSpec instanceof KEMGenerateSpec) {
            this.genSpec = (KEMGenerateSpec)algorithmParameterSpec;
            this.extSpec = null;
        }
        else {
            if (!(algorithmParameterSpec instanceof KEMExtractSpec)) {
                throw new InvalidAlgorithmParameterException("unknown spec");
            }
            this.genSpec = null;
            this.extSpec = (KEMExtractSpec)algorithmParameterSpec;
        }
    }
    
    @Override
    protected void engineInit(final int n, final SecureRandom secureRandom) {
        throw new UnsupportedOperationException("Operation not supported");
    }
    
    @Override
    protected SecretKey engineGenerateKey() {
        if (this.genSpec != null) {
            final SecretWithEncapsulation generateEncapsulated = new NTRUKEMGenerator(this.random).generateEncapsulated(((BCNTRUPublicKey)this.genSpec.getPublicKey()).getKeyParams());
            final byte[] secret = generateEncapsulated.getSecret();
            final byte[] copyOfRange = Arrays.copyOfRange(secret, 0, (this.genSpec.getKeySize() + 7) / 8);
            Arrays.clear(secret);
            final SecretKeyWithEncapsulation secretKeyWithEncapsulation = new SecretKeyWithEncapsulation(new SecretKeySpec(copyOfRange, this.genSpec.getKeyAlgorithmName()), generateEncapsulated.getEncapsulation());
            try {
                generateEncapsulated.destroy();
            }
            catch (final DestroyFailedException ex) {
                throw new IllegalStateException("key cleanup failed");
            }
            return secretKeyWithEncapsulation;
        }
        final NTRUKEMExtractor ntrukemExtractor = new NTRUKEMExtractor(((BCNTRUPrivateKey)this.extSpec.getPrivateKey()).getKeyParams());
        final byte[] encapsulation = this.extSpec.getEncapsulation();
        final byte[] secret2 = ntrukemExtractor.extractSecret(encapsulation);
        final byte[] copyOfRange2 = Arrays.copyOfRange(secret2, 0, (this.extSpec.getKeySize() + 7) / 8);
        Arrays.clear(secret2);
        final SecretKeyWithEncapsulation secretKeyWithEncapsulation2 = new SecretKeyWithEncapsulation(new SecretKeySpec(copyOfRange2, this.extSpec.getKeyAlgorithmName()), encapsulation);
        Arrays.clear(copyOfRange2);
        return secretKeyWithEncapsulation2;
    }
}