How to use

KeyAgreement

in

javax.crypto

public KeyAgreement diffieHellman(boolean side, int keySize) throws IOException, GeneralSecurityException {
  KeyPair keyPair;
  PublicKey otherHalf;
  if (side) {
    AlgorithmParameterGenerator paramGen = AlgorithmParameterGenerator.getInstance("DH");
    paramGen.init(keySize);
    KeyPairGenerator dh = KeyPairGenerator.getInstance("DH");
    dh.initialize(paramGen.generateParameters().getParameterSpec(DHParameterSpec.class));
    keyPair = dh.generateKeyPair();
    // send a half and get a half
    writeKey(keyPair.getPublic());
    otherHalf = KeyFactory.getInstance("DH").generatePublic(readKey());
  } else {
    otherHalf = KeyFactory.getInstance("DH").generatePublic(readKey());
    KeyPairGenerator keyPairGen = KeyPairGenerator.getInstance("DH");
    keyPairGen.initialize(((DHPublicKey) otherHalf).getParams());
    keyPair = keyPairGen.generateKeyPair();
    // send a half and get a half
    writeKey(keyPair.getPublic());
  }
  KeyAgreement ka = KeyAgreement.getInstance("DH");
  ka.init(keyPair.getPrivate());
  ka.doPhase(otherHalf, true);
  return ka;
}

 private static byte[] generateSecret(String dhSKAlgo, PrivateKey privateKey,
   PublicKey otherPublicKey) throws Exception {
  KeyAgreement ka = KeyAgreement.getInstance("DH");
  ka.init(privateKey);
  ka.doPhase(otherPublicKey, true);

  int keysize = getKeySize(dhSKAlgo);
  int blocksize = getBlockSize(dhSKAlgo);

  if (keysize == -1 || blocksize == -1) {
   SecretKey sKey = ka.generateSecret(dhSKAlgo);
   return sKey.getEncoded();
  } else {
   return ka.generateSecret();
  }
 }
}

@Override
void computeK(byte[] f) throws GeneralSecurityException {
  final KeyFactory keyFactory = SecurityUtils.getKeyFactory("DH");
  final PublicKey yourPubKey = keyFactory.generatePublic(new DHPublicKeySpec(new BigInteger(f), p, g));
  agreement.doPhase(yourPubKey, true);
  setK(new BigInteger(1, agreement.generateSecret()));
}

@Override
public void init(AlgorithmParameterSpec params, Factory<Random> randomFactory) throws GeneralSecurityException {
  if (!(params instanceof DHParameterSpec)) {
    throw new SSHRuntimeException("Wrong algorithm parameters for Diffie Hellman");
  }
  this.p = ((DHParameterSpec) params).getP();
  this.g = ((DHParameterSpec) params).getG();
  generator.initialize(params);
  final KeyPair kp = generator.generateKeyPair();
  agreement.init(kp.getPrivate());
  setE(((javax.crypto.interfaces.DHPublicKey) kp.getPublic()).getY().toByteArray());
}

public DHPublicKey init(DHParameterSpec dhParamSpec) throws Exception {
  dhParameterSpec = dhParamSpec;
  // The client creates its own DH key pair, using the DH parameters from above.
  KeyPairGenerator clientKpairGen = KeyPairGenerator.getInstance("DH");
  clientKpairGen.initialize(dhParamSpec);
  KeyPair clientKpair = clientKpairGen.generateKeyPair();
  // The client creates and initializes its DH KeyAgreement object.
  clientKeyAgree = KeyAgreement.getInstance("DH");
  clientKeyAgree.init(clientKpair.getPrivate());
  // The client encodes its public key, and sends it over to the server.
  return (DHPublicKey) clientKpair.getPublic();
}

@Override
public byte[] getK() throws Exception {
  if( _K == null ) {
    KeyFactory myKeyFac = KeyFactory.getInstance("DH");
    PublicKey yourPubKey = myKeyFac.generatePublic(new DHPublicKeySpec(_f, _p, _g));
    _keyAgreement.doPhase(yourPubKey, true);
    byte[] mySharedSecret = _keyAgreement.generateSecret();
    _K = new BigInteger(mySharedSecret);
    //_KArray = _K.toByteArray();	// TODO Why assign twice?
    _KArray = mySharedSecret;
  }
  return _KArray;
}

