Desencriptar una cadena en Java

En prácticamente todas las aplicaciones, siempre es necesaria la encriptación de algún tipo de información. El ejemplo más simple son las contraseñas de usuario, información personal o cualquier tipo de información sensible dentro del ámbito de la aplicación.

Anteriormente, habíamos visto un mecanismo para encriptar contraseñas y convertir el texto encriptado en una cadena almacenable en una base de datos o fichero sin problemas de codificación, mediante el API estandar de Java.

Veamos ahora cómo sería el proceso inverso:

  String cadena = "WZMLNsMJeI2PDCPuWudVucLfRyQlffqA" +
                  "1yYKWLOLuCv2SzIcw0Aegh6w3o6FjQ3T";
  String semilla = "0123456789";
  String cadenaDesencriptada = null;
  String tmp = new String( ( semilla.trim().concat("99999999") ).substring(0, 8 ) );
      
  byte[] claveDesc = new BASE64Decoder().decodeBuffer( cadena );
  SecretKeySpec desKey = new SecretKeySpec( tmp.getBytes(), "DES");
      
  Cipher cipher = Cipher.getInstance("DES/ECB/PKCS5Padding");
  cipher.init(Cipher.DECRYPT_MODE, desKey);
      
  cadenaDesencriptada = new String(cipher.doFinal(claveDesc));

Tras ejecutar el anterior código, obtendríamos la cadena original "No se a quien odio más, a Batman o a Guti" dentro de la variable cadenaDesencriptada.

Evidentemente, todo el código del ejemplo habrá que incluirlo dentro del correspondiente bloque try-catch y realizar la gestión de excepciones adecuada según nuestra aplicación.

Ver artículo: Encriptar una cadena en Java

Encriptar una cadena en Java

En prácticamente todas las aplicaciones, siempre es necesaria la encriptación de algún tipo de información. El ejemplo más simple son las contraseñas de usuario, información personal o cualquier tipo de información sensible dentro del ámbito de la aplicación.

Veamos cómo podemos codificar una cadena cualquiera utilizando el API estandar de Java.

        String claveEncriptada = null;
        String claveOriginal = "No se a quien odio más, a Batman o a Guti";
        String semilla = "0123456789";

        // Generamos una clave secreta.
        SecretKeySpec desKey = new SecretKeySpec(new String((semilla.trim().concat("99999999")).substring(0, 8)).getBytes(), "DES");
        Cipher cipher = Cipher.getInstance("DES/ECB/PKCS5Padding");
        cipher.init(Cipher.ENCRYPT_MODE, desKey);
        byte[] claveEncriptadaBytes = cipher.doFinal( claveOriginal.getBytes() );
        claveEncriptada = new BASE64Encoder().encode( claveEncriptadaBytes );

Evidentemente el código mostrado anteriormente habrá que incluirlo en un método con su generador de clave y su bloque try-catch.

Como podemos ver, la cadena que tratamos de codificar es: "No se a quien odio más, a Batman o a Guti" y el resultado que obtendríamos si ejecutaramos las instrucciones del listado sería: "WZMLNsMJeI2PDCPuWudVucLfRyQlffqA1yYKWLOLuCv2SzIcw0Aegh6w3o6FjQ3T".

La semilla, es utilizada por el algoritmo de encriptación para cifrar la cadena. Si quisieramos desencriptar la cadena obtenida, necesitaríamos la semilla para poder hacerlo. Es como la llave que abre la caja fuerte que contiene el contenido desencriptado original. A la hora de realizar una aplicación es de suma importancia que cada dato que encriptemos tenga una semilla diferente para no comprometer el total de la información en el caso de que la misma sea descubierta. El mecanismo para la elección debe ser elegido cuidadosamente para dificultar el trabajo a un posible "ladrón" que quisiera acceder a la información.

Es importante tener en cuenta que la encriptación genera una cadena de bytes, los cuales, transformados en una cadena de carácteres podría implicar la existencia de carácteres extraños en la misma, cosa que nos podría dar problemas a la hora de almacenar la información encriptada en una base de datos si no tenemos en cuenta que podemos insertar dicho tipo de cadenas a la hora de almacenarlas en fichero o base de datos. Para evitar dicho problema, utilizamos el codificación BASE64.

Ver artículo: Desencriptar una cadena en Java

Gracias a Gomstor por encontrar un error en el código que ya ha sido corregido.

Codificación de los acentos en páginas web

Generalmente cuando uno prepara una página web estática se limita a escribir "a saco" el texto que esta debe mostrar, incluyendo acentos y carácteres especiales. Esto no supone un problema si utilizamos un editor de páginas web que automáticamente fije la codificación del contenido, aunque lo lógico sería utilizar los tags de HTML para su correcta visualización. Por ejemplo, se deberá usar á (a aguda) para mostrar una á.

