some image

Tag Criptografia

Cifrar y Descifrar en Java con nuestro propio charset

Etiquetas: , Blog, Programación No comments

¿Cuantas veces has deseado cifrar (encriptar) tus mensajes para pasarlos a un amigo, y que el pueda descifrarlos (decriptar) con una equivalencia para cada letra definida por uds.?. Bueno este algoritmo implementado en Java quizas es muy conocido y facil de utilizar.

Basicamente consiste en 3 partes :

1) Se define el charset (codificacion de caracteres) utilizados para cifrar y descifrar el mensaje.

2) Se utiliza un metodo que cifra el mensaje , donde se reemplaza cada caracter del charset 1 al charset 2 y voila!!!

2) Se utiliza un metodo que descifra el mensaje haciendo la inversa del metodo anterior, donde se reemplaza cada caracter del charset 2 al charset 1 y Hakuna Matata!!

Aqui esta el código

/***
 * Clase : Cipher
 * Clase de ejemplo que muestra una forma sencilla para
 * cifrar y descifrar un texto basado en un charset definidos
 * por nosotros mismos.
 * 
 * @author [D-m-K]
 * http://codesandtags.org
 */

public class Cipher {
	
	//Charset de caracteres cuando se cifra
	private String charset1 = "1234567890!#$%&/()=¿?¡_-+*:";
	//Charset de caracteres cuando se descifra
	private String charset2 = "abcdefghijklmnopqrstuvwxyz ";
	
	/**
	 * Metodo que recibe un texto y cifra el contenido de 
	 * acuerdo a los charset definidos
	 * @param texto
	 * @return texto
	 */
	public String cifrar(String texto){
		//Convierto a minuscula las letras del alfabeto que existan en el texto
		texto = texto.toLowerCase();
		//Reemplazo los caracteres del charset2 con los del charset1
		for (int i = 0; i < charset2.length(); i++) {
			texto = texto.replace(charset2.charAt(i), charset1.charAt(i));
		}
		//Retorno el texto cifrado con el charset2
		return texto;
	}
	
	/**
	 * Metodo que recibe un texto y descifra el contenido de 
	 * acuerdo a los charset definidos
	 * @param texto
	 * @return texto
	 */
	public String descifrar(String texto){
		//Convierto a minuscula las letras del alfabeto que existan en el texto
		texto = texto.toLowerCase();
		//Reemplazo los caracteres del charset1 con los del charset2
		for (int i = 0; i < charset1.length(); i++) {
			texto = texto.replace(charset1.charAt(i), charset2.charAt(i));
		}
		//Retorno el texto cifrado con el charset2
		return texto;
	}
	
	public static void main(String[] args){
		
		//Instancia de la clase Cipher y creacion de un nuevo objeto
		Cipher cipher = new Cipher();
		
		//Cifrando texto
		String textoCifrado = cipher.cifrar("codes and tags... ");
		System.out.println(textoCifrado);
		
		//Descifrando texto
		String textoDescifrado = cipher.descifrar(textoCifrado); 
		System.out.println(textoDescifrado);
		
		//Ejemplo con varias cadenas
		String[] cadenas = new String[4];
		cadenas[0] = "Los pollitos dicen, pio pio pio... cuando tienen hambre, cuando tienen frio";
		cadenas[1] = "Habia una vez una iguana con una cara de rana";
		cadenas[2] = "Hoy es Sabado y esta lloviendo en bogota, que vaina...";
		cadenas[3] = "Este es mi ultimo ejemplo jejeje....";
		
		//Cifrando cada cadena del arreglo
		System.out.println("\n Cifrando unas cuantas cadenas...");
		for (int i = 0; i < cadenas.length; i++) {
			cadenas[i] = cipher.cifrar(cadenas[i]);
			System.out.println("Cadena " + (i + 1) + " : " + cadenas[i]);
		}
		
		//Ahora Descifrando el contenido de las cadenas
		System.out.println("\n Descifrando las cadenas de ahorita...");
		for (int i = 0; i < cadenas.length; i++) {
			cadenas[i] = cipher.descifrar(cadenas[i]);
			System.out.println("Cadena " + (i + 1) + " : " + cadenas[i]);
		}
	}
}

