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