def generaE(self):
#e es un numero primo relativo con phi(n)
self.e = 0
while not prime_relative(self.e, self.phi_n):
self.e = randint(1, self.n)
print("e: ", self.e)
return self.e
def __init__(self):
"""
Constructor de RSA, aquí se deben de generar los primos p y q
para que puedan ser vistos por toda la clase, así como la llave
pública y privada.
"""
#Aquí también deben de generar su priv_key y pub_key
self.p = generate_prime(100)
self.q = generate_prime(100)
#p = 37
#q = 61
self.n = self.p * self.q
phiN = self.__phi__()
e = randint(1, phiN)
d = mcd_and_quoef(phiN, e)
while not prime_relative(e, phiN) or d < 0:
e = randint(1, phiN)
d = mcd_and_quoef(phiN, e)
self.pub_key = e
self.priv_key = d
pub_keyFile = open("pub_key.pem", 'w')
priv_keyFile = open("priv_key.pem", 'w')
pub_keyFile.write(str(self.n) + "\n")
pub_keyFile.write(str(self.pub_key))
pub_keyFile.close()
priv_keyFile.write(str(self.n) + "\n")
priv_keyFile.write(str(self.priv_key))
priv_keyFile.close()
self.b = 9
self.padding_scheme = True
def lenstra(n):
"""
Implementación del algoritmo de Lenstra para encontrar los factores
primos de un número n de la forma n = p*q. Se asume que la proposición
anterior es cierta, es decir, que en efecto n = p*q, regresando ambos
factores de n.
"""
a, x, y = randint(1, n - 1), randint(1, n - 1), randint(1, n - 1)
b = (pow(y, 2) - pow(x, 3) - (a * x)) % n
E = ec.Curve(a, b, n)
while not prime_relative(E.determinant(), n):
a, x, y = randint(1, n - 1), randint(1, n - 1), randint(1, n - 1)
b = (pow(y, 2) - pow(x, 3) - (a * x)) % n
E = ec.Curve(a, b, n)
p = (x, y)
while not E.is_on_curve(p):
p = (randint(1, n), randint(1, n))
lamb = calculate_lambda(p, p)
point_aux = p
while has_modinv(lamb, n):
point_aux = ec.add_points(p, point_aux, E)
lamb = calculate_lambda(p, point_aux)
p = gcd(lamb, n)
q = n / p
if p == 1 or q == 1:
return lenstra(n)
return (p, q)
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.
Bajo la siguiente formula-> y = Ax+B(mod M), donde x es la posicion del elemento en el alfabeto,
y es la posicion del elemento en el nuevo orden.
M = cardinalidad del alfabeto
"""
self.M = len(alphabet)
self.alphabet=alphabet
if A is None:
self.A=len(alphabet) + 1
self.B=random.randint(0,len(alphabet))
else:
#Verificamos que la longitud del alfabeto y la llave A sean primos relativos
if not prime_relative(A,len(alphabet)):
raise CryptographyException
self.A=A
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
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 encuentraPrimoRelativo(self, n):
for i in range(2, n):
if prime_relative(i, n):
return i
"""
Función auxiliar que busca el inverso multiplicativo del
parámetro A.
Sacado de: https://www.geeksforgeeks.org/multiplicative-inverse-under-modulo-m/
"""
def modInverse(self, a, m):
a = a % m
for x in range(1, m):
if ((a * x) % m == 1):
return x
return 1
"""
Función auxiliar que encuentra un número primo relativo
de acuerdo al número que le pasen.
"""
def encuentraPrimoRelativo(self, n):
for i in range(2, n):
if prime_relative(i, n):
return i
alphabet = "ABCDEFGHIJKLMNÑOPQRSTUVWXYZ"
message = "UNMENSAJEENESPAÑOL"
a = Affine(alphabet)
n = len(alphabet)
print(prime_relative(n, a.A))
def test_constructor():
str_n = str(c.n)
assert len(str_n) >= 100
phi_n = c.__phi__()
assert prime_relative(phi_n, c.pub_key)
assert (c.pub_key * c.priv_key) % phi_n == 1
def test_correct_key():
a = Affine(alphabet)
n = len(alphabet)
assert prime_relative(n, a.A)
def get_prime_relative(self):
while True:
k = randint(1, self.phi)
if prime_relative(k, self.phi):
break
return k