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 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 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("cutemodulus", generate_keypair, encapsulate_key, recover_key, iterations=10000)
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 unit_test():
from unittesting import test_key_exchange
test_key_exchange("regularoldinverse", generate_keypair, encapsulate_key, recover_key, iterations=10000)
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)
""" 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_key_exchange():
from unittesting import test_key_exchange
test_key_exchange("agreementencapsulationinterface", generate_keypair, encapsulate_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 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 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 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 unit_test():
from unittesting import test_key_exchange
test_key_exchange("inverseandapproximation", 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)
