def generate_keys(self):
""" Generates encryption and decryption key """
# Number of bits needed to represent ASCII
num_of_bits = 8
# Make random primes until they are not equal
prime1 = generate_random_prime(num_of_bits)
prime2 = generate_random_prime(num_of_bits)
while prime1 == prime2:
prime1 = generate_random_prime(num_of_bits)
prime2 = generate_random_prime(num_of_bits)
prime_product = prime1 * prime2
phi = (prime1 - 1) * (prime2 - 1)
rand_num = random.randint(3, phi - 1)
inverse_rand_num = modular_inverse(rand_num, phi)
# Have not found an inverse:
while not inverse_rand_num:
rand_num = random.randint(3, phi - 1)
inverse_rand_num = modular_inverse(rand_num, phi)
public_key = (prime_product, rand_num)
secret_key = (prime_product, inverse_rand_num)
print('Valid key pair found!')
print('Public key:', public_key)
print('Secret key:', secret_key)
return secret_key, public_key
def generate_key(self):
p = crypto_utils.generate_random_prime(5)
q = crypto_utils.generate_random_prime(5)
while p == q:
q = crypto_utils.generate_random_prime(5)
self.n = p * q
o = (p-1) * (q-1)
self.e = random.randint(3, o-1)
self.d = crypto_utils.modular_inverse(self.e, o)
return self.n, self.e, self.d
def generate_key(self):
p = generate_random_prime(50)
q = generate_random_prime(50)
while p == q:
q = generate_random_prime(50)
_n = p * q
phi = (p - 1) * (q - 1)
while True:
e = random.randint(3, phi - 1)
d = modular_inverse(e, phi)
if d != False:
return ((_n, e), (_n, d))
def generate_random_rsa_primes(self, bits=8):
"""Generate the public and private keys for the RSA encryption/decryption"""
prime_one = crypto_utils.generate_random_prime(bits)
prime_two = crypto_utils.generate_random_prime(bits)
while prime_one == prime_two:
prime_two = crypto_utils.generate_random_prime(bits)
n = prime_one * prime_two
ø = (prime_one - 1) * (prime_two - 1)
e = random.randint(3, ø - 1)
while math.gcd(e, ø) != 1:
e = random.randint(3, ø - 1)
d = crypto_utils.modular_inverse(e, ø)
self.set_key((n, d))
return n, e
def generate_keys(self):
p = q = 0
gCd = 1
while (p == q or gCd != 1):
p = cu.generate_random_prime(8)
q = cu.generate_random_prime(8)
phi = (p - 1) * (q - 1)
e = random.randint(3, (phi - 1))
d = cu.modular_inverse(e, phi)
gCd = gcd(e, phi)
n = p * q
self.sender_key = (n, e)
self.key = (n, d)
def generate_keys(self):
"""Genererer et sett med public og private nøkkler"""
rsa_p = crypto_utils.generate_random_prime(self.rsa_b)
rsa_q = crypto_utils.generate_random_prime(self.rsa_b)
while rsa_p == rsa_q:
rsa_q = crypto_utils.generate_random_prime(self.rsa_b)
rsa_n = rsa_p * rsa_q
rsa_phi = (rsa_p - 1) * (rsa_q - 1)
rsa_e = random.randint(3, rsa_phi - 1)
rsa_d = crypto_utils.modular_inverse(rsa_e, rsa_phi)
while not rsa_d:
rsa_e = random.randint(3, rsa_phi - 1)
rsa_d = crypto_utils.modular_inverse(rsa_e, rsa_phi)
print("Public key: (" + str(rsa_n) + ", " + str(rsa_e) + ")\n"
"Private key: (" + str(rsa_n) + ", " + str(rsa_d) + ")")
def gen_key_pair():
prime_p = 0
prime_q = prime_p
while prime_p == prime_q:
prime_p = crypto_utils.generate_random_prime(8)
prime_q = crypto_utils.generate_random_prime(8)
num = prime_p * prime_q
phi = (prime_p - 1) * (prime_q - 1)
inverse_d = None
while inverse_d is None:
rand_e = random.randint(3, phi - 1)
inverse_d = strict_modular_inverse(rand_e, phi)
return ((num, rand_e), (num, inverse_d))
def generate_keys(self):
'''Generating two keys'''
rsa_p = crypto_utils.generate_random_prime(8)
rsa_q = crypto_utils.generate_random_prime(8)
while rsa_p == rsa_q:
rsa_p = crypto_utils.generate_random_prime(8)
rsa_q = crypto_utils.generate_random_prime(8)
rsa_n = rsa_p * rsa_q
phi = (rsa_p - 1) * (rsa_q - 1)
rsa_e = random.randint(3, phi - 1)
rsa_d = crypto_utils.modular_inverse(rsa_e, phi)
while not rsa_d:
rsa_e = random.randint(3, phi - 1)
rsa_d = crypto_utils.modular_inverse(rsa_e, phi)
return rsa_n, rsa_d, rsa_e
def generate_keys(self):
while True:
p_p = crypto_utils.generate_random_prime(8)
q_q = crypto_utils.generate_random_prime(8)
while q_q == p_p:
q_q = crypto_utils.generate_random_prime(8)
n_n = p_p * q_q
phi = (p_p - 1) * (q_q - 1)
e_e = random.randint(3, phi - 1)
d_d = crypto_utils.modular_inverse(e_e, phi)
if d_d != None:
break
self.encryption_key = (n_n, e_e)
self.decryption_key = (n_n, d_d)
return (self.encryption_key, self.decryption_key)
def generate_keys():
"""genererer nøkler og returnerer [private-key, public-key]"""
p_1 = 1
q = 1
while p_1 == q:
p_1 = generate_random_prime(8)
q = generate_random_prime(8)
n = p_1 * q
phi = (p_1-1)*(q-1)
d = None
while d is None:
e = randint(3, phi - 1)
anwser = modular_inverse(e, phi)
if anwser:
d = anwser
public_key = (n, e)
private_key = (n, d)
return (public_key, private_key)
def generate_rsa_keys(self):
"""public key used by senders"""
p_prime = cu.generate_random_prime(8)
q_prime = cu.generate_random_prime(8)
while p_prime == q_prime:
q_prime = cu.generate_random_prime(8)
n_prime = p_prime * q_prime
_phi = (p_prime - 1) * (q_prime - 1)
e_prime = cu.random.randint(3, _phi - 1)
d_prime = cu.modular_inverse(e_prime, _phi)
while not d_prime: # It is important that e has a modulo inverse based on _phi
e_prime = cu.random.randint(3, _phi - 1)
d_prime = cu.modular_inverse(e_prime, _phi)
self.key = (n_prime, d_prime)
self.public_key = (n_prime, e_prime)
def generate_keys(self):
from crypto_utils import generate_random_prime
p = generate_random_prime(20)
q = generate_random_prime(18)
while q == p:
q = generate_random_prime(18)
n = p * q
φ = (p-1) * (q-1)
from random import randint
while True:
e = randint(3, φ-1)
d = modular_inverse(e, φ)
if d is not None: break
return ((n,e), (n,d))
def generate_keys(self):
"""Generate encryption keys"""
prime1 = generate_random_prime(self._n_bits)
while True:
prime2 = generate_random_prime(self._n_bits)
if prime1 != prime2:
break
print('Primes: ', prime1, ', ', prime2)
prime_product = prime1 * prime2
phi = (prime1 - 1) * (prime2 - 1)
while True:
random_int = randint(3, (phi - 1))
inverse = modular_inverse(random_int, phi)
if inverse:
break
return (prime_product, random_int), (prime_product, inverse)
def generate_keys(self, bits=128):
'''
Generate an RSA-key
'''
p = cu.generate_random_prime(bits)
q = cu.generate_random_prime(bits)
while p == q:
q = cu.generate_random_prime(bits)
n = p * q
phi = (p - 1) * (q - 1)
d = False
while not d:
e = random.randint(3, phi - 1)
d = cu.modular_inverse(e, phi)
self.key = (n, d)
return (n, e)
def generate_keys():
p = 1
q = 1
while p == q:
p = generate_random_prime(1024)
q = generate_random_prime(1024)
n = p * q
phi = (p - 1) * (q - 1)
while True:
e = random.randint(3, phi - 1)
d = modular_inverse(e, phi)
if d:
break
public_key = (n, e)
private_key = (n, d)
return [public_key, private_key]
def generate_keys(self):
p, q = 0, 0
check_keys = -1
# 5 step method
while p == q:
# (1) generate two random primes p & q in range 2^8 to 2^9
p = crypto_utils.generate_random_prime(8)
q = crypto_utils.generate_random_prime(8)
# (2) define n and phi as following
phi = (p - 1) * (q - 1)
n = p * q
# (3) generate a random number between 3 and phi-1
encode_key = randint(3, phi - 1)
# (4) we want the inverse mod of e with respect for phi
try:
decode_key = crypto_utils.modular_inverse(encode_key, phi)
return (n, encode_key), (n, decode_key)
except:
self.generate_keys()
def generate_keys(self):
p = crypto_utils.generate_random_prime(8)
q = -1
while q == -1 or q == p:
q = crypto_utils.generate_random_prime(8)
n = p * q
phi = (p - 1)*(q - 1)
e = randint(2, phi - 1)
d = crypto_utils.modular_inverse(e, phi)
while not d:
p = crypto_utils.generate_random_prime(8)
q = -1
while q == -1 or q == p:
q = crypto_utils.generate_random_prime(8)
n = p * q
phi = (p - 1)*(q - 1)
e = randint(2, phi - 1)
d = crypto_utils.modular_inverse(e, phi)
sender_key = (n, e)
receiver_key = (n, d)
return [sender_key, receiver_key]
def generate_keys(self):
"""
Generate keys for sender and receiver
:return: key_one is for sender and key_two is for receiver
"""
while True:
prime_p = generate_random_prime(self.__bits__)
prime_q = generate_random_prime(self.__bits__)
if prime_p != prime_q:
break
n = prime_p * prime_q
theta = (prime_p - 1) * (prime_q - 1)
while True:
e = random.randint(3, theta - 1)
if gcd(e, theta) == 1:
break
d = modular_inverse(e, theta)
key_encrypt = (n, e)
key_decrypt = (n, d)
return key_encrypt, key_decrypt
def generate_keys(self):
"""metode som genererer krypteringsnøkler"""
p = crypto_utils.generate_random_prime(8)
q = -1
while q == -1 or q == p:
q = crypto_utils.generate_random_prime(8)
n = p * q
phi = (p - 1) * (q - 1)
e = randint(3, phi - 1)
d = crypto_utils.modular_inverse(e, phi)
while not d:
p = crypto_utils.generate_random_prime(8)
q = -1
while q == -1 or q == p:
q = crypto_utils.generate_random_prime(8)
n = p * q
phi = (p - 1) * (q - 1)
e = randint(3, phi - 1)
d = crypto_utils.modular_inverse(e, phi)
encode_key = [n, e]
decode_key = [n, d]
return [encode_key, decode_key]
def generate_key(alphabet_size):
num_bits = 8
prime1 = generate_random_prime(num_bits)
prime2 = generate_random_prime(num_bits)
while prime1 == prime2:
prime2 = generate_random_prime(num_bits)
prime_factor = prime1 * prime2
phi = (prime1 - 1) * (prime2 - 1)
encrypt = decrypt = 0
mod_found = False
while not mod_found:
encrypt = randint(3, phi - 1)
decrypt = modular_inverse(encrypt, phi)
mod_found = ((encrypt * decrypt) % phi == 1)
public = (prime_factor, encrypt)
private = (prime_factor, decrypt)
return public, private
def primes(bits=1024):
"""Helper function that returns a prime generator
with a set number of bits"""
while True:
yield generate_random_prime(bits)
def generate_keys(self):
first_random_prime = crypto_utils.generate_random_prime(8)
while (second_random_prime :=
crypto_utils.generate_random_prime(8)) == first_random_prime:
pass
