Encriptacion utilizando el algoritmo RSA

En esta ocacion veremos un ejemplo de encriptacion sobre RSA, para entenderlo mejor ps date una leida del algoritmo

1.- Crearemos una clase RSAKeys

public class RSAKeys {
/**
RSAPrivateKey esta en java.security.interfaces
*/
 private RSAPrivateKey privateKey;
 private String exponente;
 private String modulus;
//sus metodos get y set
}

2.- Agregamos la libreria commons-codec
En mi caso utilizare commons-codec-1.5

3.- Creamos la clase RSAEncriptacion

public class RSAEncriptacion {
 
 private final String ALGORITMO="RSA";
 private final String CODIFICACION = "UTF-8";
 private final Integer LONGITUD=512;
 private final Integer BASE = 16;

}

4.- Creamos el metodo generarKeys

/**
Obtenemos una instancia de un keyPairGenerator (GENERADOR DE PAR DE LLAVES)
basado en el algoritmo RSA 

Inicializamos al generador de llaves, dandole el tamaño de la llave

En una clase KeyPair guardamos las llaves generadas

En una llave publica y privada guardamos los resultados del keyPair

En nuestra clase RSAKeys guardamos la llave privada, y el modulo y exponente
de la llave publica, esto para generarla despues. 

Esto lo puedes hacer con la llave privada
*/
public RSAKeys generarKeys() throws Exception{
 KeyPairGenerator kpg = KeyPairGenerator.getInstance(ALGORITMO);
 kpg.initialize(LONGITUD);
 KeyPair kp = kpg.genKeyPair();
 RSAPublicKey publicKey = (RSAPublicKey) kp.getPublic();
 RSAPrivateKey privateKey = (RSAPrivateKey) kp.getPrivate();  
 RSAKeys keys = new RSAKeys();
 keys.setExponente(publicKey.getPublicExponent().toString(BASE));
 keys.setModulus(publicKey.getModulus().toString(BASE));
 keys.setPrivateKey(privateKey);  
 return keys;
}

5.- Realizamos el metodo obtenPublicKey

/**
Delego las exepciones a una capa superior

Realizo una instancia de un keyFactory en base al algorimo

Creo una RSAPublicKeySpec (es diferente de un RSAPublicKey) en base al modulo 
y al exponente

Obtengo una llave publica a partir de mi fabrica de keys dandole como parametro
mi publicKeySpec

Finalmente hago un cast de mi publicKey a un RSAPublicKey
*/
public RSAPublicKey obtenPublicKey(String modulo, String exponente) 
throws NoSuchAlgorithmException, InvalidKeySpecException
{
 KeyFactory fact = KeyFactory.getInstance(ALGORITMO);
 RSAPublicKeySpec publicKey = new RSAPublicKeySpec( new BigInteger(modulo 
, BASE) , new BigInteger (exponente , BASE) );
 PublicKey pubKey = fact.generatePublic(publicKey);
 return (RSAPublicKey) pubKey;
}

6.- Realizamos el metodo Encriptar

/**
Obtengo un RSAPublicKey a partir de mi metodo antes construido

Creo una instancia de cipher en base a mi algoritmo (Recuerda que este me ayuda a
encriptar y desencriptar)

Configuro mi cipher en modo encriptador y le paso como algoritmo mi llave publica

Cifro mi texto con el metodo doFinal de cipher

Ahora por medio de la clase Hex convierto a char mi arreglo de bytes, en ves 
de utilizar el metodo HexToString del post pasado (Mas facil nop  ¬¬ )

Finalmente convierto mi char[] a String
*/
public String encriptar(String texto, String modulo, String exponente) 
throws Exception {
 RSAPublicKey publicKey = obtenPublicKey(modulo, exponente);
 Cipher cipher = Cipher.getInstance(ALGORITMO);
 cipher.init(Cipher.ENCRYPT_MODE,  publicKey);
 byte[] cifrado = cipher.doFinal(texto.getBytes());
 char [] charEncriptado = Hex.encodeHex(cifrado);
 String textoEncriptado = new String(charEncriptado);
 return textoEncriptado;
}

7.- Realizamos el metodo Desencriptar

/**
Inicializamos una instancia de cipher ...

Lo configuramos en modo Decript

Obtenemos en arreglo de bytes desencriptado

Finalmente creamos un String en base a nuestro arreglo de bytes y la codificacion
*/
public String desencriptar(String decript, RSAPrivateKey privateKey) 
 throws Exception {
 Cipher cipher = Cipher.getInstance(ALGORITMO);
 cipher.init(Cipher.DECRYPT_MODE, privateKey);
 byte[] desencriptado= Hex.decodeHex(decript.toCharArray()); 
 byte[] desci = cipher.doFinal(desencriptado);
 return new String(desci, CODIFICACION);
}

8.- Nuestro Metodo Main

public static void main(String[] args) throws Exception {
 RSAEncriptacion encriptacion = new RSAEncriptacion();  
 RSAKeys keys = encriptacion.generarKeys(); 

 String textoOriginal = "Mi Texto Original";  
 String textoEncriptado = encriptacion.encriptar(textoOriginal , keys.getModulus() , keys.getExponente());
 String textoDesencriptado = encriptacion.desencriptar(textoEncriptado, keys.getPrivateKey());
  
 System.out.println("T Encriptado: " + textoEncriptado);
 System.out.println("T Desencriptado: " + textoDesencriptado);
}