def generate_public_key(private_key, c_size=32, p=P):
ai, bi = private_key
a = modular_inverse(ai, p)
b = modular_inverse(bi, p)
c = random_integer(c_size)
public_key = ((a * b) % p, (a * c) % p)
return public_key
def generate_public_key(private_key, modulus=P):
x_i, z_i, xz_i = private_key
x = modular_inverse(x_i, modulus)
z = modular_inverse(z_i, modulus)
a = modular_subtraction(z, x, modulus) # z - x
public_key = ((a * x) + (x * 2)) % modulus
return public_key
def generate_public_key(private_key, q_size=32, n=N):
p = modular_inverse(private_key, n)
pq = (p * random_integer(q_size)) % n
assert log(n, 2) - log(pq, 2) < 256
assert log(n, 2) - log(modular_inverse(pq, n), 2) < 256, (log(
n, 2), log(n - modular_inverse(pq, n), 2))
return pq
def generate_pq(private_key, q_size=32, n=N):
p = modular_inverse(private_key, n)
q = random_integer(q_size)
pq = (p * q) % n
assert log(n, 2) - log(pq, 2) < 256
assert log(n, 2) - log(modular_inverse(pq, n), 2) < 256, (log(n, 2), log(n - modular_inverse(pq, n), 2))
return pq, q
def generate_public_key(private_key, modulus=P):
x_i, z_i, xz_i = private_key
x = modular_inverse(x_i, modulus)
z = modular_inverse(z_i, modulus)
a = modular_subtraction(z, x, modulus) # z - x
public_key = ((a * x) + (x * 2)) % modulus
return public_key
def generate_public_key(private_key, c_size=32, p=P):
ai, bi = private_key
a = modular_inverse(ai, p)
b = modular_inverse(bi, p)
c = random_integer(c_size)
public_key = ((a * b) % p, (a * c) % p)
return public_key
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 generate_public_key(private_key):
""" usage: generate_public_key(private_key) => public_key
Returns the integer(s) that constitute a public key. """
a_i, b_i, ab_i, p = private_key
a = modular_inverse(a_i, p)
b = modular_inverse(b_i, p)
return a, b
def generate_public_key(private_key):
""" usage: generate_public_key(private_key) => public_key
Returns the integer(s) that constitute a public key. """
a_i, b_i, ab_i, p = private_key
a = modular_inverse(a_i, p)
b = modular_inverse(b_i, p)
return a, b
def generate_secret_key(parameters=PARAMETERS, q=Q):
inverse_size = parameters["inverse_size"]
inverse_shift = parameters["inverse_shift"]
ai = (random_integer(inverse_size) << inverse_shift) + 1
bi = (random_integer(inverse_size) << inverse_shift) + 1
d = (ai * bi) % q
a = modular_inverse(ai, q)
b = modular_inverse(bi, q)
return a, b, d
def generate_secret_key(parameters=PARAMETERS, q=Q):
inverse_size = parameters["inverse_size"]
inverse_shift = parameters["inverse_shift"]
ai = (random_integer(inverse_size) << inverse_shift) + 1
bi = (random_integer(inverse_size) << inverse_shift) + 1
d = (ai * bi) % q
a = modular_inverse(ai, q)
b = modular_inverse(bi, q)
return Key_Tuple((a, b), d)
def generate_public_key(private_key, security_level=SECURITY_LEVEL, public_key_size=PUBLIC_KEY_SIZE):
ai, modulus = private_key
a = modular_inverse(ai, modulus)
public_key = []
while len(public_key) < public_key_size:
try:
public_key.append(a + modular_inverse(ai, modulus * random_integer(security_level)))
except ValueError:
continue
return public_key
def generate_private_key(r_size=R_SIZE, inverse=INVERSE, q=Q):
while True:
r = random_integer(r_size)
try:
modular_inverse(inverse, q + r)
except ValueError:
continue
else:
break
return r
def generate_public_key(private_key, security_level=SECURITY_LEVEL, public_key_size=PUBLIC_KEY_SIZE):
ai, modulus = private_key
public_key = []
while len(public_key) < public_key_size:
try:
public_key.append(modular_inverse(ai, modulus * random_integer(security_level)) +
modular_inverse(ai, modulus * random_integer(security_level)))
except ValueError:
continue
return public_key
def generate_private_key(r_size=R_SIZE, inverse=INVERSE, q=Q):
while True:
r = random_integer(r_size)
try:
modular_inverse(inverse, q + r)
except ValueError:
continue
else:
break
return r
def generate_private_key(security_level=SECURITY_LEVEL):
while True:
short_inverse = random_integer((security_level * 2) + 3)
modulus = random_integer((security_level * 3) + 5)
try:
modular_inverse(short_inverse, modulus)
except ValueError:
continue
else:
break
return short_inverse, modulus
def generate_private_key(inverse_size=INVERSE_SIZE, r_size=R_SIZE, q=Q, shift=SHIFT):
while True:
inverse = random_integer(inverse_size) << shift
r = random_integer(r_size)
try:
modular_inverse(inverse, q + r)
except ValueError:
continue
else:
break
return inverse, r
def generate_private_key(inverse_size=INVERSE_SIZE, inverse_shift=INVERSE_SHIFT, q_size=Q_SIZE):
while True:
inverse = random_integer(inverse_size) << inverse_shift
q = random_integer(q_size)
try:
modular_inverse(inverse, q)
except ValueError:
continue
else:
break
return inverse, q
def generate_private_key(inverse_size=INVERSE_SIZE, p_size=P_SIZE):
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 generate_private_key(security_level=SECURITY_LEVEL):
while True:
ai = random_integer((security_level * 2) + 3)
modulus = random_integer((security_level * 5) + 5)
try:
modular_inverse(ai, modulus)
except ValueError:
continue
else:
break
return ai, modulus
def generate_private_key(inverse_size=INVERSE_SIZE, q_size=Q_SIZE):
while True:
ai = random_integer(inverse_size)
q = random_integer(q_size + 4)
try:
modular_inverse(ai, q)
except ValueError:
continue
else:
break
return ai, q
def generate_private_key(security_level=SECURITY_LEVEL):
while True:
modulus = random_integer(security_level + 1)
try:
a = modular_inverse(2, modulus)
b = modular_inverse(3, modulus)
except ValueError:
continue
else:
break
return modulus
def generate_private_key(security_level=SECURITY_LEVEL):
while True:
modulus = big_prime(security_level + 3)
ai = random_integer(security_level)
try:
modular_inverse(ai, modulus)
except ValueError:
continue
else:
break
return ai, ((ai * ai) + (ai * ai)) % modulus, modulus
def generate_private_key(inverse_size=INVERSE_SIZE, q_size=Q_SIZE, shift=SHIFT):
while True:
ai = random_integer(inverse_size) << shift
q = random_integer(q_size)
try:
modular_inverse(ai, q)
except ValueError:
continue
else:
break
return ai, q
def generate_private_key(inverse_size=INVERSE_SIZE, p_size=P_SIZE):
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 generate_private_key(security_level=SECURITY_LEVEL):
while True:
modulus = big_prime(security_level + 3)
ai = random_integer(security_level)
try:
modular_inverse(ai, modulus)
except ValueError:
continue
else:
break
return ai, ((ai * ai) + (ai * ai)) % modulus, modulus
def generate_private_key(security_level=SECURITY_LEVEL):
modulus = random_integer((security_level * 2) + 5)
ai = random_integer(security_level + 2)
while True:
try:
modular_inverse(ai, modulus)
except ValueError:
modulus += 1
continue
else:
break
return ai, modulus
def generate_private_key(inverse_size=INVERSE_SIZE, k_size=K_SIZE, q=Q):
shift = inverse_size * 8
while True:
ai = random_integer(inverse_size) << shift
q_k = q + random_integer(k_size)
try:
modular_inverse(ai, q_k)
except ValueError:
continue
else:
break
return ai, q_k
def generate_key(security_level=SECURITY_LEVEL, p=P):
while True:
k1 = random_integer(32)
k2 = random_integer(32)
try:
k1i = modular_inverse(k1, p - 1)
k2i = modular_inverse(k2, p - 1)
except ValueError:
continue
else:
break
return (k1, k2), (k1i, k2i)
def generate_private_key(security_level=SECURITY_LEVEL):
modulus_size = (security_level * 3) + 3
while True:
ai = random_integer(modulus_size - 3)
modulus = random_integer(modulus_size)
try:
modular_inverse(ai, modulus)
except ValueError():
continue
else:
break
return ai, modulus
def generate_private_key(inverse_size=INVERSE_SIZE, q_size=Q_SIZE, modulus=MODULUS):
while True:
ai = random_integer(inverse_size)
q = random_integer(q_size)
try:
a = modular_inverse(ai, modulus)
qi = modular_inverse(q, modulus)
except ValueError:
continue
else:
break
return ai, qi
def generate_public_parameters(security_level=SECURITY_LEVEL):
A = random_integer(security_level + 2)
N = random_integer(security_level)
while True:
try:
bad_parameters = modular_inverse(A % N, N)
bad_parameters = modular_inverse(A - N, N)
except ValueError:
break # good parameters found
else:
A = random_integer(security_level + 2)
N = random_integer(security_level)
return A, N
def generate_private_key(inverse_size=INVERSE_SIZE, r_size=R_SIZE, q=Q, shift=SHIFT):
""" usage: generate_private_key(inverse_size=INVERSE_SIZE, q_size=Q_SIZE) => private_key
Returns the integer(s) that constitute a private key. """
while True:
inverse = (random_integer(inverse_size) << shift) | 1
try:
modular_inverse(inverse, q)
except ValueError:
continue
else:
break
return inverse
def generate_private_key(security_level=SECURITY_LEVEL):
p_size = (security_level * 2) + 1
a_size = security_level + 1
while True:
p = random_integer(p_size)
a_i = random_integer(a_size) # adds 1 extra bit
try:
modular_inverse(a_i, p)
except ValueError:
continue
else:
break
return a_i, p
def generate_private_key(security_level=SECURITY_LEVEL,
padding1=3,
padding2=6):
while True:
short_inverse = random_integer((security_level * 2) + padding1)
modulus = random_integer((security_level * 3) + padding2)
try:
modular_inverse(short_inverse, modulus)
except ValueError:
continue
else:
break
return short_inverse, modulus
def generate_public_parameters(security_level=SECURITY_LEVEL):
A = random_integer(security_level + 2)
N = random_integer(security_level)
while True:
try:
bad_parameters = modular_inverse(A % N, N)
bad_parameters = modular_inverse(A - N, N)
except ValueError:
break # good parameters found
else:
A = random_integer(security_level + 2)
N = random_integer(security_level)
return A, N
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 generate_private_key(parameters=PARAMETERS):
inverse_size = parameters["inverse_size"]
q_size = parameters["q_size"]
while True:
inverse = random_integer(inverse_size)
q = random_integer(q_size)
try:
modular_inverse(inverse, q)
except ValueError:
continue
else:
if gcd(inverse, q) == 1:
break
return inverse, q
def generate_private_key(inverse_size=INVERSE_SIZE, k_size=K_SIZE, q=Q, shift=SHIFT):
""" usage: generate_private_key(inverse_size=INVERSE_SIZE, q_size=Q_SIZE) => private_key
Returns the integer(s) that constitute a private key. """
while True:
inverse = random_integer(inverse_size) << shift
k = random_integer(k_size)
try:
modular_inverse(inverse, q + k)
except ValueError:
continue
else:
break
return inverse, q + k
def generate_private_key(inverse_size=INVERSE_SIZE, modulus=MODULUS):
""" usage: generate_private_key(inverse_size=INVERSE_SIZE, modulus=MODULUS) => private_key
Returns the integer(s) that constitute a private key.
It is recommended to use generate_keypair instead of generate_private_key for normal use cases. """
while True:
ai = random_integer(inverse_size)
try:
modular_inverse(ai, modulus)
except ValueError:
continue
else:
break
return ai
def generate_key(parameters=PARAMETERS):
k_size = parameters["k_size"]
p = parameters['p']
while True:
k1 = random_integer(k_size)
k2 = random_integer(k_size)
try:
k1i = modular_inverse(k1, p - 1)
k2i = modular_inverse(k2, p - 1)
except ValueError:
continue
else:
break
return (k1, k2)
def generate_key(parameters=PARAMETERS):
k_size = parameters["k_size"]
p = parameters['p']
while True:
k1 = random_integer(k_size)
k2 = random_integer(k_size)
try:
k1i = modular_inverse(k1, p - 1)
k2i = modular_inverse(k2, p - 1)
except ValueError:
continue
else:
break
return (k1, k2)
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 generate_private_key(parameters=PARAMETERS):
inverse_size = parameters["inverse_size"]
q_size = parameters["q_size"]
while True:
inverse = random_integer(inverse_size)
q = random_integer(q_size)
try:
modular_inverse(inverse, q)
except ValueError:
continue
else:
if gcd(inverse, q) == 1:
break
return inverse, q
def generate_private_key(inverse_size=INVERSE_SIZE,
r_size=R_SIZE,
q=Q,
shift=SHIFT):
while True:
inverse = random_integer(inverse_size) << shift
r = random_integer(r_size)
try:
modular_inverse(inverse, q + r)
except ValueError:
continue
else:
break
return inverse, r
def sign(ciphertext, private_key, message_size=4):
primes, key, modulus = private_key
ciphertext = (modular_inverse(key, modulus) * ciphertext) % modulus
plaintext_bits = ['0'] * (message_size * 8)
for count in range(2):
for index, prime in enumerate(reversed(primes)):
if ciphertext % prime == 0:
print "Setting bit: ", index, prime
plaintext_bits[index] = '1'
ciphertext = (ciphertext * modular_inverse(prime, modulus)) % modulus
else:
print "Prime not in ciphertext", prime
return int(''.join(plaintext_bits), 2)
def generate_public_key(private_key, q=Q, a_shift=A_SHIFT):
""" usage: generate_public_key(private_key, r_size=R_SIZE) => public_key
Returns the integer(s) that constitute a public key. """
ai = private_key
a = modular_inverse(ai, q) >> a_shift
return a
def generate_public_key(private_key, x_size=X_SIZE, z_size=Z_SIZE, z_shift=Z_SHIFT,
public_key_size=PUBLIC_KEY_SIZE, q=Q):
ai, bi, d = private_key
a = modular_inverse(ai, q)
b = modular_inverse(bi, q)
ab = (a * b) % q
public_key = []
payload_bits = 1 << z_shift
for element_number in range(public_key_size):
x = random_integer(x_size)
y = random_integer(x_size)
z = payload_bits | random_integer(z_size)
element = ((a * x) + (b * y) + (ab * z) + random_integer(SECURITY_LEVEL - 1)) % q
public_key.append(element)
return public_key
def generate_public_key(private_key, r_size=R_SIZE, x_size=X_SIZE):
ai, q = private_key
r = random_integer(r_size)
x = random_integer(x_size)
a = modular_inverse(ai, q)
# print log(ai, 2), log(q, 2), log(r, 2), log(x, 2)
return a, (q * r) + x
def generate_public_key(private_key,
security_level=SECURITY_LEVEL,
public_key_size=PUBLIC_KEY_SIZE):
short_inverse, modulus = private_key
a = modular_inverse(short_inverse, modulus)
return [(a * (random_integer(security_level))) % modulus
for count in range(public_key_size)]
def sign(ciphertext, private_key, message_size=4):
primes, key, modulus = private_key
ciphertext = (modular_inverse(key, modulus) * ciphertext) % modulus
plaintext_bits = ['0'] * (message_size * 8)
for count in range(2):
for index, prime in enumerate(reversed(primes)):
if ciphertext % prime == 0:
print "Setting bit: ", index, prime
plaintext_bits[index] = '1'
ciphertext = (ciphertext *
modular_inverse(prime, modulus)) % modulus
else:
print "Prime not in ciphertext", prime
return int(''.join(plaintext_bits), 2)
def generate_public_key(private_key, r_size=R_SIZE, x_size=X_SIZE):
ai, q = private_key
r = random_integer(r_size)
x = random_integer(x_size)
a = modular_inverse(ai, q)
# print log(ai, 2), log(q, 2), log(r, 2), log(x, 2)
return a, (q * r) + x
def generate_public_key(private_key, q=Q, a_shift=A_SHIFT):
""" usage: generate_public_key(private_key, q=Q, k_size=K_SIZE) => public_key
Returns the integer that constitutes a public key. """
ai, q_k = private_key
a = modular_inverse(ai, q_k)
return (a >> a_shift) << a_shift