Datos de salida

3&45=:1%4:¿17=...:
codes and tags... 

 Cifrando unas cuantas cadenas...
Cadena 1 : #&=:/&##9¿&=:4935%,:/9&:/9&:/9&...:3?1%4&:¿95%5%:81$2)5,:3?1%4&:¿95%5%:6)9&
Cadena 2 : 81291:?%1:¡5*:?%1:97?1%1:3&%:?%1:31)1:45:)1%1
Cadena 3 : 8&+:5=:=1214&:+:5=¿1:##&¡95%4&:5%:2&7&¿1,:(?5:¡19%1...
Cadena 4 : 5=¿5:5=:$9:?#¿9$&:505$/#&:050505....

 Descifrando las cadenas de ahorita...
Cadena 1 : los pollitos dicen, pio pio pio... cuando tienen hambre, cuando tienen frio
Cadena 2 : habia una vez una iguana con una cara de rana
Cadena 3 : hoy es sabado y esta lloviendo en bogota, que vaina...
Cadena 4 : este es mi ultimo ejemplo jejeje....

Generando Hash en Java (MessageDigest)

Etiquetas: , Blog, Programación No comments

Muchas veces la seguridad de los datos se vuelve importante dependiendo el medio donde nos movamos y el tipo de datos que manejemos (contraseñas, numeros de tarjetas, codigos de seguridad, seriales, etc…). En Java se puede utilizar la clase MessageDigest para generar este tipo de hash :).

En esta clase Criptography, muestro un ejemplo de como implementar diferentes algoritmos para generar Hash (MD2, MD5, SHA1, SHA256, SHA512, CRC32).

import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.util.zip.CRC32;
import java.util.zip.Checksum;

/**
 * 
 * Clase que permite obtener diferentes hash en Java, utilizando la clase
 * MessageDigest
 * 
 */
public class Criptography {

	// Miembros de clase
	private String texto = "";
	private Algoritmo algoritmo = null;

	// Constantes
	public static final String VERSION = "1.0";

	/**
	 * Constructor que puede inicializar el algoritmo a utilizar
	 * 
	 * @param texto
	 */
	public Criptography(Algoritmo algoritmo) {
		this.algoritmo = algoritmo;
	}

	public Criptography() {
	}

	/**
	 * Enumeracion de algoritmos soportados por la clase Criptography
	 */
	public enum Algoritmo {
		// Declaracion del nombre de cada algoritmo
		MD2("MD2"), MD5("MD5"), SHA1("SHA-1"), SHA256("SHA-256"), SHA512(
				"SHA-512"), CRC32("CRC32");

		// nombre del algoritmo
		private String nombre;

		// Constructor que inicializa los nombres de los algoritmos disponibles
		private Algoritmo(String nombre) {
			this.nombre = nombre;
		}

		// Devuelve el nombre del algoritmo que se esta usando
		private String getNombre() {
			return nombre;
		}
	}

	/**
	 * Getters an Setters de la clase
	 */
	public String getTexto() {
		return texto;
	}

	public Algoritmo getAlgoritmo() {
		return algoritmo;
	}

	public void setAlgoritmo(Algoritmo algoritmo) {
		this.algoritmo = algoritmo;
	}

	/**
	 * Genera el hash del texto definido en la clase
	 * 
	 * @return hash
	 */
	public String generateHash(String texto) {
		this.texto = texto;
		// Variable que almacena el criptograma generado
		String hash = "";
		// Variable que guardara el digest generado
		byte[] digest = null;
		// Variable que obtiene el buffer del texto
		byte[] buffer = texto.getBytes();

		switch (algoritmo) {
		case MD2:
		case MD5:
		case SHA1:
		case SHA256:
		case SHA512:
			// Se intenta obtener el Message Digest del algoritmo
			// seleccionado. Esto es en base a la clase MessageDigest
			// del paquete Security de Java
			try {
				// Instancio un objeto MessageDigest con el algoritmo apropiado
				MessageDigest md = MessageDigest.getInstance(algoritmo
						.getNombre());
				// Reseteo el digest que pueda existir en el objeto
				md.reset();
				// Envio el buffer el mensaje a encriptar
				md.update(buffer);
				// Obtengo el Digest del Message
				digest = md.digest();
				// Obtengo la cadena del hash en valores hexadecimales
				hash = toHexadecimal(digest);
			} catch (NoSuchAlgorithmException e) {
				// Controlo el mensaje de cualquier excepcion generada
				e.printStackTrace();
			}
			break;

		case CRC32:
			// Obtengo el CRC32 del texto ingresado
			hash = getCRC32();
			break;
		}
		// retorna el criptograma generado
		return hash;
	}

