Helper class for RSA encryption and key generation(private_key.xml for .net integration)

RSAHelper.java

import java.net.URLEncoder;
import java.security.Key;
import java.security.KeyFactory;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.PublicKey;
import java.security.interfaces.RSAPrivateCrtKey;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.RSAPublicKeySpec;
import java.util.HashMap;
import java.util.Map;

import javax.crypto.Cipher;

import org.apache.commons.codec.binary.Base64;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import com.isbank.tane.analyticalapplications.PortalSettingsService;

@Component
public class RSAHelper {

	@Autowired
	private PortalSettingsService settings;

	private static final String CHAR_ENCODING = "UTF-8";
	private static final String PUBLIC_KEY_MODULUS = "public_key_modulus";
	private static final String PUBLIC_KEY_EXPONENT = "public_key_exponent";
	private static final String PRIVATE_KEY_XML = "private_key_xml";

	public String encrypt(String data) {

		try {
			KeyFactory fact = KeyFactory.getInstance("RSA");

			RSAPublicKeySpec publicKeySpec = new RSAPublicKeySpec(
					settings.getRSAPublicKeyModulus(),
					settings.getRSAPublicKeyExponent());
			PublicKey pubKey = fact.generatePublic(publicKeySpec);
			Cipher cipher = Cipher.getInstance("RSA");
			cipher.init(Cipher.ENCRYPT_MODE, pubKey);
			byte[] cipherData = cipher.doFinal(data.getBytes(CHAR_ENCODING));
			String encryptedString = Base64.encodeBase64String(cipherData);
			return URLEncoder.encode(encryptedString, CHAR_ENCODING);
		} catch (Exception e) {
			return "";
		}

	}

	public Map<String, Object> generateKeys() throws Exception {

		Map<String, Object> retVal = new HashMap<String, Object>();

		KeyPairGenerator kpg = KeyPairGenerator.getInstance("RSA");
		kpg.initialize(1024);
		KeyPair kp = kpg.genKeyPair();
		Key publicKey = kp.getPublic();
		Key privateKey = kp.getPrivate();

		KeyFactory fact = KeyFactory.getInstance("RSA");

		RSAPublicKeySpec pub = (RSAPublicKeySpec) fact.getKeySpec(publicKey,
				RSAPublicKeySpec.class);

		retVal.put(PUBLIC_KEY_MODULUS, pub.getModulus() + "");
		retVal.put(PUBLIC_KEY_EXPONENT, pub.getPublicExponent() + "");

		PKCS8EncodedKeySpec pvkKeySpec = new PKCS8EncodedKeySpec(
				privateKey.getEncoded());
		RSAPrivateCrtKey pvkKey = (RSAPrivateCrtKey) fact
				.generatePrivate(pvkKeySpec);

		retVal.put(PRIVATE_KEY_XML, privatekeyinfoToXMLRSAPriKey(pvkKey));

		return retVal;

	}

	private String privatekeyinfoToXMLRSAPriKey(RSAPrivateCrtKey pvkKey) {
		try {
			StringBuffer buff = new StringBuffer(1024);

			buff.append("<RSAKeyValue>");
			buff.append("<Modulus>"
					+ b64encode(removeMSZero(pvkKey.getModulus().toByteArray()))
					+ "</Modulus>");

			buff.append("<Exponent>"
					+ b64encode(removeMSZero(pvkKey.getPublicExponent()
							.toByteArray())) + "</Exponent>");

			buff.append("<P>"
					+ b64encode(removeMSZero(pvkKey.getPrimeP().toByteArray()))
					+ "</P>");

			buff.append("<Q>"
					+ b64encode(removeMSZero(pvkKey.getPrimeQ().toByteArray()))
					+ "</Q>");

			buff.append("<DP>"
					+ b64encode(removeMSZero(pvkKey.getPrimeExponentP()
							.toByteArray())) + "</DP>");

			buff.append("<DQ>"
					+ b64encode(removeMSZero(pvkKey.getPrimeExponentQ()
							.toByteArray())) + "</DQ>");

			buff.append("<InverseQ>"
					+ b64encode(removeMSZero(pvkKey.getCrtCoefficient()
							.toByteArray())) + "</InverseQ>");

			buff.append("<D>"
					+ b64encode(removeMSZero(pvkKey.getPrivateExponent()
							.toByteArray())) + "</D>");
			buff.append("</RSAKeyValue>");

			return buff.toString();
		} catch (Exception e) {
			return null;
		}

	}

	private byte[] removeMSZero(byte[] data) {
		byte[] data1;
		int len = data.length;
		if (data[0] == 0) {
			data1 = new byte[data.length - 1];
			System.arraycopy(data, 1, data1, 0, len - 1);
		} else
			data1 = data;

		return data1;
	}

	private final String b64encode(byte[] data) {
		return new String(Base64.encodeBase64Chunked((data))).trim();
	}

}