def unit_test(): public1, private1 = generate_keypair() public2, private2 = generate_keypair() share = key_agreement(public1, private2) test = (public1 * public2) # s(a + e) + r == sh + r # x(a + y) + z == xk + z # xk(sh + r) + z(sh + r) == xksh + xkr + zsh + zr # xs(a + y)(a + e) + xr(a + y) + sz(a + e) + zr # xsa + xsy(a + e) + xra + xry + sza + sze + zr # xsa + xsya + xsye + xra + xry + sza + sze + zr # # asx + asxy + exsy + qrx + xry + asz + esz + rz # sx(a + ay + ey) + qrx + xry + asz + esz + rz # sx(a + e) + xr # sx(a + y) + sz # xk(sh + r) + z(sh + r) == xksh + xkr + zsh + zr # ss(a + e)(a + y) + s(a + y)r + s(a + e)z + zr # ssa + sse(a + y) + sra + sry + sza + sze + zr # ssa + ssae + ssey + sra + sry + sza + sze + zr # assert ((public1 * public2) / A) & mask != share from unittesting import test_key_agreement test_key_agreement("s(a + e) key agreement e", generate_keypair, key_agreement, iterations=1000, key_size=SECURITY_LEVEL)
def unit_test(): from unittesting import test_key_agreement test_key_agreement("squaretest", generate_keypair, key_agreement, iterations=10000, key_size=SECURITY_LEVEL)
def unit_test(): from crypto.utilities import modular_inverse public_key1, private1 = generate_keypair() public_key2, private2 = generate_keypair() share = key_agreement(public_key1, private2) print "Broken: ", (public_key1 * public_key2 * modular_inverse(A, MODULUS)) % MODULUS == share from unittesting import test_key_agreement test_key_agreement("truncationtest", generate_keypair, key_agreement, iterations=10000)
def unit_test(): public1, private1 = generate_keypair() public2, private2 = generate_keypair() share = key_agreement(public1, private2) test = (public1 * public2) def f(integer): return int(''.join(char for char in reversed(format(integer, 'b'))), 2) & ((1 << 256) - 1) assert f(share) != f(test), "Broken" from unittesting import test_key_agreement test_key_agreement("s(a + e) key agreement c", generate_keypair, key_agreement, iterations=10000, key_size=SECURITY_LEVEL)
def unit_test(): public1, private1 = generate_keypair() public2, private2 = generate_keypair() share = key_agreement(public1, private2) test = (public1 * public2) def f(integer): return int(''.join(char for char in reversed(format(integer, 'b'))), 2) & ((1 << 256) - 1) assert f(share) != f(test), "Broken" from unittesting import test_key_agreement test_key_agreement("s(a + e) key agreement b", generate_keypair, key_agreement, iterations=1000, key_size=SECURITY_LEVEL)
def unit_test(): from unittesting import test_key_agreement for modulus_size in range(128): modulus = random_integer(modulus_size + 1) modulus = _resize(modulus, modulus_size * 8) globals()["MODULUS_SIZE"] = modulus#_resize(random_integer(modulus_size), modulus_size * 8) try: test_key_agreement("approximatewmodulus", generate_keypair, key_agreement, iterations=10000) except AssertionError: continue else: print "Success!" raw_input()
def test_key_agreement(): public1, private1 = generate_keypair() public2, private2 = generate_keypair() secret1 = key_agreement(public2, private1) secret2 = key_agreement(public1, private2) assert secret1 == secret2, ('\n'.join(('\n' + format(number, 'b')[:80] for number in (secret1, secret2)))) print("Public1: {}".format(public1)) print("Public2: {}".format(public2)) print("secret : {}".format(secret1)) from unittesting import test_key_agreement test_key_agreement("keyagreement6", generate_keypair, key_agreement, iterations=10000)
def test_key_agreement(): public1, private1 = generate_keypair() public2, private2 = generate_keypair() secret1 = key_agreement(public2, private1) secret2 = key_agreement(public1, private2) assert secret1 == secret2, (secret1, secret2) print("Public1: {}".format(public1)) print("Public2: {}".format(public2)) print("secret : {}".format(secret1)) from unittesting import test_key_agreement test_key_agreement("keyagreement8", generate_keypair, key_agreement, iterations=10000)
def unit_test(): for count in range(10000): pub1, priv1 = generate_keypair() pub2, priv2 = generate_keypair() share = key_agreement(pub2, priv1) backdoor_priv1 = backdoor_recover_key(pub1, BACKDOOR_KEY) assert backdoor_priv1 == priv1, (backdoor_priv1, priv1) backdoor_share = key_agreement(pub2, backdoor_priv1) if backdoor_share != share: raise Warning("Unit test failed after {} successfully compromised key exchanges".format(count)) from unittesting import test_key_agreement test_key_agreement("epq_bka", generate_keypair, key_agreement, iterations=10000)
def test_key_agreement(): public1, private1 = generate_keypair() public2, private2 = generate_keypair() secret1 = key_agreement(public2, private1) secret2 = key_agreement(public1, private2) assert secret1 == secret2, (secret1, secret2) print("Public1: {}".format(public1)) print("Public2: {}".format(public2)) print("secret : {}".format(secret1)) from unittesting import test_key_agreement test_key_agreement("keyagreement9", generate_keypair, key_agreement, iterations=10000)
def test_key_agreement(): public1, private1 = generate_keypair() public2, private2 = generate_keypair() secret1 = key_agreement(public2, private1) secret2 = key_agreement(public1, private2) assert secret1 == secret2, ('\n'.join( ('\n' + format(number, 'b')[:80] for number in (secret1, secret2)))) print("Public1: {}".format(public1)) print("Public2: {}".format(public2)) print("secret : {}".format(secret1)) from unittesting import test_key_agreement test_key_agreement("keyagreement6", generate_keypair, key_agreement, iterations=10000)
def unit_test(): from unittesting import test_key_agreement for modulus_size in range(128): modulus = random_integer(modulus_size + 1) modulus = _resize(modulus, modulus_size * 8) globals( )["MODULUS_SIZE"] = modulus #_resize(random_integer(modulus_size), modulus_size * 8) try: test_key_agreement("approximatewmodulus", generate_keypair, key_agreement, iterations=10000) except AssertionError: continue else: print "Success!" raw_input()
def test_key_agreement(): public1, private1 = generate_keypair() public2, private2 = generate_keypair() secret1 = key_agreement(public2, private1) secret2 = key_agreement(public1, private2) assert secret1 == secret2, (secret1, secret2)#('\n'.join(('\n' + format(number, 'b')[:80] for number in (secret1, secret2)))) print("Public1: {}".format(public1)) print("Public2: {}".format(public2)) print("secret : {}".format(secret1)) #a, b = public1[0], public2[0] #print("{}".format(format(a, 'b').zfill(80)[:80])) #print("{}".format(format(b, 'b').zfill(80)[:80])) #print("{}".format(format((a + b) % P, 'b').zfill(80)[:80])) #print("{}".format(format(secret1[0], 'b').zfill(80)[:80])) from unittesting import test_key_agreement test_key_agreement("keyagreement7", generate_keypair, key_agreement, iterations=10000)
def unit_test(): for count in range(10000): pub1, priv1 = generate_keypair() pub2, priv2 = generate_keypair() share = key_agreement(pub2, priv1) backdoor_priv1 = backdoor_recover_key(pub1, BACKDOOR_KEY) assert backdoor_priv1 == priv1, (backdoor_priv1, priv1) backdoor_share = key_agreement(pub2, backdoor_priv1) if backdoor_share != share: raise Warning( "Unit test failed after {} successfully compromised key exchanges" .format(count)) from unittesting import test_key_agreement test_key_agreement("backdoorkeyagreement", generate_keypair, key_agreement, iterations=10000)
def test_key_agreement(): public1, private1 = generate_keypair() public2, private2 = generate_keypair() secret1 = key_agreement(public2, private1) secret2 = key_agreement(public1, private2) assert secret1 == secret2, ( secret1, secret2 ) #('\n'.join(('\n' + format(number, 'b')[:80] for number in (secret1, secret2)))) print("Public1: {}".format(public1)) print("Public2: {}".format(public2)) print("secret : {}".format(secret1)) #a, b = public1[0], public2[0] #print("{}".format(format(a, 'b').zfill(80)[:80])) #print("{}".format(format(b, 'b').zfill(80)[:80])) #print("{}".format(format((a + b) % P, 'b').zfill(80)[:80])) #print("{}".format(format(secret1[0], 'b').zfill(80)[:80])) from unittesting import test_key_agreement test_key_agreement("keyagreement7", generate_keypair, key_agreement, iterations=10000)
def unit_test(): from unittesting import test_key_agreement test_key_agreement("highekeyagreement", generate_keypair, key_agreement, iterations=10000)
def unit_test(): from unittesting import test_key_agreement test_key_agreement("s(a + e) / k", generate_keypair, key_agreement, iterations=10000)
def test_key_agreement(): from unittesting import test_key_agreement test_key_agreement("approximatetwopoint", generate_keypair, key_agreement, iterations=10000)
def test_key_agreement(): from unittesting import test_key_agreement test_key_agreement("secretmoduluskeyagreement", generate_keypair, key_agreement, iterations=10000)
def unit_test(): from unittesting import test_key_agreement test_key_agreement("noisybase+modulus", generate_keypair, key_agreement, iterations=10000)
def unit_test(): from unittesting import test_key_agreement test_key_agreement("noinverse2", generate_keypair, key_agreement, iterations=10000)
def test_key_agreement(): from unittesting import test_key_agreement test_key_agreement("keyagreement2", generate_keypair, key_agreement, iterations=10000)
def unit_test(): from unittesting import test_key_agreement test_key_agreement("decomposetest2", generate_keypair, key_agreement, iterations=10000)
def test_key_agreement(): from unittesting import test_key_agreement test_key_agreement("approximatesquared", generate_keypair, key_agreement, iterations=10000)
def generate_private_key(private_key_size=PRIVATE_KEY_SIZE): return random_integer(private_key_size) def generate_public_key(private_key, a=A, b=B, x=X, y=Y): return point_addition(a, b, x, y, private_key) def generate_keypair(private_key_size=PRIVATE_KEY_SIZE, parameters=(A, B, X, Y)): private_key = generate_private_key(private_key_size) public_key = generate_public_key(private_key, *parameters) return public_key, private_key def key_agreement(public_key, private_key, a=A, b=B, y=Y): return point_addition(a, b, public_key, y, private_key) def test_key_agreement(): from unittesting import test_key_agreement test_key_agreement("keyagreement2", generate_keypair, key_agreement, iterations=10000) def test_inverse(): public1, private1 = generate_keypair() a, b, x, y = A, B, X, Y _public1 = point_addition(a, b, x, y, private1) assert public1 == _public1 _x = compute_inverse(A, B, _public1, Y, private1) assert _x == x, (_x, x) if __name__ == "__main__": test_key_agreement() test_inverse()