Criptografía (CCXLI): Cifrado Gronsfeld en python

Continúo poniendo scripts de programación en python para automatizar tareas que tengan relación con la criptografía.

En este post incluyo y comento un script en python para el cifrado y descifrado utilizando el cifrado Gronsfeld, una variante del cifrado de Vigenère.

Antes de poner el script, recordar que en este post expliqué cómo se cifraba manualmente.

Las funciones de cifrado y descifrado son las mismas que en el cifrado de Vigenère. Lo único que cambia es que la clave está compuesta por una combinación de los dígitos del 0 al 9:

Donde:
K: clave.
ki: dígito i-ésimo de la clave (1 ≤ i ≤ t).
t: periodo o longitud de la clave.
E: función de cifrado.
mi: carácter i-ésimo del mensaje o texto en claro a cifrar.
D: función de descifrado.
ci: carácter i-ésimo del criptograma o texto cifrado.
n: tamaño del alfabeto.

En el script ambas funciones se implementan de la siguiente manera (pongo como ejemplos el cifrado y descifrado que veremos después al ejecutar el script):

- Cifrar:

La función de cifrado es:

Ek (mi) = (mi + ki) mod n

Cifrado manual aplicando esta función al primer carácter del texto en claro del ejemplo ("E") con el primer dígito de la clave (2) al ejecutar el script (tamaño del alfabeto utilizado = 26, es decir, "Ñ" excluida):

Ek (m1) = (m1 + k1) mod n = ("E" + 2) mod 26 = (4 + 2) mod 26 = 6 = "G"

Si lo hubiéramos hecho con la tabla de Gronsfeld:

Y en el script se implementa de la siguiente manera:

alfabeto[(alfabeto.find(caracter) + int(clave[i % len(clave)])) % len(alfabeto)]

- alfabeto.find(caracter): el método find() encuentra la primera ocurrencia del valor especificado en una cadena de caracteres y devuelve la posición que ésta ocupa. La primera posición es 0 y si no se encuentra el valor devuelve -1.

En el script encuentra la ocurrencia del carácter del texto en claro en el alfabeto y devuelve su posición en el mismo (de 0 a 25).

En el ejemplo que hemos puesto devolvería la posición en el alfabeto de la "E", es decir, 4.

- len(): la función len() devuelve el número de items de un objeto. Cuando el objeto es una cadena devuelve el número de caracteres de la misma.

En el script devuelve el número de caracteres de la cadena clave, en el ejemplo 5, y el número de caracteres del alfabeto utilizado, es decir, el tamaño del alfabeto, en el ejemplo 26.

- %: el operador % realiza la división modular entre dos operandos, es decir, obtiene el resto de dividir el operando 1 entre el operando 2.

- int(clave[i % len(clave)]): en el script se refiere al dígito de la clave con la que se va a cifrar el carácter del texto en claro. Se utiliza el operador % para que cuando se acaben los dígitos de la clave se empiece otra vez desde el primer dígito de la misma.

En el ejemplo que hemos puesto devolvería el primer dígito de la clave, que es aquel con el que se va a cifrar el primer carácter del texto en claro, "E", es decir, devolvería 2.

- alfabeto[(alfabeto.find(caracter) + int(clave[i % len(clave)])) % len(alfabeto)]: obtiene el carácter cifrado, que es aquel que se halla en la posición resultante de la suma módulo tamaño del alfabeto de la posición que ocupa en el alfabeto el carácter del texto en claro a cifrar más el dígito de la clave con el que se va a cifrar éste.

En el ejemplo que hemos puesto devolvería "G", que es el carácter cifrado; aquel que se encuentra en la posición del alfabeto que resulta de la operación (4 + 2) mod 26 = 6.

- Descifrar:

La función de descifrado es:

Dk (ci) = (ci - ki) mod n

Descifrado manual aplicando esta función al primer carácter del criptograma ("G") con el primer dígito de la clave (2) en el ejemplo que veremos después al ejecutar el script (tamaño del alfabeto utilizado = 26, es decir, "Ñ" excluida):

Dk (c1) = (c1 - k1) mod n = ("G" - 2) mod 26 = (6 - 2) mod 26 = 4 = "E"

Si lo hubiéramos hecho con la tabla de Gronsfeld:

Y en el script se implementa de la siguiente manera:

alfabeto[(alfabeto.find(caracter) - int(clave[i % len(clave)])) % len(alfabeto)]

De forma análoga que en el cifrado:

En el ejemplo que hemos puesto devolvería "E", que es el carácter del texto en claro; aquel que se encuentra en la posición del alfabeto que resulta de la operación (6 - 2) mod 26 = 4.

- Script python del cifrado de Gronsfeld:

El script es el siguiente: 

#!/usr/bin/env python
# -*- coding: utf-8 -*-

# CIFRADO DE GRONSFELD:
#
# Cifra y descifra textos en claro y criptogramas, respectivamente,
# utilizando el criptosistema de Gronsfeld.
#
# http://mikelgarcialarragan.blogspot.com/

