def test_encrypt_decrypt_backdoor():
public, private = generate_keypair()
message = bytearray(random_bytes(32))
ciphertext, key = convergent_encrypt(message, public)
plaintext = convergent_decrypt(ciphertext, key, public)
_plaintext = backdoor_decrypt(ciphertext, private)
assert plaintext == message
assert _plaintext == plaintext, (_plaintext, plaintext)
print "backdoorconvergent encryption unit test complete"
def test_encrypt_decrypt_backdoor():
public, private = generate_keypair()
message = bytearray(random_bytes(32))
ciphertext, key = convergent_encrypt(message, public)
plaintext = convergent_decrypt(ciphertext, key, public)
_plaintext = backdoor_decrypt(ciphertext, private)
assert plaintext == message
assert _plaintext == plaintext, (_plaintext, plaintext)
print "backdoorconvergent encryption unit test complete"
def test_encoder_decoder():
bits = random_bits(16)
keys = [((item & 15) | 1) for item in bytearray(random_bytes(16))]
import majorityencoding
import choiceencoding
print ''.join((str(item) for item in bits))
for encode_bit, decode_bit in [(item.encode_bit, item.decode_bit) for item in (majorityencoding, choiceencoding)]:
encoded_bits = encoder(bits, encode_bit)
decoded_bits = decoder(encoded_bits, decode_bit, 3)
assert decoded_bits == bits
bits = [0] * 43
encoded_bits = encoder(bits, choiceencoding.encode_bit)
assert len(encoded_bits) == 128, len(encoded_bits)
print encoded_bits
def test_encoder_decoder():
bits = random_bits(16)
keys = [((item & 15) | 1) for item in bytearray(random_bytes(16))]
import majorityencoding
import choiceencoding
print ''.join((str(item) for item in bits))
for encode_bit, decode_bit in [(item.encode_bit, item.decode_bit)
for item in (majorityencoding,
choiceencoding)]:
encoded_bits = encoder(bits, encode_bit)
decoded_bits = decoder(encoded_bits, decode_bit, 3)
assert decoded_bits == bits
bits = [0] * 43
encoded_bits = encoder(bits, choiceencoding.encode_bit)
assert len(encoded_bits) == 128, len(encoded_bits)
print encoded_bits
def test_sign_verify(algorithm_name, generate_keypair, sign, verify,
iterations=1024, message_size=32):
print("Beginning {} unit test...".format(algorithm_name))
print("Generating keypair...")
public_key, private_key = generate_keypair()
print("...done")
message = random_integer(message_size)
random_generator = random_integer
try:
sign(message, private_key)
except TypeError:
message = random_bytes(message_size)
try:
sign(message, private_key)
except TypeError:
raise TypeError("Unable to determine type of message to be signed")
else:
random_generator = random_bytes
print("Validating correctness...")
for count in range(iterations):
message = random_generator(message_size)
signature = sign(message, private_key)
if not verify(signature, message, public_key):
raise UnitTestFailure("Unit test failed after {} successful signature verifications".format(count))
print("...done")
test_sign_verify_time(iterations, sign, verify, public_key, private_key, message_size, random_generator)
public_sizes = determine_key_size(public_key)
private_sizes = determine_key_size(private_key)
print("Public key size : {}".format(sum(public_sizes)))
print("Private key size: {}".format(sum(private_sizes)))
print("Signature size : {}".format(sum(determine_key_size(signature))))
print("(sizes are in bits)")
print("{} unit test passed".format(algorithm_name))
def generate_private_key(prime_count=80, key_size=16, modulus_size=33):
primes = PRIMES[:]
shuffle(primes, bytearray(random_bytes(len(primes))))
key = random_integer(key_size)
modulus = big_prime(modulus_size)
return primes[:prime_count], key, modulus
def generate_private_key(security_level=SECURITY_LEVEL):
return bytearray(random_bytes(security_level))
def generate_key(length=STATE_LENGTH, mask=MASK64):
key_m = [(item & mask) | 1 for item in bytearray(random_bytes(length))]
key_e = [item & mask for item in bytearray(random_bytes(length))]
return key_m + key_e
def generate_private_key(prime_count=80, key_size=16, modulus_size=33):
primes = PRIMES[:]
shuffle(primes, bytearray(random_bytes(len(primes))))
key = random_integer(key_size)
modulus = big_prime(modulus_size)
return primes[:prime_count], key, modulus
from crypto.utilities import shuffle, random_integer, random_bytes
SIZE = 32
ARRAY = range(SIZE)
SHUFFLE_KEY = bytearray(random_bytes(SIZE))
def generate_private_key(size=32):
return random_integer(size)
def generate_public_key(shuffle_count, _array=ARRAY, _key=SHUFFLE_KEY):
state = _array[:]
for count in range(shuffle_count):
shuffle(state, _key)
return state
def generate_keypair(size=32):
shuffle_count = generate_private_key(size)
public_key = generate_public_key(shuffle_count)
return public_key, shuffle_count
def key_agreement(public_key, private_key, _key=SHUFFLE_KEY):
state = public_key[:]
for count in range(private_key):
shuffle(state, _key)
return state
def generate_private_key(security_level=SECURITY_LEVEL):
return bytearray(random_bytes(security_level))