Ecriptar – Desencriptar datos utilizando una clave privada PKCS12 con JAVA ANDROID

icon_padlock

Este tutorial esta destinado a desarrolladores que quieran incorporar seguridad dentro de sus programas.

Con el fin de crear una firma digital  necesitaremos crear nuestra clave privada ( en nuestro caso del tipo P12 o PKCS12)

para ello ejecutamos la siguiente linea de codigo en la consola de windows o CMD

keytool -genkeypair -alias my_certificate -keystore my_keystore.pfx -storepass my_password -validity 365 -keyalg RSA -keysize 2048 -storetype pkcs12

Ubicaremos el archivo p12 generado en la carpeta res/raw dentro del proyecto y la instanciaremos de la siguiente manera.

KeyStore truststore = KeyStore.getInstance("PKCS12");
InputStream in = context.getResources().openRawResource(R.raw.demop12); // clave prueba 2
truststore.load(in, password.toCharArray());

o podemos seguir este tutorial para generar nuestro keystore. Este keystore lo utilizaremos para generar el algoritmo de encriptación de datos.

Creando KeyPair

Lo siguiente es generar un  Key Pair para ello utilizaremos la clase que nos provee java KeyPairGenerator en este caso crearemos un Key pair publico / privado para la firma digital  de 1024 bits de longitud.

Con el fin de crear una firma digital necesitaremos una Llave privada.

/*
 * Creamos el keypair 
 * para obtener luego las claves publicas y privadas
 */  
    KeyPair keypair = null;
    try {
        java.security.KeyPairGenerator keyGen = KeyPairGenerator.getInstance(key.getAlgorithm());
        keyGen.initialize(1024);
        keypair = keyGen.generateKeyPair();
    } catch (Exception e) {
        e.printStackTrace();
    }
/*
 * instanciacion de llaves publicas y privadas
 */
    PrivateKey privateKey = keypair.getPrivate();
    PublicKey publicKey = keypair.getPublic();

Preparando el Cipher

En Cryptografia un cipher ( Cypher) es un algoritmo para ejecutar encriptacion o desencriptación de una serie de datos siguiendo un procedimiento.  “enciphear” o codificar es convertir información de un texto plano en un codigo o cipher.

Cuando utilizamos un cipher la información original se conoce como plaintext y la encriptada como ciphertext.

El texto ciphertext contiene toda la información del plaintext, pero no de una forma legible para nosotros ni para computadoras. Solo va a ser legible utilizando el apropiado mecanismo de desencriptación.

La operación de un cypher usualmente depende de una pieza de información auxiliar llamada Key. El proceso de encriptacion varia dependiendo de la Key que cambiara el detalle del algoritmo de la operación.

La key  debe seleccionarse antes de utilizar un cipher. Sin el conocimiento de una  key  debe ser imposible si no es que es imposible desencriptar un ciphertext  en un legible plaintext.

//------------------------------------------------------------------------------------------------------------------------
 // Instanciando Cipher 
 //------------------------------------------------------------------------------------------------------------------------
 /*
 * cipher - proceso de ecriptacion de datos para encriptar y desencriptar
 * en este caso utilizando el algoritmo extraido desde nuestro keystore ( archivo p12 )
 */
    Cipher cipher = null;
    try {
        cipher = Cipher.getInstance(key.getAlgorithm());
    } catch (NoSuchAlgorithmException e1) {
        e1.printStackTrace();
    } catch (NoSuchPaddingException e1) {
        e1.printStackTrace();
   }

Encriptando y desencriptando datos

A continuación lo que nos queda es como encriptar y desencriptar datos, para ello se muestran los ejemplos en código.

public byte[] encryptPkcs12(String text,KeyPair keypair,Cipher cipher) {
    byte[] cipherText = null;
    try {
        cipher.init(Cipher.ENCRYPT_MODE, keypair.getPrivate() );
        cipherText = cipher.doFinal(text.getBytes());
    } catch (Exception e) {
        e.printStackTrace();
    }
    return cipherText;
 }
public String decryptPkcs12(byte[] cipherBytes,KeyPair keypair,Cipher cipher) {
    try {
       cipher.init(Cipher.DECRYPT_MODE, keypair.getPublic());
       byte[] newMD = cipher.doFinal(cipherBytes);
       String plainStr = new String(newMD, "UTF8");
       return plainStr;
    } catch (GeneralSecurityException e) {
        throw new RuntimeException(e);
    } catch (UnsupportedEncodingException e) {
        throw new RuntimeException(e);
    }
 }
Anuncios

About exequielc

Hola! Estás en el blog de Exequiel Catalani. Como es un blog, se trata de una extensión más o menos lineal de las cosas que hago y pasan por mi cabeza: ciberculturas, videos de la red, nuevos medios y tecnologia, y Programacion etc...

Responder

Por favor, inicia sesión con uno de estos métodos para publicar tu comentario:

Logo de WordPress.com

Estás comentando usando tu cuenta de WordPress.com. Cerrar sesión / Cambiar )

Imagen de Twitter

Estás comentando usando tu cuenta de Twitter. Cerrar sesión / Cambiar )

Foto de Facebook

Estás comentando usando tu cuenta de Facebook. Cerrar sesión / Cambiar )

Google+ photo

Estás comentando usando tu cuenta de Google+. Cerrar sesión / Cambiar )

Conectando a %s

A %d blogueros les gusta esto: