Criptografía (CCXLIX): Cifrado afín 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 afín.

Antes de poner el script, indicar cuales son las funciones de cifrado y descifrado:

Ea,b(mi) = (a * mi + b) mod n

Da,b(ci) = (a^-1 (ci - b)) mod n

Donde:

a: constante de decimación.

b: constante de desplazamiento.

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.

a^-1: inverso modular o multiplicativo de a.
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:

Ea,b(mi) = (a * mi + b) mod n

Cifrado manual aplicando esta función al primer carácter del texto en claro del ejemplo ("E") con la constante de decimación (a) igual a 19  y la constante de desplazamiento (b) igual a 17 al ejecutar el script (tamaño del alfabeto utilizado = 26, es decir, "Ñ" excluida):

Ea,b(mi) = (a * mi + b) mod n = (19 * "E" + 17) mod 26 = (19 *4 + 17) mod 26 = 93 mod 26 = 15 = "P"

Es decir, el carácter "E" se sustituye por el carácter "P".

Y en el script se implementa de la siguiente manera:

alfabeto[(int(a) * alfabeto.find(caracter) + int(b)) % 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 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.

- alfabeto[(int(a) * alfabeto.find(caracter) + int(b)) % len(alfabeto)]: obtiene el carácter cifrado, que es aquel que se halla en la posición resultante de multiplicar la constante de decimación por la posición que ocupa en el alfabeto el carácter del texto en claro a cifrar más la constante de desplazamiento. Operación que se realiza módulo tamaño del alfabeto.

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

- Descifrar:

La función de descifrado es:

Da,b(ci) = (a^-1 (ci - b)) mod n

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

Da,b(ci) = (a^-1 (ci - b)) mod n = (11 ("P" - 17)) mod 26 = (11 * (-2)) mod 26 = 4 = "E"

Es decir, el carácter "P" se sustituye por "E".

Y en el script se implementa de la siguiente manera:

alfabeto[(pow(int(a), -1, len(alfabeto)) * (alfabeto.find(caracter) - int(b))) % len(alfabeto)]

pow(int(a), -1, len(alfabeto)): obtiene el inverso modular de a, es decir, el menor número entero cuya multiplicación modular por a es igual 1.

En el ejemplo que hemos puesto 11: (19 * 11) mod 26 = 1.

y el resto de forma análoga que en el cifrado, con lo que en el ejemplo devolvería "E".

- Script python del cifrado afín:

El script es el siguiente:

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

# CIFRADO AFÍN:
#
# Cifra y descifra textos en claro y criptogramas, respectivamente,
# utilizando el cifrado afín.
#
# http://mikelgarcialarragan.blogspot.com/

import re
from unicodedata import normalize
import math

# FUNCIÓN DE CIFRADO:
# La función de cifrado es: Ea,b(mi) = (a * mi + b) mod n
def cifrar(alfabeto,texto_claro,a,b):
    criptograma = ''
    for caracter in texto_claro:
        criptograma = criptograma + alfabeto[(int(a) * alfabeto.find(caracter) + int(b)) % len(alfabeto)]
    return criptograma

# FUNCIÓN DE DESCIFRADO:
# La función de descifrado es: Da,b(ci) = (inv(a) * (ci - b)) mod n
def descifrar(alfabeto,criptograma,a,b):
    texto_claro = ''
    for caracter in criptograma:
        texto_claro = texto_claro + alfabeto[(pow(int(a), -1, len(alfabeto)) * (alfabeto.find(caracter) - int(b))) % len(alfabeto)]
    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, la constante de decimación y la constante de desplazamiento.
            # Se convierten los caracteres del texto en claro a mayúsculas y se eliminan de él los espacios, las tildes, diéresis, etc.
            texto_claro = "*"
            a = b = "99"
            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 a.isnumeric() or int(a) == 0 or int(a) > len(alfabeto):
                        a = input('Constante de decimación: ')
                        if a.isnumeric() and int(a) != 0 and int(a) <= len(alfabeto):
                            if math.gcd(int(a),len(alfabeto)) == 1:
                                print ("[+] Constante de decimación:", a)
                                while not b.isnumeric or int(b) > len(alfabeto):
                                    b = input('Constante de desplazamiento: ')
                                    if b.isnumeric() and int(b) <= len(alfabeto):
                                        print ("[+] Constante de desplazamiento:", b)
                                        criptograma = cifrar(alfabeto,texto_claro,a,b)
                                        print ("[+] Criptograma:", criptograma)
                                    else:
                                        b = "99"
                                        print ("*** ERROR: La constante de desplazamiento debe ser un número entero menor o igual que el tamaño del alfabeto.")
                            else:
                                a = "99"
                                print ("*** ERROR: La constante de decimación y el tamaño del alfabeto deben ser coprimos.")
                        else:
                            print ("*** ERROR: La constante de decimación debe ser un número entero mayor o igual que 1 y menor o igual que el tamaño del alfabeto.")
                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, la constante de decimación y la constante de desplazamiento.
            # Se convierten los caracteres del criptograma a mayúsculas y se eliminan de él los espacios, las tildes, diéresis, etc.
            criptograma = "*"
            a = b = "99"
            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 a.isnumeric() or int(a) == 0 or int(a) > len(alfabeto):
                        a = input('Constante de decimación: ')
                        if a.isnumeric() and int(a) != 0 and int(a) <= len(alfabeto):
                            if math.gcd(int(a),len(alfabeto)) == 1:
                                print ("[+] Constante de decimación:", a)
                                while not b.isnumeric or int(b) > len(alfabeto):
                                    b = input('Constante de desplazamiento: ')
                                    if b.isnumeric() and int(b) <= len(alfabeto):
                                        print ("[+] Constante de desplazamiento:", b)
                                        texto_claro = descifrar(alfabeto,criptograma,a,b)
                                        print ("[+] Texto en claro:", texto_claro)
                                    else:
                                        b = "99"
                                        print ("*** ERROR: La constante de desplazamiento debe ser un número entero menor o igual que el tamaño del alfabeto.")
                            else:
                                a = "99"
                                print ("*** ERROR: La constante de decimación y el tamaño del alfabeto deben ser coprimos.")
                        else:
                            print ("*** ERROR: La constante de decimación debe ser un número entero mayor o igual que 1 y menor o igual que el tamaño del alfabeto.")
                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: