def __init__(self, alphabet, n, key=None):
"""
Constructor de clase, recibiendo un alfabeto completamente necesario pero
podría no recibir una llave de cifrado, en cuyo caso, hay que generar una,
para el caso del tamañHo de la llave, hay que asegurarse que tiene raíz entera.
:param alphabet: una cadena con todos los elementos del alfabeto.
:param n: el tamaño de la llave, obligatorio siempre.
:param key: una cadena que corresponde a la llave, en caso de ser una llave inválida
arrojar una CryptographyException.
"""
self.alphabet = alphabet
self.n = n
# Checamos si la raíz de la longitud de la llave es entera
raiz = self.encuentraRaiz(self.n)
if not (isinstance(raiz, int)):
raise CryptographyException()
# Checamos si se nos pasa una llave y sino, la generamos
self.key = key if key else self.construyeLllave(raiz)
self.key = self.llenaMatriz(self.key, raiz, True)
#self.key = self.key % len(self.alphabet)
# Si el determinante es 0, entonces no tiene matriz inversa y se levanta excepción
if self.key.det() == 0:
raise CryptographyException()
# Si la longitud del alfabeto % determinante de la llave es 0 se levanta la excepción
elif len(self.alphabet) % self.key.det() == 0:
raise CryptographyException()
def cipher(self, message):
new_cipher_msg = ""
ce = CryptographyException()
for cha in message:
i = ce.get_index(cha, self.alphabet)
c = (self.A * i + self.B) % len(self.alphabet)
new_cipher_msg += self.alphabet[c]
print("Mensaje Cifrado: %s" % (new_cipher_msg))
return (new_cipher_msg)
def decipher(self, criptotext):
new_decipher_msg = ""
ce = CryptographyException()
for cha in criptotext:
i = ce.get_index(cha, self.alphabet)
dec = (ce.modInverso(self.A, len(self.alphabet)) *
(i - self.B)) % len(self.alphabet)
new_decipher_msg += self.alphabet[dec]
print("Mensaje Decifrado: %s" % (new_decipher_msg))
return (new_decipher_msg)
def decipher(self, ciphered):
"""
Implementación del algoritmo de decifrado, según el criptosistema de vigenere.
:param ciphered: El criptotexto a decifrar.
:return: El texto plano correspondiente del parámetro recibido.
"""
new_decipher_msg = ""
ce = CryptographyException()
for index, cha in enumerate(ciphered):
i = ce.get_index(
cha, self.alphabet
) # Se obtiene el indice de cada caracter de la clave
cha_clave = self.password[index % len(self.password)]
j = ce.get_index(
cha_clave, self.alphabet
) # Se obtiene el indice de cada caracter del mensaje
dec = (i - j) % len(self.alphabet)
new_decipher_msg += self.alphabet[dec]
print("Mensaje Decifrado: %s" % (new_decipher_msg))
return (new_decipher_msg)
def cipher(self, message):
"""
Usando el algoritmo de cifrado de vigenere, cifrar el mensaje recibido como parámetro,
usando la tabla descrita en el PDF.
:param message: El mensaje a cifrar.
:return: Una cadena de texto con el mensaje cifrado.
"""
new_cipher_msg = ""
ce = CryptographyException()
for index, cha in enumerate(message):
i = ce.get_index(
cha, self.alphabet
) # Se obtiene el indice de cada caracter de la clave
cha_clave = self.password[index % len(self.password)]
j = ce.get_index(
cha_clave, self.alphabet
) # Se obtiene el indice de cada caracter del mensaje
c = (i + j) % len(self.alphabet)
new_cipher_msg += self.alphabet[c]
print("Mensaje Cifrado: %s" % (new_cipher_msg))
return (new_cipher_msg)
def __init__(self, alphabet, password=None):
#Recomendación, ingeniárselas para no cargar siempre O(n^2) en memoria aunque esto no
#será evaluado, con n el tamaño del alfabeto.
"""
Constructor de clase, recibe un parámetro obligatorio correspondiente al alfabeto
y un parámetro opcional que es la palabra clave, en caso de ser None, entonces
generar una palabra pseudoaleatoria de al menos tamaño 4.
:param alphabet: Alfabeto a trabajar con el cifrado.
:param password: El password que puede ser o no dada por el usuario.
"""
self.alphabet = alphabet
self.password = password
ce = CryptographyException()
def __init__(self, alphabet, A=None, B=None):
"""
Constructor de clase que tiene como parámetro todos los atributos
que necesita el algoritmo de cifrado afín.
Parámetro:
alphabet -- el alfabeto sobre quien se cifra el mensaje.
A -- El coeficiente A que necesita el cifrado.
B -- El coeficiente B de desplazamiento.
"""
self.alphabet = alphabet
A = A if A else 1
if prime_relative(A, len(self.alphabet)):
self.A = A
else:
raise (CryptographyException())
self.B = B
def __init__(self, alphabet, A=None, B=None):
"""
Constructor de clase que tiene como parámetro todos los atributos
que necesita el algoritmo de cifrado afín.
Parámetro:
alphabet -- el alfabeto sobre quien se cifra el mensaje.
A -- El coeficiente A que necesita el cifrado.
B -- El coeficiente B de desplazamiento.
"""
self.alphabet = alphabet
# Checamos que se haya pasado un parámetro A
A = A if A else self.encuentraPrimoRelativo(len(self.alphabet))
# Checamos si A y la longitud del alfabeto son primos relativos.
if prime_relative(A, len(self.alphabet)):
self.A = A
else:
raise CryptographyException()
self.B = B
def __init__(self, alphabet, n, key=None):
"""
Constructor de clase, recibiendo un alfabeto completamente necesario pero
podría no recibir una llave de cifrado, en cuyo caso, hay que generar una,
para el caso del tamaÑHo de la llave, hay que asegurarse que tiene raíz entera.
:param alphabet: una cadena con todos los elementos del alfabeto.
:param n: el tamaÑo de la llave, obligatorio siempre.
:param key: una cadena que corresponde a la llave, en caso de ser una llave inválida
arrojar una CryptographyException.
"""
self.alphabet = alphabet
self.n = n
decimal, entera = math.modf(math.sqrt(self.n))
if key and decimal == 0:
self.key = self.generate_key(key)
if (len(self.alphabet) % int(np.linalg.det(self.key)) == 0):
raise CryptographyException()
else:
self.key = self.generate_key()