Si lo que pretendemos es, dada una cadena, sustituir una serie de caracteres por otra, en Python es tan sencillo como pasarle al método maketrans una cadena con los caracteres que queremos cambiar y otra con los caracteres a utilizar en su lugar. Ambas cadenas deberán tener la misma longitud. Este método devuelve una tabla de traducción, un objeto susceptible de ser usado por el método translate el cual se aplica sobre un string, como veremos.

Cifrado César

En pocas palabras, el cifrado César se basa en sustituir cada letra de un mensaje, una cadena de texto, por la que le sigue 3 puestos más allá en el alfabeto, es decir, la A por la D, la B por la E, y así sucesivamente, hasta las tres últimas letras que se cambiarán por las tres primeras letras, respectivamente. Para descifrar un mensaje cifrado con este sistema sólo tenemos que llevar a cabo el proceso inverso, cambiar la A por la X, la B por la Y, la C por la Z, y a partir de la D por la letra 3 puestos antes en el alfabeto. No tiene en cuenta mayúsculas o minúsculas, por lo que por ahora no nos preocuparemos de eso.

```python from string import maketrans

sfrom = "abcdefghijklmnopqrstuvwxyz" sto = "xyzabcdefghijklmnopqrstuvw" trantab = maketrans(sfrom, sto)

"sbwkrq".translate(trantab) ```

Con esto en mente, podemos escribir un método que nos permita cualquier tipo de traslación, tanto en un sentido como en otro:

python from string import maketrans, translate, ascii_lowercase as al def caesar(text, offset=3): return translate(text, maketrans(al, al[offset:] + al[:offset]))

```python

caesar("python") 'sbwkrq' caesar("sbwkrq", -3) 'python' caesar("python", 13) 'clguba' ```

Los métodos de cifrado basados en traslaciones hace mucho tiempo que quedaron obsoletos, ya que es sencillo obtener una distribución de las frecuencias de letras de un texto cifrado y compararlas con la frecuencia de aparición de letras para un idioma concreto.

ROT13

RTO13 está basado en el cifrado César, sólo que en lugar de 3 posiciones, hace la sustitución por el carácter que está 13 puestos hacia adelante en el alfabeto, conservando, además, si es mayúscula o minúscula.

python from string import maketrans, translate, ascii_lowercase as al, ascii_uppercase as au def rot13(text, offset=13): sfrom = au + al sto = au[offset:] + au[:offset] + al[offset:] + al[:offset] return translate(text, maketrans(sfrom, sto))

```python

rot13("ABCXYZabcxyz") 'NOPKLMnopklm' ```

ROT47

Este es un ROT13 que utiliza un conjunto mayor que el de las letras, ya que utiliza el conjunto de los caracteres ASCII del "!" (33) al "\~" (126), y realiza la sustitución por el carácter que está 47 puestos hacia adelante. Crearemos la lista de caracteres ASCII necesarios a partir de las listas de caracteres del módulo string. Para conseguirlo, buscaremos los índices de los caracteres de puntuación entre los cuales insertaremos las listas de dígitos y letras mayúsculas y minúsculas.

Este es el código ASCII:

```bash 30 40 50 60 70 80 90 100 110 120


0: ( 2 < F P Z d n x 1: ) 3 = G Q [ e o y 2: * 4 > H R \ f p z 3: ! + 5 ? I S ] g q { 4: " , 6 @ J T ^ h r | 5: # - 7 A K U _ i s } 6: $ . 8 B L V ` j t ~ 7: % / 9 C M W a k u DEL 8: & 0 : D N X b l v 9: ;’ 1 ; E O Y c m w ```

Y este es el contenido de la lista de signos de puntuación:

```python

string.punctuation '!"#$%&\'()*+,-./:;< =>?@[\]^_`{|}~' ```

Debemos colocar los números entre "/" y ":", las letras mayúsculas entre "@" y "[", y las letras minúsculas entre "`" y "{":

```python from string import punctuation as p, digits as d, ascii_lowercase as al, ascii_uppercase as au

ix = p.find(":") iu = p.find("[") il = p.find("{") ascii = p[:ix] + d + p[ix:iu] + au + p[iu:il] + al + p[il:] ```

```python

print ascii '!"#$%&\'()*+,-./0123456789:;< =>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~' len(ascii) 94 ```

Ya podemos crear una función rot47:

python from string import maketrans, translate def rot47(text, offset=47): # ascii contiene los caracteres ASCII del "!" (33) al "~" (126) return translate(text, maketrans(ascii, ascii[offset:] + ascii[:offset]))

```python

print rot47("Cómo se puede distinguir a un extrovertido de un") ró>@ D6 AF656 5:DE:?8F:C 2 F? 6IEC@G6CE:5@ 56 F? ```

Vigenëre

Vigenëre es un cifrado César por grupos, donde cada letra del grupo sufre una traslación diferente. La longitud de la palabra clave determina el tamaño de los grupos, y cada letra especifica la traslación para cada letra del grupo. No distingue entre mayúsculas y minúsculas.

python from string import ascii_lowercase as al def vigenere_crypt(text, key, decrypt=0): prefix = -1 if decrypt else 1 len_t = len(text) len_k = len(key) ak = [ al.find(c) for c in key ] return "".join([caesar(text[i], prefix*ak[i%len_k]) for i in range(len_t)])

```python

vigenere_crypt("parisvautbienunemesse", "loup") 'aolxdjujepctyihtxsmhp' ```

```python

vigenere_crypt("aolxdjujepctyihtxsmhp", "loup", -1) 'parisvautbienunemesse' ```

Este cifrado también quedó obsoleto después de que se descubriera el método Kasiski, que consiste en buscar palabras repetidas en el texto cifrado. Es casi seguro que dichas palabras no sólo eran la misma antes del cifrado sino que además la clave coincidió en la misma posición en ambas ocurrencias. La distancia entre palabras repetidas es múltiplo de la longitud de la clave, por lo que si tenemos diferentes palabras que se repiten, obtenemos el máximo común divisor de las longitudes y la longitud de la clave debe ser, o dicho mcd, o un factor primo de éste. Una vez encontrada la longitud de la clave, se aplica la misma técnica estadística que para el cifrado César.


Entradas relacionadas


Published

Category

dev

Tags

Contacto