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 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():
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 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("squaretest", generate_keypair, key_agreement, iterations=10000, key_size=SECURITY_LEVEL)
def unit_test():
from unittesting import test_key_agreement
test_key_agreement("noinverse2", 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()
def unit_test():
from unittesting import test_key_agreement
test_key_agreement("noisybase+modulus",
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("s(a + e) / k", generate_keypair, key_agreement, iterations=10000)
