Técnicas criptográficas: Caesar

Es un hecho que Flash no se lleva nada bién con los temas de seguridad ni nada que se le asemeje. Su arquitectura no permite la utilización de SSL, presente entre la capa de TCP y de aplicación, que nos dan los navegadores actuales y que quizá sea el algoritmo más usado hoy en día (no por ello el más seguro).
Iremos viendo distintos mecanismo/algoritmos implementables en la capa de aplicación (por software) que aporten a Flash una mayor seguridad en los canales de comunicación con el servidor. De esta forma podremos mandar parejas de valores usuario / password sin miedo (bueno... no tanto como si no lo encriptáramos) por la red.
Aquí está la implementación más antigua que se conoce de un algoritmo criptográfico: el algoritmo de CESAR!

El algortimo de Cesar (ó Caesar) es un algoritmo de sustitución, lo que quiere decir que reemplazamos cada carácter por otro a través de una tabla que los relaciona. Es importante tener en cuenta que el texto cifrado (cypherText) tendrá la misma longitud de carácteres que el texto en claro (ó plainText).
Veamos un ejemplo:

plainText	a	b	c	d	e	f	g	h	i
cypherText	d	e	f	g	h	i	j	k	l

Vemos en la tabla anterior que cambiamos la 'a' por la 'd', la 'b' por la 'e' y así sucesivamente. La norma general es que sumamos 3 a cada letra. El 3 es lo que se conoce como clave y podría ser cualquier otro número.
Adaptando esto a la tabla ASCII extendida (de 256 carácteres) una posible implementación en AS sería: (Podéis encontrar una tabla ASCII en http://mcrmo.fasthost.tv/informatica/asciitable.htm)

if (_global.Criptografy == undefined)  {
        _global.Criptografy = new Object();
};

if (_global.Criptografy.Caesar == undefined)  {
        _global.criptografy.caesar= new Object();
};


/**
* @method: public string encrypt(plainText,key)
* @params: plainText --> Texto a encriptar
*               key --> clave para el algortimo
* @return: el texto cifrado
* @Description: Encripta un texto pasado como valor
*                    según el algoritmo de César utilizando la
*                    la clave key.
****/

Criptografy.Caesar.encrypt = function(plainText,key)  {
        var cipherText = new String();
        var long = plainText.length;
        var letra;
        
        for (letra = 0; letra < long; letra++)  {
                cipherText += String.fromCharCode((plainText.charCodeAt(letra)+ key)% 256);
        }
        
        return cipherText;
};

/**
* @method: public string decrypt(cipherText,key)
* @params: cipherText --> Texto para desencriptar
                  key --> clave para el algortimo
* @return: el texto descifrado
* @Description: Desencripta un texto pasado como valor
*                          según el algoritmo de César utilizando la
*                       la clave key
****/
Criptografy.Caesar.decrypt = function(cipherText,key) {
        var plainText = new String();
        var long = cipherText.length;
        var letra;
        
        for (letra = 0; letra <long;
letra++)  {
                plainText += String.fromCharCode((cipherText.charCodeAt(letra)- key) % 256);
        };        
        
        return plainText;
};

 

Un caso de uso didáctico podría ser el siguiente. Añadir el siguiente código en un .fla:

#include "Criptografy.Caesar.as"

myPlainText = "Este es el texto que se va a encriptar";
trace("-- Texto usuario: " + myPlainText)

myCipherText = Criptografy.Caesar.encrypt(myPlainText,3);
trace("-- Encriptado: " + myCipherText);

myPlainText = Criptografy.Caesar.decrypt(myCipherText,3);
trace("-- Desencriptado: " + myPlainText);

 

Este es uno de los métodos más rudimentarios para encriptar información y puede ser fácilmente roto, ya sea por fuerza bruta o por un poco de inteligencia que le pongámos al asunto. Por fuerza bruta consistería en desencriptar el texto que tengamos encriptado con cada una de las 256 claves posibles, entre los textos que encontremos seleccionaremos el que mayor sentido tenga.

Si no queremos utilizar fuerza bruta... Una de las técnicas que a veces he usado es fijarme en el carácter que más a menudo se repite.
EJEMPLO: Wh#vlhqwhv#phmru#dkrud#txh#or#kdv#ghvfliudgrBBB#>0,
#mhmhmhmh

En el criptograma anterior vemos que se repite mucho '#'. Por lógica pura qué podría ser??? un ESPACIO??!!! ;-) Suponiendo que se trata de un espacio, buscamos en la tabla ASCII el código de '#' que es 35, el código del espacio es 32. De aquí podemos sacar la clave: 3 ;-)

Pues ya está, ya hemos roto el código :P

A ver si para el siguiente artículo planteo algún algoritmo más serio y menos frágil. Y cuando tenga tiempo os prometo una implementación del conocido RSA.

Por cierto, qué os parecería si propusiéramos unos juegos de guerra para Flash? Algo así para jugar e intentar descifrar código, claves, etc., etc... Espero vuestras opiniones!