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-codecEn 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 Mainpublic 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);
}