protected void handleSecretKeyRequest(PublicKey dh_public_key, Address sender) throws Exception {
  KeyPair    kp=key_pair_gen.generateKeyPair();
  PrivateKey private_key=kp.getPrivate();
  PublicKey  public_key_rsp=kp.getPublic(); // sent back as part of the response
  byte[]     version;
  byte[]     encrypted_secret_key;
  log.debug("%s: received public key %s.. from %s", local_addr, print16(dh_public_key), sender);
  synchronized(this) {
    key_agreement.init(private_key);
    key_agreement.doPhase(dh_public_key, true);
    // Diffie-Hellman secret session key, to encrypt secret key
    byte[] secret_session_key=key_agreement.generateSecret();
    SecretKey hashed_session_key=hash(secret_session_key);
    Cipher encrypter=Cipher.getInstance(secret_key_algorithm);
    encrypter.init(Cipher.ENCRYPT_MODE, hashed_session_key);
    Tuple<SecretKey,byte[]> tuple=(Tuple<SecretKey,byte[]>)up_prot.up(new Event(Event.GET_SECRET_KEY));
    SecretKey secret_key=tuple.getVal1();
    version=tuple.getVal2();
    encrypted_secret_key=encrypter.doFinal(secret_key.getEncoded());
  }
  log.debug("%s: sending public key rsp %s.. to %s", local_addr, print16(public_key_rsp), sender);
  // send response to sender with public_key_rsp, encrypted secret key and secret key version
  Message rsp=new Message(sender)
   .putHeader(id, DhHeader.createSecretKeyResponse(public_key_rsp.getEncoded(),
                           encrypted_secret_key, version));
  down_prot.down(rsp);
}

KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
PublicKey pubKey = keyFactory.generatePublic(x509KeySpec);
PrivateKey priKey = keyFactory.generatePrivate(pkcs8KeySpec);
KeyAgreement keyAgree = KeyAgreement.getInstance(keyFactory.getAlgorithm());
keyAgree.init(priKey);
keyAgree.doPhase(pubKey, true);
SecretKey secretKey = keyAgree.generateSecret(SECRET_KEY_ALGORITHM);

 KeyPairGenerator eckpg = KeyPairGenerator.getInstance("EC");
ECGenParameterSpec p256 = new ECGenParameterSpec("secp256r1");
eckpg.initialize(p256);
KeyPair doubleUseKeyPair = eckpg.generateKeyPair();
KeyAgreement ecdh = KeyAgreement.getInstance("ECDH");
ecdh.init(doubleUseKeyPair.getPrivate());
// ...

Signature ecdsa = Signature.getInstance("SHA256withECDSA");
ecdsa.initSign(doubleUseKeyPair.getPrivate());
// ...

System.out.println(eckpg.getProvider());
System.out.println(ecdh.getProvider());
System.out.println(ecdsa.getProvider());

KeyFactory keyFact = KeyFactory.getInstance("DH");
pubKey = keyFact.generatePublic(x509KeySpec);
KeyAgreement ka = KeyAgreement.getInstance("DH");
ka.init(dhPrivateKey);
ka.doPhase(pubKey, true);
 SecretKey sKey = ka.generateSecret(skAlgo);
 decrypt = Cipher.getInstance(skAlgo);
 decrypt.init(Cipher.DECRYPT_MODE, sKey);
 String algoStr = getDhAlgoStr(skAlgo);
 byte[] sKeyBytes = ka.generateSecret();
 SecretKeySpec sks = new SecretKeySpec(sKeyBytes, 0, keysize, algoStr);
 IvParameterSpec ivps = new IvParameterSpec(sKeyBytes, keysize, blocksize);

public void doPhase(byte[] serverPubKeyEnc) throws Exception {
  /*
   * The client uses the server's public key for the first (and only) phase
   * of its version of the DH protocol.  Before it can do so, it has to
   * instantiate a DH public key from the server's encoded key material.
   */
  KeyFactory clientKeyFac = KeyFactory.getInstance("DH");
  X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(serverPubKeyEnc);
  PublicKey serverPubKey = clientKeyFac.generatePublic(x509KeySpec);
  clientKeyAgree.doPhase(serverPubKey, true);
}

