Question

how to write program in java for encrypt and decrypt input text using DH algorithm

Answer 1

	import java.io.UnsupportedEncodingException; import java.security.InvalidAlgorithmParameterException;
	import java.security.InvalidKeyException;
	import java.security.Key;
	import java.security.KeyPair;
	import java.security.KeyPairGenerator;
	import java.security.NoSuchAlgorithmException;
	import java.security.NoSuchProviderException;
	import java.security.PrivateKey;
	import java.security.PublicKey;
	import java.security.SecureRandom;
	import java.util.Enumeration;
	import javax.crypto.BadPaddingException;
	import javax.crypto.Cipher;
	import javax.crypto.IllegalBlockSizeException;
	import javax.crypto.KeyAgreement;
	import javax.crypto.NoSuchPaddingException;
	import javax.crypto.SecretKey;
	import javax.crypto.ShortBufferException;
	import javax.crypto.spec.IvParameterSpec;
	import javax.crypto.spec.SecretKeySpec;
	import org.bouncycastle.jce.ECNamedCurveTable;
	import org.bouncycastle.jce.spec.ECNamedCurveParameterSpec;
	public class Test {
	public static byte[] iv = new SecureRandom().generateSeed(16);
	public static void main(String[] args) {
	String plainText = "Look mah, I'm a message!";
	System.out.println("Original plaintext message: " + plainText);
	// Initialize two key pairs
	KeyPair keyPairA = generateECKeys();
	KeyPair keyPairB = generateECKeys();
	// Create two AES secret keys to encrypt/decrypt the message
	SecretKey secretKeyA = generateSharedSecret(keyPairA.getPrivate(),
	keyPairB.getPublic());
	SecretKey secretKeyB = generateSharedSecret(keyPairB.getPrivate(),
	keyPairA.getPublic());
	// Encrypt the message using 'secretKeyA'
	String cipherText = encryptString(secretKeyA, plainText);
	System.out.println("Encrypted cipher text: " + cipherText);
	// Decrypt the message using 'secretKeyB'
	String decryptedPlainText = decryptString(secretKeyB, cipherText);
	System.out.println("Decrypted cipher text: " + decryptedPlainText);
	}
	public static KeyPair generateECKeys() {
	try {
	ECNamedCurveParameterSpec parameterSpec = ECNamedCurveTable.getParameterSpec("brainpoolp256r1");
	KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance(
	"ECDH", "BC");
	keyPairGenerator.initialize(parameterSpec);
	KeyPair keyPair = keyPairGenerator.generateKeyPair();
	return keyPair;
	} catch (NoSuchAlgorithmException | InvalidAlgorithmParameterException
	| NoSuchProviderException e) {
	e.printStackTrace();
	return null;
	}
	}
	public static SecretKey generateSharedSecret(PrivateKey privateKey,
	PublicKey publicKey) {
	try {
	KeyAgreement keyAgreement = KeyAgreement.getInstance("ECDH", "BC");
	keyAgreement.init(privateKey);
	keyAgreement.doPhase(publicKey, true);
	SecretKey key = keyAgreement.generateSecret("AES");
	return key;
	} catch (InvalidKeyException | NoSuchAlgorithmException
	| NoSuchProviderException e) {
	// TODO Auto-generated catch block
	e.printStackTrace();
	return null;
	}
	}
	public static String encryptString(SecretKey key, String plainText) {
	try {
	IvParameterSpec ivSpec = new IvParameterSpec(iv);
	Cipher cipher = Cipher.getInstance("AES/GCM/NoPadding", "BC");
	byte[] plainTextBytes = plainText.getBytes("UTF-8");
	byte[] cipherText;
	cipher.init(Cipher.ENCRYPT_MODE, key, ivSpec);
	cipherText = new byte[cipher.getOutputSize(plainTextBytes.length)];
	int encryptLength = cipher.update(plainTextBytes, 0,
	plainTextBytes.length, cipherText, 0);
	encryptLength += cipher.doFinal(cipherText, encryptLength);
	return bytesToHex(cipherText);
	} catch (NoSuchAlgorithmException | NoSuchProviderException
	| NoSuchPaddingException | InvalidKeyException
	| InvalidAlgorithmParameterException
	| UnsupportedEncodingException | ShortBufferException
	| IllegalBlockSizeException | BadPaddingException e) {
	e.printStackTrace();
	return null;
	}
	}
	public static String decryptString(SecretKey key, String cipherText) {
	try {
	Key decryptionKey = new SecretKeySpec(key.getEncoded(),
	key.getAlgorithm());
	IvParameterSpec ivSpec = new IvParameterSpec(iv);
	Cipher cipher = Cipher.getInstance("AES/GCM/NoPadding", "BC");
	byte[] cipherTextBytes = hexToBytes(cipherText);
	byte[] plainText;
	cipher.init(Cipher.DECRYPT_MODE, decryptionKey, ivSpec);
	plainText = new byte[cipher.getOutputSize(cipherTextBytes.length)];
	int decryptLength = cipher.update(cipherTextBytes, 0,
	cipherTextBytes.length, plainText, 0);
	decryptLength += cipher.doFinal(plainText, decryptLength);
	return new String(plainText, "UTF-8");
	} catch (NoSuchAlgorithmException | NoSuchProviderException
	| NoSuchPaddingException | InvalidKeyException
	| InvalidAlgorithmParameterException
	| IllegalBlockSizeException | BadPaddingException
	| ShortBufferException | UnsupportedEncodingException e) {
	e.printStackTrace();
	return null;
	}
	}
	public static String bytesToHex(byte[] data, int length) {
	String digits = "0123456789ABCDEF";
	StringBuffer buffer = new StringBuffer();
	for (int i = 0; i != length; i++) {
	int v = data[i] & 0xff;
	buffer.append(digits.charAt(v >> 4));
	buffer.append(digits.charAt(v & 0xf));
	}
	return buffer.toString();
	}
	public static String bytesToHex(byte[] data) {
	return bytesToHex(data, data.length);
	}
	public static byte[] hexToBytes(String string) {
	int length = string.length();
	byte[] data = new byte[length / 2];
	for (int i = 0; i < length; i += 2) {
	data[i / 2] = (byte) ((Character.digit(string.charAt(i), 16) << 4) + Character
	.digit(string.charAt(i + 1), 16));
	}
	return data;
	}
	} Output: Original plaintext message : Look mah, I'm a message! Encrypted cipher text: 7AFCF3F9A6213FA6900D3DFC12553379580FC7AD362E2C2E28F548FC2AF42F07CF2B057537376F36 Decrypted cipher text: Look mah, I'm a message!