Diffie-Hellman Key Agreement

import java.math.BigInteger;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.MessageDigest;
import java.security.SecureRandom;
import java.security.Security;

import javax.crypto.KeyAgreement;
import javax.crypto.spec.DHParameterSpec;

public class MainClass {
private static BigInteger g512 = new BigInteger("1234567890", 16);

private static BigInteger p512 = new BigInteger("1234567890", 16);

public static void main(String[] args) throws Exception {
Security.addProvider(new org.bouncycastle.jce.provider.BouncyCastleProv
ider());

DHParameterSpec dhParams = new DHParameterSpec(p512, g512);
KeyPairGenerator keyGen = KeyPairGenerator.getInstance("DH", "BC");

keyGen.initialize(dhParams, new SecureRandom());

KeyAgreement aKeyAgree = KeyAgreement.getInstance("DH", "BC");
KeyPair aPair = keyGen.generateKeyPair();
KeyAgreement bKeyAgree = KeyAgreement.getInstance("DH", "BC");
KeyPair bPair = keyGen.generateKeyPair();

aKeyAgree.init(aPair.getPrivate());
bKeyAgree.init(bPair.getPrivate());

aKeyAgree.doPhase(bPair.getPublic(), true);
bKeyAgree.doPhase(aPair.getPublic(), true);

MessageDigest hash = MessageDigest.getInstance("SHA1", "BC");
System.out.println(new String(hash.digest(aKeyAgree.generateSecret())))
;
System.out.println(new String(hash.digest(bKeyAgree.generateSecret())))
;
}
}
Diffie-Hellman with Elliptic Curve
import java.math.BigInteger;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.MessageDigest;
import java.security.SecureRandom;
import java.security.Security;
import java.security.spec.ECFieldFp;
import java.security.spec.ECParameterSpec;
import java.security.spec.ECPoint;
import java.security.spec.EllipticCurve;

import javax.crypto.KeyAgreement;

public class MainClass {
public static void main(String[] args) throws Exception {
Security.addProvider(new org.bouncycastle.jce.provider.BouncyCastleProv
ider());

KeyPairGenerator keyGen = KeyPairGenerator.getInstance("ECDH", "BC");
EllipticCurve curve = new EllipticCurve(new ECFieldFp(new BigInteger("f
ffffffffffffffffffffffffffffffeffffffffffffffff", 16)), new BigInteger("fff
ffffffffffffffffffffffffffffefffffffffffffffc", 16), new BigInteger("ffffff
fffffffffffffffffffffffffefffffffffffffffc", 16));

ECParameterSpec ecSpec = new ECParameterSpec(curve, new ECPoint(new Big
Integer("fffffffffffffffffffffffffffffffefffffffffffffffc", 16), new BigInt
eger("fffffffffffffffffffffffffffffffefffffffffffffffc", 16)), new BigInteg
er("fffffffffffffffffffffffffffffffefffffffffffffffc", 16), 1);

keyGen.initialize(ecSpec, new SecureRandom());

KeyAgreement aKeyAgree = KeyAgreement.getInstance("ECDH", "BC");
KeyPair aPair = keyGen.generateKeyPair();
KeyAgreement bKeyAgree = KeyAgreement.getInstance("ECDH", "BC");
KeyPair bPair = keyGen.generateKeyPair();

aKeyAgree.init(aPair.getPrivate());
bKeyAgree.init(bPair.getPrivate());

aKeyAgree.doPhase(bPair.getPublic(), true);
bKeyAgree.doPhase(aPair.getPublic(), true);

MessageDigest hash = MessageDigest.getInstance("SHA1", "BC");

System.out.println(new String(hash.digest(aKeyAgree.generateSecret())))
;
System.out.println(new String(hash.digest(bKeyAgree.generateSecret())))
;
}
}
Implementing the Diffie-Hellman key
exchange
import java.math.BigInteger;
import java.security.KeyFactory;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.SecureRandom;

import javax.crypto.spec.DHParameterSpec;
import javax.crypto.spec.DHPublicKeySpec;

public class MainClass {
public final static int pValue = 47;

public final static int gValue = 71;

public final static int XaValue = 9;

public final static int XbValue = 14;

public static void main(String[] args) throws Exception {
BigInteger p = new BigInteger(Integer.toString(pValue));
BigInteger g = new BigInteger(Integer.toString(gValue));
BigInteger Xa = new BigInteger(Integer.toString(XaValue));
BigInteger Xb = new BigInteger(Integer.toString(XbValue));

createKey();

int bitLength = 512; // 512 bits
SecureRandom rnd = new SecureRandom();
p = BigInteger.probablePrime(bitLength, rnd);
g = BigInteger.probablePrime(bitLength, rnd);

createSpecificKey(p, g);
}

public static void createKey() throws Exception {
KeyPairGenerator kpg = KeyPairGenerator.getInstance("DiffieHellman");

kpg.initialize(512);
KeyPair kp = kpg.generateKeyPair();
KeyFactory kfactory = KeyFactory.getInstance("DiffieHellman");

DHPublicKeySpec kspec = (DHPublicKeySpec) kfactory.getKeySpec(kp.getPub
lic(),
DHPublicKeySpec.class);
}

public static void createSpecificKey(BigInteger p, BigInteger g) throws E
xception {
KeyPairGenerator kpg = KeyPairGenerator.getInstance("DiffieHellman");

DHParameterSpec param = new DHParameterSpec(p, g);
kpg.initialize(param);
KeyPair kp = kpg.generateKeyPair();

KeyFactory kfactory = KeyFactory.getInstance("DiffieHellman");

DHPublicKeySpec kspec = (DHPublicKeySpec) kfactory.getKeySpec(kp.getPub
lic(),
DHPublicKeySpec.class);
}
}
Generating a Parameter Set for the Diffie-Hellman
Key Agreement Algorithm
import java.security.AlgorithmParameterGenerator;
import java.security.AlgorithmParameters;

import javax.crypto.spec.DHParameterSpec;

public class Main {
public static void main(String[] argv) throws Exception {
AlgorithmParameterGenerator paramGen = AlgorithmParameterGenerator.getI
nstance("DH");
paramGen.init(1024);

AlgorithmParameters params = paramGen.generateParameters();
DHParameterSpec dhSpec = (DHParameterSpec) params.getParameterSpec(DHPa
rameterSpec.class);

System.out.println("" + dhSpec.getP() + "," + dhSpec.getG() + "," + dhS
pec.getL());
}
}