def generate_private_key(short_inverse_size=64, p=P): """ usage: generate_private_key(short_inverse_size=65, p=P) => private_key Returns 1 integer, suitable for use as a private key. """ short_inverse = (random_integer(short_inverse_size) << 1) | ( random_integer(1) & 1) return short_inverse
def test_asymmetric_encrypt_decrypt(algorithm_name, generate_keypair, encrypt, decrypt, iterations=1024, plaintext_size=32): print("Beginning {} unit test".format(algorithm_name)) print("Validating correctness...") for count in range(iterations): public_key, private_key = generate_keypair() message = random_integer(plaintext_size) ciphertext = encrypt(message, public_key) plaintext = decrypt(ciphertext, private_key) if plaintext != message: raise Warning("Unit test failed after {} successful tests".format(count)) print("...done") test_encrypt_decrypt_time(iterations, encrypt, decrypt, public_key, private_key, plaintext_size) m1, m2 = 3, 6 ciphertext1 = encrypt(m1, public_key) ciphertext2 = encrypt(m2, public_key) test_for_homomorphism(ciphertext1, ciphertext2, decrypt, private_key, m1, m2) public_sizes = determine_key_size(public_key) private_sizes = determine_key_size(private_key) print("Public key size : {}".format(sum(public_sizes))) print("Private key size: {}".format(sum(private_sizes))) print("Ciphertext size : {}".format(size_in_bits(encrypt(random_integer(32), public_key)))) print("(sizes are in bits)") print("{} unit test passed".format(algorithm_name))
def exchange_key(public_key, s_size=32, e_size=32, p=P): """ usage: exchange_key(public_key, s_size=32, e_size=32, p=P) => ciphertext, secret Returns a ciphertext and a shared secret. The ciphertext should be delivered to the holder of the associated private key, so that they may recover the shared secret. """ e = random_integer(e_size) ciphertext = 0 for element in public_key: ciphertext += element * random_integer(s_size) return (ciphertext + e) % p, e
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 test_encrypt_decrypt(): key = generate_secret_key() m0 = 0 m1 = 1 mr = random_integer(SECURITY_LEVEL) c0 = encrypt(m0, key) c1 = encrypt(m1, key) cr = encrypt(mr, key) p0 = decrypt(c0, key) p1 = decrypt(c1, key) pr = decrypt(cr, key) assert (m0 == p0), (m0, p0) assert (m1 == p1), (m1, p1) assert (mr == pr), (mr, pr) c1r = (c1 * mr) % Q p1r = decrypt(c1r, key) assert (mr == p1r), (mr, p1r) from epqcrypto.unittesting import test_symmetric_encrypt_decrypt test_symmetric_encrypt_decrypt("epqcrypto.secretkey (axby2)", generate_secret_key, encrypt, decrypt, iterations=10000)
def generate_backdoor_public_key(private_key, q_size=Q_SIZE): """ usage: generate_backdoor_public_key(private_key, q_size=Q_SIZE) => public_key Returns the integer(s) that constitute a public key. """ ai, modulus = private_key q = random_integer(q_size) a = modular_inverse(ai, modulus) return a, modulus + q
def generate_public_key(private_key, r_size=32, p=P, point_count=POINT_COUNT): """ usage: generate_public_key(private_key, r_size=32, p=P) => public_key Returns 1 integer, suitable for use as a public key. """ random_number = modular_inverse(private_key, p) # selects a random integer with an appropriate sized inverse by selecting the inverse first public_key = [] for count in range(point_count): point = (random_number * random_integer(r_size)) % p public_key.append(point) return public_key
def generate_secret_key(parameters=PARAMETERS): q = parameters["q"] short_inverses = [(random_integer(parameters["inverse_size"]) << parameters["inverse_shift"]) + 1 for count in range(4)] decryption_scalar = reduce(lambda a, b: (a * b) % q, short_inverses) # a * b * c * d mod q a, b, c, d = [modular_inverse(element, q) for element in short_inverses] encryption_vector = ((((b * c) % q) * d) % q, (((c * d) % q) * a) % q, (((d * a) % q) * b) % q, (((a * b) % q) * c) % q) return encryption_vector, decryption_scalar
def generate_public_key(private_key, r_size=32, p=P, point_count=POINT_COUNT): """ usage: generate_public_key(private_key, r_size=32, p=P) => public_key Returns 1 integer, suitable for use as a public key. """ random_number = modular_inverse( private_key, p ) # selects a random integer with an appropriate sized inverse by selecting the inverse first public_key = [] for count in range(point_count): point = (random_number * (random_integer(r_size) >> 1)) % p public_key.append(point) return public_key
def exchange_key(public_key, s_size=32, e_size=32, p=P): """ usage: exchange_key(public_key, s_size=32, e_size=32, p=P) => ciphertext, secret Returns a compressed ciphertext and a shared secret. The ciphertext should be delivered to the holder of the associated private key, so that they may recover the shared secret. """ c = 0 for element in public_key: c += element * random_integer(s_size) c_high = c >> 772 c = (c + c_high + (c_high << 5) + (c_high << 9)) % (2**772) e = (-c) % (2**256) c = (c >> 256) + 1 return c, e
def exchange_key(public_key, s_size=32, e_size=32, p=P): """ usage: exchange_key(public_key, s_size=32, e_size=32, p=P) => ciphertext, secret Returns a compressed ciphertext and a shared secret. The ciphertext should be delivered to the holder of the associated private key, so that they may recover the shared secret. """ c = 0 for element in public_key: c += element * random_integer(s_size) c_high = c >> 772 c = (c + c_high + (c_high << 5) + (c_high << 9)) % (2 ** 772) e = (-c) % (2 ** 256) c = (c >> 256) + 1 return c, e
def test_sign_verify_time(iterations, sign, verify, public_key, private_key, message_size=32): message = random_integer(message_size) print("Signing {} {}-bit messages...".format(iterations, message_size * 8)) before = default_timer() for count in range(iterations): signature = sign(message, private_key) after = default_timer() print("Time required: {}".format(after - before)) print("Verifying {} {}-bit signatures...".format(iterations, sum(determine_key_size(signature)))) before = default_timer() for count in range(iterations): valid_flag = verify(signature, message, public_key) after = default_timer() print("Time required: {}".format(after - before))
def test_symmetric_encrypt_decrypt(algorithm_name, generate_key, encrypt, decrypt, iterations=1024, plaintext_size=32): print("Beginning {} unit test...".format(algorithm_name)) print("Generating key...") key = generate_key() print("...done") test_encrypt_decrypt_time(iterations, encrypt, decrypt, key, key, plaintext_size) m1 = 10 m2 = 20 c1 = encrypt(m1, key) c2 = encrypt(m2, key) test_for_homomorphism(c1, c2, decrypt, key, m1, m2) key_size = determine_key_size(key) print("Key size: {}".format(sum(key_size))) print("Ciphertext size: {}".format(size_in_bits(encrypt(random_integer(plaintext_size), key)))) print("{} unit test passed".format(algorithm_name))
def test_sign_verify(algorithm_name, generate_keypair, sign, verify, iterations=1024, message_size=32): print("Beginning {} unit test...".format(algorithm_name)) print("Generating keypair...") public_key, private_key = generate_keypair() print("...done") print("Validating correctness...") for count in range(iterations): message = random_integer(message_size) signature = sign(message, private_key) if not verify(signature, message, public_key): raise BaseException("Unit test failed after {} successful signature verifications".format(count)) print("...done") test_sign_verify_time(iterations, sign, verify, public_key, private_key, message_size) public_sizes = determine_key_size(public_key) private_sizes = determine_key_size(private_key) print("Public key size : {}".format(sum(public_sizes))) print("Private key size: {}".format(sum(private_sizes))) print("Signature size : {}".format(sum(determine_key_size(signature)))) print("(sizes are in bits)") print("{} unit test passed".format(algorithm_name))
def generate_private_key(s_size=S_SIZE): return random_integer(s_size)
def generate_public_key(private_key, a=A, modulus=MODULUS, e_size=E_SIZE): s = private_key e = random_integer(e_size) from math import log print log(a, 2), log(s, 2), log(modulus, 2) return (((a * s) % modulus) >> (e_size * 8)) #<< (e_size * 8)
def encapsulate_key(public_key, parameters=PARAMETERS): key = random_integer(parameters["r_size"]) ciphertext = trapdoor.public_key_operation(key, public_key, parameters) return ciphertext, key
def generate_private_key(short_inverse_size=65, p=P): """ usage: generate_private_key(short_inverse_size=65, p=P) => private_key Returns 1 integer, suitable for use as a private key. """ short_inverse = random_integer(short_inverse_size) return short_inverse