	/**
	 * Para los algoritmos que tienen hash, hace la conversion del arreglo de
	 * bytes[] generado a una cadena String
	 * 
	 * @param digest
	 * @return hash
	 */
	private String toHexadecimal(byte[] digest) {
		String hash = "";
		for (byte aux : digest) {
			int b = aux & 0xff; // Hace un cast del byte a hexadecimal
			if (Integer.toHexString(b).length() == 1)
				hash += "0";
			hash += Integer.toHexString(b);
		}
		return hash;
	}

	/**
	 * Obtiene el Checksum 32 (CRC32) del texto ingresado
	 * 
	 * @return
	 */
	private String getCRC32() {
		String hash = null;
		byte[] bytes = texto.getBytes();
		// Objeto Checksum
		Checksum crc32 = new CRC32();
		// Inicializo el objeto
		crc32.reset();
		// Actualizo la con el arreglo de bytes que obtengo del texto
		crc32.update(bytes, 0, bytes.length);
		hash = Long.toHexString(crc32.getValue()).toUpperCase();
		return hash;
	}

	/**
	 * Ejemplo de uso de la clase
	 * 
	 * @param args
	 */
	public static void main(String[] args) {
		// 1. Creacion del objeto Criptography :
		Criptography ejemplo = new Criptography();

		// Obteniendo version
		System.out.println(" [            Criptography " + ejemplo.VERSION
				+ "            ]\n");

		// 2. Seleccionar el algoritmo
		ejemplo.setAlgoritmo(Algoritmo.MD2);

		// 3. Obtener el hash
		System.out.println("\nHash : "
				+ ejemplo.generateHash("Esta es una prueba"));
		System.out.println("Algoritmo : " + ejemplo.getAlgoritmo());
		System.out.println("Texto : " + ejemplo.getTexto());

		// 4. Cambiar el algoritmo
		ejemplo.setAlgoritmo(Algoritmo.MD5);
		System.out.println("\nHash : "
				+ ejemplo.generateHash("Esta es una prueba"));
		System.out.println("Algoritmo : " + ejemplo.getAlgoritmo());
		System.out.println("Texto : " + ejemplo.getTexto());

		// 5. Cambiar el texto
		ejemplo.setAlgoritmo(Algoritmo.SHA256);
		System.out.println("\nHash : "
				+ ejemplo.generateHash("Codes and Tags in other Hash"));
		System.out.println("Algoritmo : " + ejemplo.getAlgoritmo());
		System.out.println("Texto : " + ejemplo.getTexto());

		// Y otro algoritmo....
		ejemplo.setAlgoritmo(Algoritmo.CRC32);
		System.out
				.println("\nHash : " + ejemplo.generateHash("Utilizando CRC32"));
		System.out.println("Algoritmo : " + ejemplo.getAlgoritmo());
		System.out.println("Texto : " + ejemplo.getTexto());
	}
}

Salida

 [            Criptography 1.0            ]


Hash : 392aeb7f6564fbce3204e41d0ba27bf2
Algoritmo : MD2
Texto : Esta es una prueba

Hash : f099ae43ce165c31c5956d44190288cd
Algoritmo : MD5
Texto : Esta es una prueba

Hash : 2af6b965237c2f973dcb9bf1145ad19650ec1089f0740f383b4a948b97547be0
Algoritmo : SHA256
Texto : Codes and Tags in other Hash

Hash : 796FEE50
Algoritmo : CRC32
Texto : Utilizando CRC32