def generate_public_key(private_key, c_size=32, p=P): ai, bi = private_key a = modular_inverse(ai, p) b = modular_inverse(bi, p) c = random_integer(c_size) public_key = ((a * b) % p, (a * c) % p) return public_key
def generate_public_key(private_key, modulus=P): x_i, z_i, xz_i = private_key x = modular_inverse(x_i, modulus) z = modular_inverse(z_i, modulus) a = modular_subtraction(z, x, modulus) # z - x public_key = ((a * x) + (x * 2)) % modulus return public_key
def generate_public_key(private_key, q_size=32, n=N): p = modular_inverse(private_key, n) pq = (p * random_integer(q_size)) % n assert log(n, 2) - log(pq, 2) < 256 assert log(n, 2) - log(modular_inverse(pq, n), 2) < 256, (log( n, 2), log(n - modular_inverse(pq, n), 2)) return pq
def generate_pq(private_key, q_size=32, n=N): p = modular_inverse(private_key, n) q = random_integer(q_size) pq = (p * q) % n assert log(n, 2) - log(pq, 2) < 256 assert log(n, 2) - log(modular_inverse(pq, n), 2) < 256, (log(n, 2), log(n - modular_inverse(pq, n), 2)) return pq, q
def generate_public_key(private_key, modulus=P): x_i, z_i, xz_i = private_key x = modular_inverse(x_i, modulus) z = modular_inverse(z_i, modulus) a = modular_subtraction(z, x, modulus) # z - x public_key = ((a * x) + (x * 2)) % modulus return public_key
def generate_public_key(private_key, c_size=32, p=P): ai, bi = private_key a = modular_inverse(ai, p) b = modular_inverse(bi, p) c = random_integer(c_size) public_key = ((a * b) % p, (a * c) % p) return public_key
def generate_public_key(private_key, security_level=SECURITY_LEVEL): a = modular_inverse((2, private_key * big_prime(security_level)) b = modular_inverse((3, private_key * big_prime(security_level)) return a, b def generate_keypair(security_level=SECURITY_LEVEL): private_key = generate_private_key(security_level) public_key = generate_public_key(private_key, security_level) return public_key, private_key def encapsulate_key(public_key, security_level=SECURITY_LEVEL): a, b = public_key s1 = random_integer(security_level) s2 = random_integer(security_level) e = random_integer(security_level) shared_secret = (3 * s1) + (2 * s2) + (6 * e) ciphertext = ((a * s1) + (b * s2) + e) return ciphertext, shared_secret def recover_key(ciphertext, private_key): return (ciphertext * 6) % private_key def unit_test(): from unittesting import test_key_exchange test_key_exchange("knowninverses", generate_keypair, encapsulate_key, recover_key, iterations=10000) if __name__ == "__main__": unit_test()
def generate_public_key(private_key): """ usage: generate_public_key(private_key) => public_key Returns the integer(s) that constitute a public key. """ a_i, b_i, ab_i, p = private_key a = modular_inverse(a_i, p) b = modular_inverse(b_i, p) return a, b
def generate_public_key(private_key): """ usage: generate_public_key(private_key) => public_key Returns the integer(s) that constitute a public key. """ a_i, b_i, ab_i, p = private_key a = modular_inverse(a_i, p) b = modular_inverse(b_i, p) return a, b
def generate_secret_key(parameters=PARAMETERS, q=Q): inverse_size = parameters["inverse_size"] inverse_shift = parameters["inverse_shift"] ai = (random_integer(inverse_size) << inverse_shift) + 1 bi = (random_integer(inverse_size) << inverse_shift) + 1 d = (ai * bi) % q a = modular_inverse(ai, q) b = modular_inverse(bi, q) return a, b, d
def generate_secret_key(parameters=PARAMETERS, q=Q): inverse_size = parameters["inverse_size"] inverse_shift = parameters["inverse_shift"] ai = (random_integer(inverse_size) << inverse_shift) + 1 bi = (random_integer(inverse_size) << inverse_shift) + 1 d = (ai * bi) % q a = modular_inverse(ai, q) b = modular_inverse(bi, q) return Key_Tuple((a, b), d)
def generate_public_key(private_key, security_level=SECURITY_LEVEL, public_key_size=PUBLIC_KEY_SIZE): ai, modulus = private_key a = modular_inverse(ai, modulus) public_key = [] while len(public_key) < public_key_size: try: public_key.append(a + modular_inverse(ai, modulus * random_integer(security_level))) except ValueError: continue return public_key
def generate_private_key(r_size=R_SIZE, inverse=INVERSE, q=Q): while True: r = random_integer(r_size) try: modular_inverse(inverse, q + r) except ValueError: continue else: break return r
def generate_public_key(private_key, security_level=SECURITY_LEVEL, public_key_size=PUBLIC_KEY_SIZE): ai, modulus = private_key public_key = [] while len(public_key) < public_key_size: try: public_key.append(modular_inverse(ai, modulus * random_integer(security_level)) + modular_inverse(ai, modulus * random_integer(security_level))) except ValueError: continue return public_key
def generate_private_key(r_size=R_SIZE, inverse=INVERSE, q=Q): while True: r = random_integer(r_size) try: modular_inverse(inverse, q + r) except ValueError: continue else: break return r
def generate_private_key(security_level=SECURITY_LEVEL): while True: short_inverse = random_integer((security_level * 2) + 3) modulus = random_integer((security_level * 3) + 5) try: modular_inverse(short_inverse, modulus) except ValueError: continue else: break return short_inverse, modulus
def generate_private_key(inverse_size=INVERSE_SIZE, r_size=R_SIZE, q=Q, shift=SHIFT): while True: inverse = random_integer(inverse_size) << shift r = random_integer(r_size) try: modular_inverse(inverse, q + r) except ValueError: continue else: break return inverse, r
def generate_private_key(inverse_size=INVERSE_SIZE, inverse_shift=INVERSE_SHIFT, q_size=Q_SIZE): while True: inverse = random_integer(inverse_size) << inverse_shift q = random_integer(q_size) try: modular_inverse(inverse, q) except ValueError: continue else: break return inverse, q
def generate_private_key(inverse_size=INVERSE_SIZE, p_size=P_SIZE): while True: inverse = random_integer(inverse_size) modulus = random_integer(p_size) try: modular_inverse(inverse, modulus) except ValueError: continue else: break return inverse, modulus
def generate_private_key(security_level=SECURITY_LEVEL): while True: ai = random_integer((security_level * 2) + 3) modulus = random_integer((security_level * 5) + 5) try: modular_inverse(ai, modulus) except ValueError: continue else: break return ai, modulus
def generate_private_key(inverse_size=INVERSE_SIZE, q_size=Q_SIZE): while True: ai = random_integer(inverse_size) q = random_integer(q_size + 4) try: modular_inverse(ai, q) except ValueError: continue else: break return ai, q
def generate_private_key(security_level=SECURITY_LEVEL): while True: modulus = random_integer(security_level + 1) try: a = modular_inverse(2, modulus) b = modular_inverse(3, modulus) except ValueError: continue else: break return modulus
def generate_private_key(security_level=SECURITY_LEVEL): while True: modulus = big_prime(security_level + 3) ai = random_integer(security_level) try: modular_inverse(ai, modulus) except ValueError: continue else: break return ai, ((ai * ai) + (ai * ai)) % modulus, modulus
def generate_private_key(inverse_size=INVERSE_SIZE, q_size=Q_SIZE, shift=SHIFT): while True: ai = random_integer(inverse_size) << shift q = random_integer(q_size) try: modular_inverse(ai, q) except ValueError: continue else: break return ai, q
def generate_private_key(inverse_size=INVERSE_SIZE, p_size=P_SIZE): while True: inverse = random_integer(inverse_size) modulus = random_integer(p_size) try: modular_inverse(inverse, modulus) except ValueError: continue else: break return inverse, modulus
def generate_private_key(security_level=SECURITY_LEVEL): while True: modulus = big_prime(security_level + 3) ai = random_integer(security_level) try: modular_inverse(ai, modulus) except ValueError: continue else: break return ai, ((ai * ai) + (ai * ai)) % modulus, modulus
def generate_private_key(security_level=SECURITY_LEVEL): modulus = random_integer((security_level * 2) + 5) ai = random_integer(security_level + 2) while True: try: modular_inverse(ai, modulus) except ValueError: modulus += 1 continue else: break return ai, modulus
def generate_private_key(inverse_size=INVERSE_SIZE, k_size=K_SIZE, q=Q): shift = inverse_size * 8 while True: ai = random_integer(inverse_size) << shift q_k = q + random_integer(k_size) try: modular_inverse(ai, q_k) except ValueError: continue else: break return ai, q_k
def generate_key(security_level=SECURITY_LEVEL, p=P): while True: k1 = random_integer(32) k2 = random_integer(32) try: k1i = modular_inverse(k1, p - 1) k2i = modular_inverse(k2, p - 1) except ValueError: continue else: break return (k1, k2), (k1i, k2i)
def generate_private_key(security_level=SECURITY_LEVEL): modulus_size = (security_level * 3) + 3 while True: ai = random_integer(modulus_size - 3) modulus = random_integer(modulus_size) try: modular_inverse(ai, modulus) except ValueError(): continue else: break return ai, modulus
def generate_private_key(inverse_size=INVERSE_SIZE, q_size=Q_SIZE, modulus=MODULUS): while True: ai = random_integer(inverse_size) q = random_integer(q_size) try: a = modular_inverse(ai, modulus) qi = modular_inverse(q, modulus) except ValueError: continue else: break return ai, qi
def generate_public_parameters(security_level=SECURITY_LEVEL): A = random_integer(security_level + 2) N = random_integer(security_level) while True: try: bad_parameters = modular_inverse(A % N, N) bad_parameters = modular_inverse(A - N, N) except ValueError: break # good parameters found else: A = random_integer(security_level + 2) N = random_integer(security_level) return A, N
def generate_private_key(inverse_size=INVERSE_SIZE, r_size=R_SIZE, q=Q, shift=SHIFT): """ usage: generate_private_key(inverse_size=INVERSE_SIZE, q_size=Q_SIZE) => private_key Returns the integer(s) that constitute a private key. """ while True: inverse = (random_integer(inverse_size) << shift) | 1 try: modular_inverse(inverse, q) except ValueError: continue else: break return inverse
def generate_private_key(security_level=SECURITY_LEVEL): p_size = (security_level * 2) + 1 a_size = security_level + 1 while True: p = random_integer(p_size) a_i = random_integer(a_size) # adds 1 extra bit try: modular_inverse(a_i, p) except ValueError: continue else: break return a_i, p
def generate_private_key(security_level=SECURITY_LEVEL, padding1=3, padding2=6): while True: short_inverse = random_integer((security_level * 2) + padding1) modulus = random_integer((security_level * 3) + padding2) try: modular_inverse(short_inverse, modulus) except ValueError: continue else: break return short_inverse, modulus
def generate_public_parameters(security_level=SECURITY_LEVEL): A = random_integer(security_level + 2) N = random_integer(security_level) while True: try: bad_parameters = modular_inverse(A % N, N) bad_parameters = modular_inverse(A - N, N) except ValueError: break # good parameters found else: A = random_integer(security_level + 2) N = random_integer(security_level) return A, N
def generate_backdoor_private_key(inverse_size=INVERSE_SIZE, p_size=P_SIZE): """ usage: generate_backdoor_private_key(inverse_size=INVERSE_SIZE, p_size=P_SIZE) => private_key Returns the integer(s) that constitute a private key. """ while True: inverse = random_integer(inverse_size) modulus = random_integer(p_size) try: modular_inverse(inverse, modulus) except ValueError: continue else: break return inverse, modulus
def generate_private_key(parameters=PARAMETERS): inverse_size = parameters["inverse_size"] q_size = parameters["q_size"] while True: inverse = random_integer(inverse_size) q = random_integer(q_size) try: modular_inverse(inverse, q) except ValueError: continue else: if gcd(inverse, q) == 1: break return inverse, q
def generate_private_key(inverse_size=INVERSE_SIZE, k_size=K_SIZE, q=Q, shift=SHIFT): """ usage: generate_private_key(inverse_size=INVERSE_SIZE, q_size=Q_SIZE) => private_key Returns the integer(s) that constitute a private key. """ while True: inverse = random_integer(inverse_size) << shift k = random_integer(k_size) try: modular_inverse(inverse, q + k) except ValueError: continue else: break return inverse, q + k
def generate_private_key(inverse_size=INVERSE_SIZE, modulus=MODULUS): """ usage: generate_private_key(inverse_size=INVERSE_SIZE, modulus=MODULUS) => private_key Returns the integer(s) that constitute a private key. It is recommended to use generate_keypair instead of generate_private_key for normal use cases. """ while True: ai = random_integer(inverse_size) try: modular_inverse(ai, modulus) except ValueError: continue else: break return ai
def generate_key(parameters=PARAMETERS): k_size = parameters["k_size"] p = parameters['p'] while True: k1 = random_integer(k_size) k2 = random_integer(k_size) try: k1i = modular_inverse(k1, p - 1) k2i = modular_inverse(k2, p - 1) except ValueError: continue else: break return (k1, k2)
def generate_key(parameters=PARAMETERS): k_size = parameters["k_size"] p = parameters['p'] while True: k1 = random_integer(k_size) k2 = random_integer(k_size) try: k1i = modular_inverse(k1, p - 1) k2i = modular_inverse(k2, p - 1) except ValueError: continue else: break return (k1, k2)
def generate_backdoor_private_key(inverse_size=INVERSE_SIZE, p_size=P_SIZE): """ usage: generate_backdoor_private_key(inverse_size=INVERSE_SIZE, p_size=P_SIZE) => private_key Returns the integer(s) that constitute a private key. """ while True: inverse = random_integer(inverse_size) modulus = random_integer(p_size) try: modular_inverse(inverse, modulus) except ValueError: continue else: break return inverse, modulus
def generate_private_key(parameters=PARAMETERS): inverse_size = parameters["inverse_size"] q_size = parameters["q_size"] while True: inverse = random_integer(inverse_size) q = random_integer(q_size) try: modular_inverse(inverse, q) except ValueError: continue else: if gcd(inverse, q) == 1: break return inverse, q
def generate_private_key(inverse_size=INVERSE_SIZE, r_size=R_SIZE, q=Q, shift=SHIFT): while True: inverse = random_integer(inverse_size) << shift r = random_integer(r_size) try: modular_inverse(inverse, q + r) except ValueError: continue else: break return inverse, r
def sign(ciphertext, private_key, message_size=4): primes, key, modulus = private_key ciphertext = (modular_inverse(key, modulus) * ciphertext) % modulus plaintext_bits = ['0'] * (message_size * 8) for count in range(2): for index, prime in enumerate(reversed(primes)): if ciphertext % prime == 0: print "Setting bit: ", index, prime plaintext_bits[index] = '1' ciphertext = (ciphertext * modular_inverse(prime, modulus)) % modulus else: print "Prime not in ciphertext", prime return int(''.join(plaintext_bits), 2)
def generate_public_key(private_key, q=Q, a_shift=A_SHIFT): """ usage: generate_public_key(private_key, r_size=R_SIZE) => public_key Returns the integer(s) that constitute a public key. """ ai = private_key a = modular_inverse(ai, q) >> a_shift return a
def generate_public_key(private_key, x_size=X_SIZE, z_size=Z_SIZE, z_shift=Z_SHIFT, public_key_size=PUBLIC_KEY_SIZE, q=Q): ai, bi, d = private_key a = modular_inverse(ai, q) b = modular_inverse(bi, q) ab = (a * b) % q public_key = [] payload_bits = 1 << z_shift for element_number in range(public_key_size): x = random_integer(x_size) y = random_integer(x_size) z = payload_bits | random_integer(z_size) element = ((a * x) + (b * y) + (ab * z) + random_integer(SECURITY_LEVEL - 1)) % q public_key.append(element) return public_key
def generate_public_key(private_key, r_size=R_SIZE, x_size=X_SIZE): ai, q = private_key r = random_integer(r_size) x = random_integer(x_size) a = modular_inverse(ai, q) # print log(ai, 2), log(q, 2), log(r, 2), log(x, 2) return a, (q * r) + x
def generate_public_key(private_key, security_level=SECURITY_LEVEL, public_key_size=PUBLIC_KEY_SIZE): short_inverse, modulus = private_key a = modular_inverse(short_inverse, modulus) return [(a * (random_integer(security_level))) % modulus for count in range(public_key_size)]
def sign(ciphertext, private_key, message_size=4): primes, key, modulus = private_key ciphertext = (modular_inverse(key, modulus) * ciphertext) % modulus plaintext_bits = ['0'] * (message_size * 8) for count in range(2): for index, prime in enumerate(reversed(primes)): if ciphertext % prime == 0: print "Setting bit: ", index, prime plaintext_bits[index] = '1' ciphertext = (ciphertext * modular_inverse(prime, modulus)) % modulus else: print "Prime not in ciphertext", prime return int(''.join(plaintext_bits), 2)
def generate_public_key(private_key, r_size=R_SIZE, x_size=X_SIZE): ai, q = private_key r = random_integer(r_size) x = random_integer(x_size) a = modular_inverse(ai, q) # print log(ai, 2), log(q, 2), log(r, 2), log(x, 2) return a, (q * r) + x
def generate_public_key(private_key, q=Q, a_shift=A_SHIFT): """ usage: generate_public_key(private_key, q=Q, k_size=K_SIZE) => public_key Returns the integer that constitutes a public key. """ ai, q_k = private_key a = modular_inverse(ai, q_k) return (a >> a_shift) << a_shift