El problema se puede presentar al crear una página web dinámicamente, ya sea con ASP, jsp, php o cualquier otra tecnología en la que los textos que se deben mostrar se obtienen de una fuente de datos como una tabla de una base de datos y que han sido introducidos por terceros. En algunos casos, como sobre todo sucede con el navegador Firefox nos podemos encontrar con sorpresas, como ver unos rombitos en el lugar de alguna vocal acentuada. Ver un ejemplo (sólo firefox).

Para evitar este problema, deberemos incluir en la cabecera de la página el siguiente meta tag:

<meta content="text/html; charset=iso-8859-1" http-equiv="Content-Type"></meta>

Lo que informa al navegador de la codificación que debe utilizar para interpretar los carácteres de la página mostrada.

Otra opción es obligar al servidor a incluir dicho tag automáticamente. Esto se hace añadiendo al archivo .htaccess lo siguiente:

AddType text/html;charset=ISO-8859-1 .html

Parámetros en línea de comandos en java

Una de las cosas más engorrosas a la hora de preparar una pequeña aplicación java en línea de comandos,al igual que en otros lenguajes de programación, es el tener que controlar todos los parámetros que se le pasan a la aplicación, el orden de los mismos, que vayan separados al estilo -s -l -r o -slr...

Existe un proyecto de Martian Software Inc. llamado JSAP, que será de gran ayuda para este tipo de cosas. Lo descubrí casi de casualidad y me parece una maravilla. Pero veamos un ejemplo: Imaginemos un programa que lee de un archivo una serie de datos, los procesa, y los escribe en un archivo de salida, exceptuando los datos que generan alguna incidencia que son grabados en un tercer archivo de errores, la aplicación además parará cuando se produzcan un número de errores igual al indicado en otro parámetro, es decir el clásico problema de metodología Warnier.

El programa debería ejecutarse con un comando del estilo de:

java com.trapallada.programa -i entrada.txt -o salida.txt -e errores.txt -n 500

donde los parámetros podrían ser aparecer en cualquier orden.

/*
* Por CNG (www.trapallada.com).
*/
public static void main(String[] args)
{
try
{
JSAP jsap = new JSAP();

// Se crean los diferentes parámetros:
// Parámetro del fichero de entrada
FlaggedOption optEntrada = new FlaggedOption("Fichero de Entrada")
.setStringParser(JSAP.STRING_PARSER)
.setRequired(true)
.setShortFlag('i')
.setLongFlag("input");

// Parámetro del fichero de salida
FlaggedOption optSalida = new FlaggedOption("Fichero de Salida")
.setStringParser(JSAP.STRING_PARSER)
.setRequired(true)
.setShortFlag('o')
.setLongFlag("output");

// Parámetro del fichero de errores
FlaggedOption optErrores = new FlaggedOption("Fichero de Errores")
.setStringParser(JSAP.STRING_PARSER)
.setRequired(true)
.setShortFlag('e')
.setLongFlag("errores");

// Parámetro del fichero de número de errores (no obligatorio)
FlaggedOption optNumeroErrores = new FlaggedOption("Número de Errores")
.setStringParser(JSAP.INTEGER_PARSER)
.setRequired(false)
.setShortFlag('n')
.setLongFlag("numErrores");

// Registramos los parámetros
jsap.registerParameter(optEntrada);
jsap.registerParameter(optSalida);
jsap.registerParameter(optErrores);
jsap.registerParameter(optNumeroErrores);

// Se procesan los argumentos de la línea de comandos
JSAPResult config = jsap.parse(args);

// Si se produce algún error generamos el mensaje de error con JSAP.
if (!config.success())
{
System.err.println();
System.err.println("Uso: java " + Lector.class.getName());
System.err.println(" " + jsap.getUsage());
System.err.println();
System.exit(1);
}

// Se recogen los datos del la configuración cargada desde los
// parámetros de la línea de comandos.
String entrada = config.getString(optEntrada.getID());
String salida = config.getString(optSalida.getID());
String errores = config.getString(optErrores.getID());
Integer numErrores = new Integer(config.getInt(optNumeroErrores.getID()));
}
catch (Exception e)
{
e.printStackTrace();
}
}

Esto sería lo que devolvería la ejecución de la clase en el caso de no poner nada a continuación de la llamada a la misma (sin parámetros).

Uso: java com.trapallada.programa
(-i|--input) <Fichero de Entrada> (-o|--output) <Fichero de Salida> (-e|--errores) <Fichero de Errores> [(-n|--numErrores) <Número de Errores>]