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_public_key(private_key, q=Q, a_shift=A_SHIFT):
""" usage: generate_public_key(private_key, q=Q, a_shift=A_SHIFT) => 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
def generate_backdoor_public_key(private_key, q_size=Q_SIZE):
""" usage: generate_backdoor_public_key(private_key, q_size=Q_SIZE) => public_key
Returns the integer(s) that constitute a public key. """
ai, modulus = private_key
q = random_integer(q_size)
a = modular_inverse(ai, modulus)
return a, modulus + q
def generate_public_key(private_key, r_size=32, p=P, point_count=POINT_COUNT):
""" usage: generate_public_key(private_key, r_size=32, p=P) => public_key
Returns 1 integer, suitable for use as a public key. """
random_number = modular_inverse(private_key, p) # selects a random integer with an appropriate sized inverse by selecting the inverse first
public_key = []
for count in range(point_count):
point = (random_number * random_integer(r_size)) % p
public_key.append(point)
return public_key
def generate_secret_key(parameters=PARAMETERS):
q = parameters["q"]
short_inverses = [(random_integer(parameters["inverse_size"]) <<
parameters["inverse_shift"]) + 1 for count in range(4)]
decryption_scalar = reduce(lambda a, b: (a * b) % q,
short_inverses) # a * b * c * d mod q
a, b, c, d = [modular_inverse(element, q) for element in short_inverses]
encryption_vector = ((((b * c) % q) * d) % q, (((c * d) % q) * a) % q,
(((d * a) % q) * b) % q, (((a * b) % q) * c) % q)
return encryption_vector, decryption_scalar
def generate_public_key(private_key, r_size=32, p=P, point_count=POINT_COUNT):
""" usage: generate_public_key(private_key, r_size=32, p=P) => public_key
Returns 1 integer, suitable for use as a public key. """
random_number = modular_inverse(
private_key, p
) # selects a random integer with an appropriate sized inverse by selecting the inverse first
public_key = []
for count in range(point_count):
point = (random_number * (random_integer(r_size) >> 1)) % p
public_key.append(point)
return public_key
def generate_private_key(inverse_size=INVERSE_SIZE,
k_size=K_SIZE,
q=Q,
shift=SHIFT,
seed=TEST_VECTOR_SEED,
nonce=TEST_VECTOR_NONCE):
""" usage: generate_private_key(inverse_size=INVERSE_SIZE, k_size=K_SIZE, q=Q, shift=SHIFT,
seed=TEST_VECTOR_SEED, nonce=TEST_VECTOR_NONCE) => private_key
Returns the integer(s) that constitute a private key. """
while True:
inverse = random_integer(inverse_size, seed, nonce) << shift
nonce = increment_nonce(nonce)
k = random_integer(k_size, seed, nonce)
nonce = increment_nonce(nonce)
try:
modular_inverse(inverse, q + k)
except ValueError:
continue
else:
break
return inverse, q + k
def generate_keypair(p=P):
public_key, private_key = epqcrypto.asymmetric.keyexchange.generate_keypair(
)
ai, a, b, c = private_key
private_key = (ai, a, modular_inverse(b, p), c)
return public_key, private_key
def generate_keypair(p=P):
public_key, private_key = epqcrypto.asymmetric.keyexchange.generate_keypair()
ai, a, b, c = private_key
private_key = (ai, a, modular_inverse(b, p), c)
return public_key, private_key
