jceecdhkeyagreement.java

java 文件下载器。可自定义

// Decompiled by Jad v1.5.8e2. Copyright 2001 Pavel Kouznetsov.
// Jad home page: http://kpdus.tripod.com/jad.html
// Decompiler options: packimports(3) fieldsfirst ansi space 
// Source File Name:   JCEECDHKeyAgreement.java

package org.bouncycastle.jce.provider;

import java.math.BigInteger;
import java.security.*;
import java.security.spec.AlgorithmParameterSpec;
import javax.crypto.*;
import javax.crypto.spec.SecretKeySpec;
import org.bouncycastle.crypto.BasicAgreement;
import org.bouncycastle.crypto.CipherParameters;
import org.bouncycastle.crypto.agreement.ECDHBasicAgreement;
import org.bouncycastle.jce.interfaces.ECPrivateKey;
import org.bouncycastle.jce.interfaces.ECPublicKey;

// Referenced classes of package org.bouncycastle.jce.provider:
//			ECUtil

public class JCEECDHKeyAgreement extends KeyAgreementSpi
{
	public static class DH extends JCEECDHKeyAgreement
	{

		public DH()
		{
			super(new ECDHBasicAgreement());
		}
	}


	private BigInteger result;
	private CipherParameters privKey;
	private BasicAgreement agreement;

	protected JCEECDHKeyAgreement(BasicAgreement agreement)
	{
		this.agreement = agreement;
	}

	public Key doPhase(Key key, boolean lastPhase)
		throws InvalidKeyException, IllegalStateException
	{
		return engineDoPhase(key, lastPhase);
	}

	protected Key engineDoPhase(Key key, boolean lastPhase)
		throws InvalidKeyException, IllegalStateException
	{
		if (privKey == null)
			throw new IllegalStateException("EC Diffie-Hellman not initialised.");
		if (!lastPhase)
			throw new IllegalStateException("EC Diffie-Hellman can only be between two parties.");
		if (!(key instanceof ECPublicKey))
		{
			throw new InvalidKeyException("EC Key Agreement doPhase requires ECPublicKey");
		} else
		{
			CipherParameters pubKey = ECUtil.generatePublicKeyParameter((PublicKey)key);
			result = agreement.calculateAgreement(pubKey);
			return null;
		}
	}

	public byte[] generateSecret()
		throws IllegalStateException
	{
		return engineGenerateSecret();
	}

	protected byte[] engineGenerateSecret()
		throws IllegalStateException
	{
		return result.toByteArray();
	}

	protected int engineGenerateSecret(byte sharedSecret[], int offset)
		throws IllegalStateException, ShortBufferException
	{
		byte secret[] = result.toByteArray();
		if (sharedSecret.length - offset < secret.length)
		{
			throw new ShortBufferException("ECKeyAgreement - buffer too short");
		} else
		{
			System.arraycopy(secret, 0, sharedSecret, offset, secret.length);
			return secret.length;
		}
	}

	protected SecretKey engineGenerateSecret(String algorithm)
	{
		return new SecretKeySpec(result.toByteArray(), algorithm);
	}

	public void init(Key key)
		throws InvalidKeyException, InvalidAlgorithmParameterException
	{
		engineInit(key, null);
	}

	protected void engineInit(Key key, AlgorithmParameterSpec params, SecureRandom random)
		throws InvalidKeyException, InvalidAlgorithmParameterException
	{
		if (!(key instanceof ECPrivateKey))
		{
			throw new InvalidKeyException("ECKeyAgreement requires ECPrivateKey for initialisation");
		} else
		{
			privKey = ECUtil.generatePrivateKeyParameter((PrivateKey)key);
			agreement.init(privKey);
			return;
		}
	}

	protected void engineInit(Key key, SecureRandom random)
		throws InvalidKeyException
	{
		if (!(key instanceof ECPrivateKey))
		{
			throw new InvalidKeyException("ECKeyAgreement requires ECPrivateKey");
		} else
		{
			privKey = ECUtil.generatePrivateKeyParameter((PrivateKey)key);
			agreement.init(privKey);
			return;
		}
	}
}