Java Public Private Key Encryption

Following unit test simulates usage of public-private key encryption between two nodes. Basically, Client Node requests to Server Node with a public key and Server Node returns a data back to Client Node encrypted with client provided public key. This data can only be decrypted by Client Node using private key.



RSA 2048 bit encryption is used. Public Key which is byte[] is conveyed from client node to server node as Base64 encoded. Also give attention that how Public Key is reconstructed on server side from byte [].

	import java.security.KeyFactory;
	import java.security.KeyPair;
	import java.security.KeyPairGenerator;
	import java.security.NoSuchAlgorithmException;
	import java.security.PublicKey;
	import java.security.spec.InvalidKeySpecException;
	import java.security.spec.X509EncodedKeySpec;
	import javax.crypto.Cipher;
	import junit.framework.Assert;
	import org.apache.commons.codec.binary.Base64;
	import org.junit.Before;
	import org.junit.Test;
	/**
	* This unit test simulates following scenario.
	* 1.) Client constructs Private-Public Key pair
	* 2.) Client requests to Server with Public Key
	* 3.) Server encrypts a data with Public Key and returns
	* that encrypted data back to Client
	* 4.) Client decrypts data using private Key
	* 5.) It is expected that original data encrypted by Server with Public Key
	* should be equal to decrypted with private key on Client Side
	*
	* @author ferhatk
	* @since Feb 9, 2015 4:49:39 PM
	*
	*/
	public class PublicPrivateKeyEncryptionTest {
	public static final String ALGORITHM = "RSA";
	public static final int KEY_SIZE = 2048;
	public static final String DATA_TO_ENCRYPT = "encryptMe";
	Client client;
	Server server;
	@Before
	public void setup() throws NoSuchAlgorithmException{
	client = new Client();
	System.out.println("PublicKey:");
	System.out.println(client.getPublicKeyBase64Encoded());
	System.out.println("PrivateKey:");
	System.out.println(client.getPrivateKeyBase64Encoded());
	server = new Server(client.getPublicKeyBase64Encoded());
	}
	@Test
	public void test(){
	byte[] encryptedData = server.encryptWithPublicKey(DATA_TO_ENCRYPT);
	String decryptedData = client.decryptWithPrivateKey(encryptedData);
	Assert.assertEquals(DATA_TO_ENCRYPT, decryptedData);
	}
	class Client{
	private KeyPair keyPair;
	Client() throws NoSuchAlgorithmException{
	final KeyPairGenerator keyGen = KeyPairGenerator.getInstance(ALGORITHM);
	keyGen.initialize(2048);
	keyPair = keyGen.generateKeyPair();
	}
	public String getPublicKeyBase64Encoded(){
	return encodeBase64(keyPair.getPublic().getEncoded());
	}
	public String getPrivateKeyBase64Encoded(){
	return encodeBase64(keyPair.getPrivate().getEncoded());
	}
	public String decryptWithPrivateKey(byte[] encryptedData){
	byte[] dectyptedText = null;
	try {
	final Cipher cipher = Cipher.getInstance(ALGORITHM);
	cipher.init(Cipher.DECRYPT_MODE, keyPair.getPrivate());
	dectyptedText = cipher.doFinal(encryptedData);
	} catch (Exception ex) {
	ex.printStackTrace();
	}
	return new String(dectyptedText);
	}
	}
	class Server{
	private String publicKeyBase64Encoded;
	public Server(String publicKeyBase64Encoded){
	this.publicKeyBase64Encoded = publicKeyBase64Encoded;
	}
	public String getPublicKeyBase64Encoded(){
	return publicKeyBase64Encoded;
	}
	public byte[] getPublicKeyBase64Decoded(){
	return Base64.decodeBase64(publicKeyBase64Encoded);
	}
	private PublicKey constructPublicKeyObject() throws InvalidKeySpecException, NoSuchAlgorithmException{
	return
	KeyFactory.getInstance(ALGORITHM).
	generatePublic(new X509EncodedKeySpec(getPublicKeyBase64Decoded()));
	}
	public byte[] encryptWithPublicKey(String dataToEncrypt){
	byte[] cipherText = null;
	try {
	final Cipher cipher = Cipher.getInstance(ALGORITHM);
	cipher.init(Cipher.ENCRYPT_MODE, constructPublicKeyObject());
	cipherText = cipher.doFinal(dataToEncrypt.getBytes());
	} catch (Exception e) {
	e.printStackTrace();
	}
	return cipherText;
	}
	}
	public static String encodeBase64(byte[] binaryData){
	return new String(Base64.encodeBase64(binaryData));
	}
	public static byte[] decodeBase64(String binaryData){
	return Base64.decodeBase64(binaryData);
	}
	}

view raw PublicPrivateKeyEncryptionTest.java hosted with ❤ by GitHub