package org.bouncycastle.jce.provider;import java.math.BigInteger;import java.security.InvalidAlgorithmParameterException;import java.security.InvalidKeyException;import java.security.Key;import java.security.SecureRandom;import java.security.spec.AlgorithmParameterSpec;import javax.crypto.KeyAgreementSpi;import javax.crypto.SecretKey;import javax.crypto.ShortBufferException;import javax.crypto.interfaces.DHPrivateKey;import javax.crypto.interfaces.DHPublicKey;import javax.crypto.spec.DHParameterSpec;import javax.crypto.spec.SecretKeySpec;/** * Diffie-Hellman key agreement. There's actually a better way of doing this * if you are using long term public keys, see the light-weight version for * details. */public class JCEDHKeyAgreement    extends KeyAgreementSpi{    private BigInteger      x;    private BigInteger      p;    private BigInteger      g;    private BigInteger      result;    private SecureRandom    random;        private byte[] bigIntToBytes(        BigInteger    r)    {        byte[]    tmp = r.toByteArray();                if (tmp[0] == 0)        {            byte[]    ntmp = new byte[tmp.length - 1];                        System.arraycopy(tmp, 1, ntmp, 0, ntmp.length);            return ntmp;        }                return tmp;    }        protected Key engineDoPhase(        Key     key,        boolean lastPhase)         throws InvalidKeyException, IllegalStateException    {        if (x == null)        {            throw new IllegalStateException("Diffie-Hellman not initialised.");        }        if (!(key instanceof DHPublicKey))        {            throw new InvalidKeyException("DHKeyAgreement doPhase requires DHPublicKey");        }        DHPublicKey pubKey = (DHPublicKey)key;        if (!pubKey.getParams().getG().equals(g) || !pubKey.getParams().getP().equals(p))        {            throw new InvalidKeyException("DHPublicKey not for this KeyAgreement!");        }        if (lastPhase)        {            result = ((DHPublicKey)key).getY().modPow(x, p);            return null;        }        else        {            result = ((DHPublicKey)key).getY().modPow(x, p);        }        return new JCEDHPublicKey(result, pubKey.getParams());    }    protected byte[] engineGenerateSecret()         throws IllegalStateException    {        if (x == null)        {            throw new IllegalStateException("Diffie-Hellman not initialised.");        }        return bigIntToBytes(result);    }    protected int engineGenerateSecret(        byte[]  sharedSecret,        int     offset)         throws IllegalStateException, ShortBufferException    {        if (x == null)        {            throw new IllegalStateException("Diffie-Hellman not initialised.");        }        byte[]  secret = bigIntToBytes(result);        if (sharedSecret.length - offset < secret.length)        {            throw new ShortBufferException("DHKeyAgreement - buffer too short");        }        System.arraycopy(secret, 0, sharedSecret, offset, secret.length);        return secret.length;    }    protected SecretKey engineGenerateSecret(        String algorithm)     {        if (x == null)        {            throw new IllegalStateException("Diffie-Hellman not initialised.");        }                return new SecretKeySpec(bigIntToBytes(result), algorithm);    }    protected void engineInit(        Key                     key,        AlgorithmParameterSpec  params,        SecureRandom            random)         throws InvalidKeyException, InvalidAlgorithmParameterException    {        if (!(key instanceof DHPrivateKey))        {            throw new InvalidKeyException("DHKeyAgreement requires DHPrivateKey for initialisation");        }        DHPrivateKey    privKey = (DHPrivateKey)key;        this.random = random;        if (params != null)        {            if (!(params instanceof DHParameterSpec))            {                throw new InvalidAlgorithmParameterException("DHKeyAgreement only accepts DHParameterSpec");            }            DHParameterSpec p = (DHParameterSpec)params;            this.p = p.getP();            this.g = p.getG();        }        else        {            this.p = privKey.getParams().getP();            this.g = privKey.getParams().getG();        }        this.x = this.result = privKey.getX();    }    protected void engineInit(        Key             key,        SecureRandom    random)         throws InvalidKeyException    {        if (!(key instanceof DHPrivateKey))        {            throw new InvalidKeyException("DHKeyAgreement requires DHPrivateKey");        }        DHPrivateKey    privKey = (DHPrivateKey)key;        this.random = random;        this.p = privKey.getParams().getP();        this.g = privKey.getParams().getG();        this.x = this.result = privKey.getX();    }}