def test_encapsulate_key_recover_key(): #pub, priv = generate_keypair() #s = random_integer(S_SIZE) #s |= 1 << S_SHIFT #e = random_integer(E_SIZE) #a = modular_inverse(priv, Q) #r = random_integer(R_SIZE) #print format(s, 'b') #raw_input() #rs = r * s #_r = (rs >> S_SHIFT) & MASK #print format(r, 'b') #print format(_r, 'b') #assert r == _r, (r, _r, len(format(r, 'b')), len(format(_r, 'b'))) #c = (r * ((a * s) + e)) % Q #_r = (((c * priv) % Q) >> S_SHIFT) & MASK #assert (s * r) < Q #from math import log #aisize, esize, rsize = log(priv, 2), log(e, 2), log(r, 2) #assert s > (priv * e * r), (log(s, 2), aisize + esize + rsize) #print format(_r, 'b') #print format(r, 'b') #assert r == _r from unittesting import test_key_exchange test_key_exchange("uppers", generate_keypair, encapsulate_key, recover_key, iterations=10000)
def test_encapsulate_key_recover_key(): from unittesting import test_key_exchange test_key_exchange("qtpie_resized", generate_keypair, encapsulate_key, recover_key, iterations=10000)
def unit_test(): from unittesting import test_key_exchange test_key_exchange("a_asquared", generate_keypair, encapsulate_key, recover_key, iterations=10000)
def test_encapsulate_key_recover_key(): from unittesting import test_key_exchange test_key_exchange("bigpublickey2", generate_keypair, encapsulate_key, recover_key, iterations=10000)
def test_key_exchange(): from unittesting import test_key_exchange test_key_exchange("agreementencapsulationinterface", generate_keypair, encapsulate_key, recover_key, iterations=10000)
def unit_test(): #public1, private1 = generate_keypair() #c1, s1 = encapsulate_key(public1) #c2, s2 = encapsulate_key(public1) #c3, s3 = (c1 + c2), (s1 + s2) #c4, s4 = (c1 * c2), (s1 * s2) % private1[1] # #_s3 = recover_key(c3, private1) #_s4 = recover_key(c4, private1, depth=2) #assert _s3 == s3, (_s3, s3) #assert _s4 == s4, (_s4, s4) # #m1, m2 = 10, 20 #c1 = encrypt(m1, public1) #c2 = encrypt(m2, public1) #c3 = c1 + c2 #m3 = m1 + m2 #c4 = c1 * c2 #m4 = m1 * m2 # #p1 = decrypt(c1, private1) #p2 = decrypt(c2, private1) #p3 = decrypt(c3, private1) #p4 = decrypt(c4, private1, depth=2) #assert p1 == m1, (p1, m1) #assert p2 == m2, (p2, m2) #assert p3 == m3, (p3, m3) #assert p4 == m4, (p4, m4) from unittesting import test_key_exchange test_key_exchange("manyinverses_keyexchange2", generate_keypair, encapsulate_key, recover_key, iterations=10000)
def unit_test(): secret_key = generate_secret_key() c1 = encrypt(1, secret_key) p1 = decrypt(c1, secret_key) assert p1 == 1, (p1, 1) c2 = encrypt(2, secret_key) c3 = c1 + c2 p3 = decrypt(c3, secret_key) assert p3 == 1 + 2, (p3, 3) c6 = c2 * c3 p6 = decrypt(c6, secret_key, depth=2) assert p6 == 2 * 3, (p6, 6) from unittesting import test_symmetric_encrypt_decrypt test_symmetric_encrypt_decrypt("noiselessfhe", generate_secret_key, encrypt, decrypt, iterations=10000) from unittesting import test_key_exchange test_key_exchange("noiselessfhe_kex", generate_keypair, encapsulate_key, recover_key, iterations=10000)
def unit_test(): from unittesting import test_key_exchange test_key_exchange("cutemodulus", generate_keypair, encapsulate_key, recover_key, iterations=10000)
def test_encapsulate_key_recover_key(): from unittesting import test_key_exchange test_key_exchange("uppers+qr", generate_keypair, encapsulate_key, recover_key, iterations=10000)
def unit_test(): from unittesting import test_key_exchange test_key_exchange("twoshortinverses", generate_keypair, encapsulate_key, recover_key, iterations=10000)
def unit_test(): from unittesting import test_key_exchange test_key_exchange("inverseandapproximation", generate_keypair, encapsulate_key, recover_key, iterations=10000)
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 test_public_key_operation_private_key_operation(): from unittesting import test_key_exchange test_key_exchange("axbyabz", generate_keypair, exchange_key, recover_key, iterations=10000)
def test_exchange_key_recover_key(): from unittesting import test_key_exchange test_key_exchange("epqcryptokeyexchange", generate_keypair, exchange_key, recover_key, iterations=10000)
def test_exchange_key_recover_key(): from unittesting import test_key_exchange test_key_exchange("qtpie2pointm", generate_keypair, exchange_key, recover_key, iterations=10000)
def test_exchange_key_recover_key(): from unittesting import test_key_exchange, test_exchange_key_recover_key_time test_key_exchange("qtpiekeyexchange", generate_keypair, exchange_key, recover_key, iterations=10000) print("Performing synthetic speed test (time does not include generation of random numbers)...") def exchange_key_speed_test(public_key, n=N, e=random_integer(32), q=random_integer(32)): return ((public_key * q) + e) % n, e test_exchange_key_recover_key_time(10000, exchange_key_speed_test, recover_key, *generate_keypair(), key_size=32)
def test_encapsulate_key_recover_key(): from unittesting import test_key_exchange test_key_exchange("hard_as_RSA", generate_keypair, encapsulate_key, recover_key, iterations=10000, key_size=SECURITY_LEVEL)
def test_exchange_key_recover_key(): from unittesting import test_key_exchange, test_exchange_key_recover_key_time test_key_exchange("qtpiekeyexchange2", generate_keypair, exchange_key, recover_key, iterations=10000, key_size=16) print("Performing synthetic speed test (time does not include generation of random numbers)...") def exchange_key_speed_test(public_key, e=random_integer(32), q=random_integer(32), n=N): return ((public_key * q) + e) % n, e test_exchange_key_recover_key_time(10000, exchange_key_speed_test, recover_key, *generate_keypair(), key_size=16)
def unit_test(): from unittesting import test_key_exchange test_key_exchange("choseninverses", generate_keypair, encapsulate_key, recover_key, iterations=10000, key_size=SECURITY_LEVEL)
def unit_test(): from unittesting import test_key_exchange test_key_exchange("slideytrapdoor", generate_keypair, encapsulate_key, recover_key, iterations=10000, key_size=SECURITY_LEVEL)
def test_exchange_key_recover_key(): from unittesting import test_key_exchange public_key, private_key = generate_keypair() ciphertext, key = exchange_key(public_key) _key = recover_key(ciphertext, private_key) assert _key == key, (_key, key) test_key_exchange("mullesskeyexchange", generate_keypair, exchange_key, recover_key)
def test_exchange_key_recover_key(): from unittesting import test_key_exchange public_key, private_key = generate_keypair() ciphertext, key = exchange_key(public_key) _key = recover_key(ciphertext, private_key) assert _key == key, (_key, key) test_key_exchange("onepoint", generate_keypair, exchange_key, recover_key)
def unit_test(): from unittesting import test_key_exchange, test_asymmetric_encrypt_decrypt test_key_exchange("separated_kex", generate_keypair, encapsulate_key, recover_key, iterations=10000, key_size=SECURITY_LEVEL) test_asymmetric_encrypt_decrypt("separated_pke", generate_keypair, encrypt, decrypt, iterations=10000)
def test_exchange_key_recover_key(): from unittesting import test_key_exchange test_key_exchange("qtpie2pointma", generate_keypair, exchange_key, recover_key, iterations=10000, key_size=16)
def unit_test(): from unittesting import test_key_exchange, test_sign_verify test_key_exchange("cutemodulus", generate_keypair, encapsulate_key, recover_key, iterations=10000) test_sign_verify("cutemodulus", generate_keypair, sign, verify, iterations=10000, message_size=P_SIZE - 4)
def unit_test(): from unittesting import test_key_exchange test_key_exchange("regularoldinverse", generate_keypair, encapsulate_key, recover_key, iterations=10000)
""" usage: key_agreement(public_key, private_key, shift=930): Returns a shared secret in the form of an integer. The shift argument must be modified if the security_level has been altered from the default. """ s = private_key approximate_shared_point = ((s ** 2) * public_key) output = approximate_shared_point >> shift if not output: raise ValueError("Shared secret was 0") return output def encapsulate_key(public_key1, security_level=SECURITY_LEVEL, points=POINTS): public_key2, private_key2 = generate_keypair(security_level, points) secret = key_agreement(public_key1, private_key2) return public_key2, secret def recover_key(public_key2, private_key): return key_agreement(public_key2, private_key) def test_key_exchange(): from unittesting import test_key_exchange test_key_exchange("agreementencapsulationinterface", generate_keypair, encapsulate_key, recover_key, iterations=10000) def test_key_agreement(): from unittesting import test_key_agreement test_key_agreement("approximatesquared", generate_keypair, key_agreement, iterations=10000) if __name__ == "__main__": test_key_agreement() test_key_exchange()
def test_encapsulate_key_recover_key(): from unittesting import test_key_exchange test_key_exchange("uppers+q", generate_keypair, encapsulate_key, recover_key, iterations=10000)
def encapsulate_key(public_key1, security_level=SECURITY_LEVEL, points=POINTS): public_key2, private_key2 = generate_keypair(security_level, points) secret = key_agreement(public_key1, private_key2) return public_key2, secret def recover_key(public_key2, private_key): return key_agreement(public_key2, private_key) def test_key_exchange(): from unittesting import test_key_exchange test_key_exchange("agreementencapsulationinterface", generate_keypair, encapsulate_key, recover_key, iterations=10000) def test_key_agreement(): from unittesting import test_key_agreement test_key_agreement("approximatesquared", generate_keypair, key_agreement, iterations=10000) if __name__ == "__main__": test_key_agreement() test_key_exchange()
def unit_test(): from unittesting import test_key_exchange test_key_exchange("poweroftwoinverses", generate_keypair, encapsulate_key, recover_key, iterations=10000)