import re
from unicodedata import normalize

# FUNCIÓN DE CIFRADO:
# La función de cifrado es: Ek(mi) = (mi + Ki) mod n
def cifrar(alfabeto,texto_claro,clave):
    criptograma = ''
    i = 0
    for caracter in texto_claro:
        criptograma = criptograma + alfabeto[(alfabeto.find(caracter) + int(clave[i % len(clave)])) % len(alfabeto)]
        i+=1
    return criptograma

# FUNCIÓN DE DESCIFRADO:
# La función de descifrado es: Dk(Ci) = (Ci - Ki) mod n
def descifrar(alfabeto,criptograma,clave):
    texto_claro = ''
    i = 0
    for caracter in criptograma:
        texto_claro = texto_claro + alfabeto[(alfabeto.find(caracter) - int(clave[i % len(clave)])) % len(alfabeto)]
        i+=1
    return texto_claro

def main():
# SELECCIÓN DE ALFABETO:
# Se solicita que se indique el alfabeto a emplear.
    alfabeto = ""
    while alfabeto == "":
        print ("")
        print ("*** SELECCIÓN DE ALFABETO ************************")
        print ('1. Alfabeto inglés  (26 caracteres, "Ñ" excluida).')
        print ('2. Alfabeto español (27 caracteres, "Ñ" incluida).')
        print ("")
        opcion = input("Por favor, seleccione una opcion: ")
        if opcion == "1":
            alfabeto = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
        elif opcion == "2":
            alfabeto = "ABCDEFGHIJKLMNÑOPQRSTUVWXYZ"
        else:
            print ("*** ERROR: Opción no válida.")
    print ("")
    print ("[+] Alfabeto:", alfabeto)
    print ("[+] Tamaño del alfabeto (n):", len(alfabeto))

# MENÚ:
# Se presenta el menú para que se seleccione una opción.
    salir = False
    while not salir:
        print ("")
        print ("*** MENÚ *****************************************")
        print ("1. Cifrar.")
        print ("2. Descifrar.")
        print ("3. Salir.")
        print ("")
        opcion = input("Por favor, seleccione una opción: ")
        if opcion == "1":
            print ("")
            print ("--- CIFRAR:")
            # Cifrar: Se introducen el texto en claro y la clave. Se convierten los caracteres a mayúsculas y
            # se eliminan del texto en claro los espacios, las tildes, diéresis, etc.
            texto_claro =clave = "*"
            while not texto_claro.isalpha():
                texto_claro = input('Texto en claro a cifrar: ').upper()
                texto_claro = texto_claro.replace(' ','')
                texto_claro = re.sub(r"([^n\u0300-\u036f]|n(?!\u0303(?![\u0300-\u036f])))[\u0300-\u036f]+",
                                     r"\1", normalize("NFD", texto_claro), 0, re.I)
                texto_claro = normalize("NFC", texto_claro)
                if texto_claro.isalpha():
                    print ("[+] Texto en claro a cifrar:", texto_claro)
                    while not clave.isnumeric():
                        clave = input('Clave: ')
                        if clave.isnumeric():
                            print ("[+] Clave:", clave)
                            criptograma = cifrar(alfabeto,texto_claro,clave)
                            print ("[+] Criptograma:", criptograma)
                        else:
                            print ("*** ERROR: La clave sólo debe contener dígitos.")
                else:
                    print ("*** ERROR: El texto en claro a cifrar sólo debe contener caracteres alfabéticos.")
        elif opcion == "2":
            print ("")
            print ("--- DESCIFRAR:")
            # Descifrar: Se introducen el criptograma y la clave. Se convierten los caracteres a mayúsculas y
            # se eliminan del criptograma los espacios, las tildes, diéresis, etc.
            criptograma =clave = "*"
            while not criptograma.isalpha():
                criptograma = input('Criptograma a descifrar: ').upper()
                criptograma = criptograma.replace(' ','')
                criptograma = re.sub(r"([^n\u0300-\u036f]|n(?!\u0303(?![\u0300-\u036f])))[\u0300-\u036f]+",
                                      r"\1", normalize("NFD", criptograma), 0, re.I)
                criptograma = normalize("NFC", criptograma)
                if criptograma.isalpha():
                    print ("[+] Criptograma a descifrar:", criptograma)
                    while not clave.isnumeric():
                        clave = input('Clave: ')
                        if clave.isnumeric():
                            print ("[+] Clave:", clave)
                            texto_claro = descifrar(alfabeto,criptograma,clave)
                            print ("[+] Texto en claro:", texto_claro)
                        else:
                            print ("*** ERROR: La clave sólo debe contener dígitos.")
                else:
                    print ("*** ERROR: El criptograma a descifrar sólo debe contener caracteres alfabéticos.")
        elif opcion == "3":
            print ("*** FIN ******************************************")
            salir = True
        else:
            print ("*** ERROR: Opción no válida.")
	
if __name__ == '__main__':
    main()

Lo ejecuto:

- Cifrar:

- Descifrar:

Quizás también te interese: