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