def generate_private_key(security_level=SECURITY_LEVEL, s_size=S_SIZE, a=A, modulus=MODULUS):
r = random_integer(64)
target = random_integer(31)
t = modular_subtraction(target, r, modulus)
assert (t + r) % modulus == target
s = random_integer(s_size) >> 4
r += t % s
ae = t / s
e = modular_subtraction(ae, a, modulus)
print log(a, 2), log(s, 2), log(e, 2), log(r, 2)
assert e > 0
assert ((s * (a + e)) + r) % modulus == target, (((s * (a + e)) + r) % modulus, target)
#if e < 0 or modulus - (s * (a + e)
return s, e, r
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, 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 decrypt(ciphertext, private_key, p=N, _hash=hash_function):
private_key, pubk_i = private_key
e = recover_key(ciphertext, private_key, p)
pubk_ciphertext = modular_subtraction(ciphertext, e, p)
_ciphertext = (pubk_ciphertext * pubk_i) % p
key = _hash(e)
return _ciphertext ^ key
def decrypt(ciphertext, private_key, p=N, _hash=hash_function):
private_key, pubk_i = private_key
e = recover_key(ciphertext, private_key, p)
pubk_ciphertext = modular_subtraction(ciphertext, e, p)
_ciphertext = (pubk_ciphertext * pubk_i) % p
key = _hash(e)
return _ciphertext ^ key
def generate_parameters(a_size=A_SIZE, b_size=B_SIZE,
x_size=X_SIZE, p_size=P_SIZE):
a = random_integer(a_size)
b = random_integer(b_size)
x = random_integer(x_size)
p = big_prime(p_size)
z = modular_inverse(modular_subtraction(1, a, p), p)
return a, b, x, p, z
def generate_parameters(a_size=A_SIZE, b_size=B_SIZE,
x_size=X_SIZE, p_size=P_SIZE):
a = random_integer(a_size)
b = random_integer(b_size)
x = random_integer(x_size)
p = big_prime(p_size)
z = modular_inverse(modular_subtraction(1, a, p), p)
return a, b, x, p, z
def generate_private_key(security_level=SECURITY_LEVEL,
s_size=S_SIZE,
a=A,
modulus=MODULUS):
r = random_integer(64)
target = random_integer(31)
t = modular_subtraction(target, r, modulus)
assert (t + r) % modulus == target
s = random_integer(s_size) >> 4
r += t % s
ae = t / s
e = modular_subtraction(ae, a, modulus)
print log(a, 2), log(s, 2), log(e, 2), log(r, 2)
assert e > 0
assert ((s * (a + e)) + r) % modulus == target, (((s * (a + e)) + r) %
modulus, target)
#if e < 0 or modulus - (s * (a + e)
return s, e, r
def convergent_decrypt(ciphertext, key, public_key, n=N,
_hash=hash_function, decrypt=symmetric_decrypt):
""" usage: convergent_decrypt(ciphertext, key, public_key, n=N,
_hash=hash_function, decrypt=symmetric_decrypt) => message or None
Decrypts ciphertext using key; If the integrity is validated, then return the message; If not, then return None. """
public_key_ciphertext = modular_subtraction(ciphertext, key, n)
ciphertext = (modular_inverse(public_key, n) * public_key_ciphertext) % n
return _decrypt(key, ciphertext, decrypt, _hash)
def encrypt(m, public_key, security_level=SECURITY_LEVEL, _modulus=(2 ** (SECURITY_LEVEL * 8))):
ciphertext = 0
value = 0
for element in public_key[:-1]:
r = random_integer(security_level)
ciphertext += element * r
value += r
final_r = modular_subtraction(m, value, _modulus)
ciphertext += public_key[-1] * final_r
return ciphertext
def generate_private_key(security_level=SECURITY_LEVEL, a=A, modulus=MODULUS):
e = random_integer(security_level - 1)
public_key = random_integer(security_level)
while e < public_key:
e = random_integer(security_level)
public_key = random_integer(security_level)
_as = modular_subtraction(public_key, e, modulus)
s = _as / a
e += _as % a
assert ((a * s) + e) % modulus == public_key
return s, e
def generate_private_key(security_level=SECURITY_LEVEL, a=A, modulus=MODULUS):
e = random_integer(security_level - 1)
public_key = random_integer(security_level)
while e < public_key:
e = random_integer(security_level)
public_key = random_integer(security_level)
_as = modular_subtraction(public_key, e, modulus)
s = _as / a
e += _as % a
assert ((a * s) + e) % modulus == public_key
return s, e
def encrypt(m, secret_key, security_level=SECURITY_LEVEL):
modulus, encryption_key, decryption_key = secret_key
ciphertext = 0
value = 0
for element in encryption_key[:-1]:
r = random_integer(security_level)
ciphertext += element * r
value += r
final_r = modular_subtraction(m, value, modulus)
ciphertext += encryption_key[-1] * final_r
return ciphertext % (modulus * random_integer(security_level))
def encrypt(m,
public_key,
security_level=SECURITY_LEVEL,
_modulus=(2**(SECURITY_LEVEL * 8))):
ciphertext = 0
value = 0
for element in public_key[:-1]:
r = random_integer(security_level)
ciphertext += element * r
value += r
final_r = modular_subtraction(m, value, _modulus)
ciphertext += public_key[-1] * final_r
return ciphertext
def convergent_decrypt(ciphertext,
key,
public_key,
n=N,
_hash=hash_function,
decrypt=symmetric_decrypt):
""" usage: convergent_decrypt(ciphertext, key, public_key, n=N,
_hash=hash_function, decrypt=symmetric_decrypt) => message or None
Decrypts ciphertext using key; If the integrity is validated, then return the message; If not, then return None. """
public_key_ciphertext = modular_subtraction(ciphertext, key, n)
ciphertext = (modular_inverse(public_key, n) * public_key_ciphertext) % n
return _decrypt(key, ciphertext, decrypt, _hash)
def backdoor_decrypt(ciphertext, private_key, n=N,
_hash=hash_function, decrypt=symmetric_decrypt):
""" usage: backdoor_decrypt(ciphertext, private_key, n=N,
_hash=hash_function, decrypt=symmetric_decrypt) => message
Decrypts a ciphertext using the private key; If the integrity is validated, then return the message; If not, then return None.
This method can be used on any ciphertext that was created with the corresponding public key. """
p, pi, ri = private_key
pikey_cr = (pi * ciphertext) % n
cr = pikey_cr % pi
pikey = modular_subtraction(pikey_cr, cr, n)
ciphertext = (cr * ri) % n
key = (pikey * p) % n
return _decrypt(key, ciphertext, decrypt, _hash)
def encrypt(m, public_key, r_size=R_SIZE, q=Q, s_mask=secretkey.S_MASK + 1):
ciphertext = 0
running_total = 0
for encryption_of_1 in public_key[:-1]:
r = random_integer(r_size)
ciphertext += encryption_of_1 * r
running_total += r
encryption_of_1 = public_key[-1]
correction_factor = modular_subtraction(m, running_total, s_mask) # ensures r + r + r + ... == m # + 1 because it's a mask and not the modulus
ciphertext += encryption_of_1 * correction_factor
ciphertext += random_integer(160)
ciphertext %= q
#running_total += correction_factor
#running_total &= s_mask
#assert running_total == m, (running_total, m)
return ciphertext
def backdoor_decrypt(ciphertext,
private_key,
n=N,
_hash=hash_function,
decrypt=symmetric_decrypt):
""" usage: backdoor_decrypt(ciphertext, private_key, n=N,
_hash=hash_function, decrypt=symmetric_decrypt) => message
Decrypts a ciphertext using the private key; If the integrity is validated, then return the message; If not, then return None.
This method can be used on any ciphertext that was created with the corresponding public key. """
p, pi, ri = private_key
pikey_cr = (pi * ciphertext) % n
cr = pikey_cr % pi
pikey = modular_subtraction(pikey_cr, cr, n)
ciphertext = (cr * ri) % n
key = (pikey * p) % n
return _decrypt(key, ciphertext, decrypt, _hash)
def encrypt(m, public_key, r_size=R_SIZE, q=Q, s_mask=secretkey.S_MASK + 1):
ciphertext = 0
running_total = 0
for encryption_of_1 in public_key[:-1]:
r = random_integer(r_size)
ciphertext += encryption_of_1 * r
running_total += r
encryption_of_1 = public_key[-1]
correction_factor = modular_subtraction(
m, running_total, s_mask
) # ensures r + r + r + ... == m # + 1 because it's a mask and not the modulus
ciphertext += encryption_of_1 * correction_factor
ciphertext += random_integer(160)
ciphertext %= q
#running_total += correction_factor
#running_total &= s_mask
#assert running_total == m, (running_total, m)
return ciphertext
def _sum_geometric_series(a, p=P, z=Z):
return modular_subtraction(z, z * a, p)
def invert_arithmetic_choice(d, b, c, modulus=256):
return modular_subtraction(d, c, modulus) * (modular_inverse(a, modulus) * modular_subtraction(b, c, modulus)) % modulus, modulus)
def generate_key(size=SIZE, p=P):
a = random_integer(size)
b = random_integer(size)
d = modular_inverse(modular_subtraction(b ** 2, a ** 2, p), p)
return a, b, d
def invert_mix_columns(a, b, c, d, modulus=MODULUS):
d ^= a
b ^= c
c = modular_subtraction(c, d, modulus)
a = modular_subtraction(a, b, modulus)
return a, b, c, d
def sign(m, x, p=P):
r, priv_info = generate_keypair()
e = hash(r + m)
k = priv_info[0]
s = modular_subtraction(k, (x[0] + e), p)
return s, e
def _sum_geometric_series(a, p=P, z=Z):
return modular_subtraction(z, z * a, p)
def _sum_geometric_series(point_count, a=A, p=P, z=Z):
t = modular_subtraction(1, a, p)
return (t * z) % p
def decrypt(c, secret_key, modulus=DEFAULT_MODULUS):
k1, k2, k3 = secret_key
_e = c #% k1
return (modular_subtraction(_e, k3, modulus) * modular_inverse(k2, modulus)) % modulus