public void init() throws Exception{
 myKpairGen=KeyPairGenerator.getInstance("DH");
 myKeyAgree=KeyAgreement.getInstance("DH");
}
public byte[] getE() throws Exception{

public static ECDHKeySet getSharedSecret (ECKey keyServer, ECKey keyClient) {
  try {
    ECPrivateKeySpec specPrivate = new ECPrivateKeySpec(keyServer.getPrivKey(), ecParameters);
    ECPublicKeySpec specPublic = new ECPublicKeySpec(new ECPoint(keyClient.getPubKeyPoint().getXCoord().toBigInteger(), keyClient.getPubKeyPoint()
        .getYCoord().toBigInteger()), ecParameters);
    ECPrivateKey privateKey = (ECPrivateKey) kf.generatePrivate(specPrivate);
    ECPublicKey publicKey = (ECPublicKey) kf.generatePublic(specPublic);
    JCEECPrivateKey ecPrivKey = new JCEECPrivateKey(privateKey);
    JCEECPublicKey ecPubKey = new JCEECPublicKey(publicKey);
    KeyAgreement aKeyAgree = KeyAgreement.getInstance("ECDH");
    aKeyAgree.init(ecPrivKey);
    aKeyAgree.doPhase(ecPubKey, true);
    return new ECDHKeySet(aKeyAgree.generateSecret(), keyServer.getPubKey(), keyClient.getPubKey());
  } catch (Exception e) {
    throw new RuntimeException(e);
  }
}

public static KeyAgreement getInitializedKeyAgreement(KeyPair keyPair) {
  KeyAgreement keyAgreement = null;
  try {
    keyAgreement = KeyAgreement.getInstance(DIFFIE_HELLMAN);
    keyAgreement.init(keyPair.getPrivate());
    return keyAgreement;
  } catch (NoSuchAlgorithmException e) {
    throw new RuntimeException(e);
  } catch (InvalidKeyException e) {
    throw new RuntimeException(e);
  }
}

public BigInteger keyAgreement(ECPoint otherParty) {
  if (privKey == null) {
    throw new MissingPrivateKeyException();
  } else if (privKey instanceof BCECPrivateKey) {
    final ECDHBasicAgreement agreement = new ECDHBasicAgreement();
    agreement.init(new ECPrivateKeyParameters(((BCECPrivateKey) privKey).getD(), CURVE));
    return agreement.calculateAgreement(new ECPublicKeyParameters(otherParty, CURVE));
  } else {
    try {
      final KeyAgreement agreement = ECKeyAgreement.getInstance(this.provider);
      agreement.init(this.privKey);
      agreement.doPhase(
        ECKeyFactory.getInstance(this.provider)
          .generatePublic(new ECPublicKeySpec(otherParty, CURVE_SPEC)),
          /* lastPhase */ true);
      return new BigInteger(1, agreement.generateSecret());
    } catch (IllegalStateException | InvalidKeyException | InvalidKeySpecException ex) {
      throw new RuntimeException("ECDH key agreement failure", ex);
    }
  }
}

public void init(int size) throws Exception{
 myKeyAgree = KeyAgreement.getInstance("ECDH");
 KeyPairGenECDSA kpair = new KeyPairGenECDSA();
 kpair.init(size);
 publicKey = kpair.getPublicKey();
 byte[] r = kpair.getR();
 byte[] s = kpair.getS();
 Q_array = toPoint(r, s);
 myKeyAgree.init(kpair.getPrivateKey());
}

public static KeyAgreement getInstance(final String provider) throws NoSuchProviderException {
 try {
  return KeyAgreement.getInstance(ALGORITHM, provider);
 } catch (NoSuchAlgorithmException ex) {
  throw new AssertionError(algorithmAssertionMsg, ex);
 }
}

public static KeyAgreement generateKeyAgreement(PrivateKey privateKey, PublicKey publicKey) throws NoSuchAlgorithmException, InvalidKeyException {
  KeyAgreement keyAgreement = KeyAgreement.getInstance(AlgorithmName.DH);
  keyAgreement.init(privateKey);
  keyAgreement.doPhase(publicKey, true);
  return keyAgreement;
}

public SecretKey calculateKeyAgreement(String agreementAlgorithm, PrivateKey privateKey, PublicKey publicKey, String secretAlgorithm)
  throws GeneralSecurityException
{
  KeyAgreement agreement = helper.createKeyAgreement(agreementAlgorithm);
  agreement.init(privateKey);
  agreement.doPhase(publicKey, true);
  return agreement.generateSecret(secretAlgorithm);
}

protected void handleSecretKeyResponse(PublicKey dh_public_key, byte[] encrypted_secret_key,
                    byte[] version, Address sender) throws Exception {
  Tuple<SecretKey,byte[]> tuple=null;
  log.debug("%s: received public key rsp %s.. from %s", local_addr, print16(dh_public_key), sender);
  synchronized(this) {
    key_agreement.doPhase(dh_public_key, true);
    // Diffie-Hellman secret session key, to decrypt secret key
    byte[] secret_session_key=key_agreement.generateSecret();
    SecretKey hashed_session_key=hash(secret_session_key);
    Cipher encrypter=Cipher.getInstance(secret_key_algorithm);
    encrypter.init(Cipher.DECRYPT_MODE, hashed_session_key);
    byte[] secret_key=encrypter.doFinal(encrypted_secret_key); // <-- this is the shared group key
    SecretKey sk=new SecretKeySpec(secret_key, secret_key_algorithm);
    tuple=new Tuple<>(sk, version);
    dh_key=null;
  }
  log.debug("%s: sending up secret key (version: %s)", local_addr, Util.byteArrayToHexString(version));
  up_prot.up(new Event(Event.SET_SECRET_KEY, tuple));
}