def test_authenticated_stream_cipher_metrics():
from crypto.analysis.metrics import test_stream_cipher, PERFORMANCE_TEST
print "Testing metrics of encryption algorithm"
def test_algorithm(data, key, nonce):
data = bytearray(data)
authenticated_stream_cipher(data, key, nonce, post_processing_steps=0)
return bytes(data)
test_stream_cipher(test_algorithm, "\x00" * 16, "\x00" * 16, performance_test_sizes=(1500, 4096), **PERFORMANCE_TEST)
def test_encrypt_metrics():
from crypto.analysis.metrics import test_stream_cipher, PERFORMANCE_TEST
print "Testing metrics of encryption algorithm"
test_stream_cipher(encrypt,
"\x00" * 16,
"\x00" * 16,
performance_test_sizes=(1500, 4096),
**PERFORMANCE_TEST)
def test_authenticated_stream_cipher_metrics():
from crypto.analysis.metrics import test_stream_cipher, PERFORMANCE_TEST
print "Testing metrics of encryption algorithm"
def test_algorithm(data, key, nonce):
data = bytearray(data)
authenticated_stream_cipher(data, key, nonce, post_processing_steps=0)
return bytes(data)
test_stream_cipher(test_algorithm,
"\x00" * 16,
"\x00" * 16,
performance_test_sizes=(1500, 4096),
**PERFORMANCE_TEST)
def test_metrics():
from crypto.analysis.metrics import test_stream_cipher
def keygen(byte):
return (0, 0, 0, ord(byte)), (0, 0, 0, 0)
def seedgen(padding, byte):
output = bytearray(16)
try:
output[-1] = byte
except (ValueError, TypeError):
output[-1] = byte[0]
return bytes_to_words(output, 4)
seed = [0 for count in range(4)]
test_stream_cipher(stream_cipher, ([0, 0, 0, 0], [0, 0, 0, 0]), seed, key_generation_function=keygen, seed_generation_function=seedgen)
def test_metrics():
from crypto.analysis.metrics import test_stream_cipher
def keygen(byte):
return (0, 0, 0, ord(byte)), (0, 0, 0, 0)
def seedgen(padding, byte):
output = bytearray(32)
try:
output[-1] = byte
except (ValueError, TypeError):
output[-1] = byte[0]
return bytes_to_words(output, 4)
seed = [0 for count in range(4)]
test_stream_cipher(stream_cipher, generate_keys(), seed, key_generation_function=keygen, seed_generation_function=seedgen,
randomness_test=False, avalanche_test=False, bias_test=False)
def test_metrics():
from crypto.analysis.metrics import test_stream_cipher
def keygen(byte):
key = [0] * 10
key[-1] = ord(byte)
return key, [0] * 20
def seedgen(padding, byte):
output = bytearray(20)
try:
output[-1] = byte
except (ValueError, TypeError):
output[-1] = byte[0]
return output
seed = [0] * 20
test_stream_cipher(stream_cipher, generate_keys(), seed, key_generation_function=keygen, seed_generation_function=seedgen)#,
def test_metrics():
from crypto.analysis.metrics import test_stream_cipher
def keygen(byte):
key = [0] * 10
key[-1] = ord(byte)
return key, [0] * 20
def seedgen(padding, byte):
output = bytearray(20)
try:
output[-1] = byte
except (ValueError, TypeError):
output[-1] = byte[0]
return output
seed = [0] * 20
test_stream_cipher(stream_cipher,
generate_keys(),
seed,
key_generation_function=keygen,
seed_generation_function=seedgen) #,
def test_metrics():
from crypto.analysis.metrics import test_stream_cipher
def keygen(byte):
return (0, 0, 0, ord(byte)), (0, 0, 0, 0)
def seedgen(padding, byte):
output = bytearray(32)
try:
output[-1] = byte
except (ValueError, TypeError):
output[-1] = byte[0]
return bytes_to_words(output, 4)
seed = [0 for count in range(4)]
test_stream_cipher(stream_cipher,
generate_keys(),
seed,
key_generation_function=keygen,
seed_generation_function=seedgen,
randomness_test=False,
avalanche_test=False,
bias_test=False)
def test_metrics():
from crypto.analysis.metrics import test_stream_cipher
def keygen(byte):
key = [0] * 10
key[-1] = ord(byte)
return key, [0] * 20
def seedgen(padding, byte):
output = bytearray(20)
try:
output[-1] = byte
except (ValueError, TypeError):
output[-1] = byte[0]
return output
seed = [0] * 20
test_stream_cipher(stream_cipher,
generate_keys(),
seed,
key_generation_function=keygen,
seed_generation_function=seedgen) #,
#randomness_test=False, avalanche_test=False, bias_test=False)
if __name__ == "__main__":
test_stream_cipher()
test_metrics()
def test_crypt_stream_metrics():
from crypto.analysis.metrics import test_stream_cipher
test_stream_cipher(crypt_stream, bytearray(32), bytearray(32))
def test_stream_cipher():
prng_key, seed_key = range(10), range(20)
seed = seed_key
message = bytearray("Awesome!")
print stream_cipher(message, (prng_key, seed_key), seed)
print stream_cipher(message, (prng_key, seed_key), seed)
def test_metrics():
from crypto.analysis.metrics import test_stream_cipher
def keygen(byte):
key = [0] * 10
key[-1] = ord(byte)
return key, [0] * 20
def seedgen(padding, byte):
output = bytearray(20)
try:
output[-1] = byte
except (ValueError, TypeError):
output[-1] = byte[0]
return output
seed = [0] * 20
test_stream_cipher(stream_cipher, generate_keys(), seed, key_generation_function=keygen, seed_generation_function=seedgen)#,
#randomness_test=False, avalanche_test=False, bias_test=False)
if __name__ == "__main__":
test_stream_cipher()
test_metrics()
def test_metrics():
from crypto.analysis.metrics import test_stream_cipher
test_stream_cipher(stream_cipher, "\x00" * 16, "\x00" * 16)
def _permutation(seed, key, index, index2, wordsize):
left, right = seed[index], seed[index2]
left ^= (index + 1) # add constant
right ^= (index2 + 1)
#
left ^= (key[index % KEY_SIZE]) # add key
right ^= (key[index2 % KEY_SIZE])
# a0 a1 a2 a3 a4 a5 a6 a7
# b0 b1 b2 b3 b4 b5 b6 b7
# a0b0 a1b1 a2b2 a3b3 a4b4 a5b5 a6b6 a7b7 a ^ b
# b0 b1 b2 b3 b4 b5 b6 b7
# a1b1 a2b2 a3b3 a4b4 a5b5 a6b6 a7b7 a0b0 a = rotate_left(a, 1); b ^= a;
# a1b1 a2b2 a3b3 a4b4 a5b5 a6b6 a7b7 a0b0 = b
# a3b23 a4b34 a5b45 a6b56 a7b67 a0b07 a1b01 a2b12
# a13b123 a24b234 a35b345 a46b456 a57b567 a06b067 a17b017 a02b012 b = rotate_left(b, 3); a ^= b
# a13b123 a24b234 a35b345 a46b456 a57b567 a06b067 a17b017 a02b012
left ^= right # linear layer
left = rotate_left(left, 1, 8)
right ^= left
right = rotate_left(right, 3, 8)
left ^= right
left = rotate_left(left,
right = S_BOX256[right]
left = S_BOX256[left] # non-linear layer
seed[index], seed[index2] = left, right
def permutation(seed, key, index, index2, wordsize):
# could squeeze output after each quarter section to improve latency
_permutation(seed, key, index, index2, wordsize)
_permutation(seed, key, (5 + index), (5 + index2), wordsize)
_permutation(seed, key, (10 + index), (10 + index2), wordsize)
_permutation(seed, key, (15 + index), (15 + index2), wordsize)
def combine_key_stream(state, seed, plaintext_index, index, index2):
print bytearray(seed)
try:
state[plaintext_index + 0] ^= (seed[index + 0] ^ seed[index2 + 0])
state[plaintext_index + 1] ^= (seed[index + 5] ^ seed[index2 + 5])
state[plaintext_index + 2] ^= (seed[index + 10] ^ seed[index2 + 10])
state[plaintext_index + 3] ^= (seed[index + 15] ^ seed[index2 + 15])
except IndexError:
pass
def stream_cipher(plaintext, key, seed, wordsize=8):
# make state 2x key
# 4 instances of 5-8 bit words via SIMD would be scalable?
# 80-bit prng key, 160 bit state (5 * 8 = 40 * 4 = 160)
# optional seed key for increased key bits?
prng_key, seed_key = key
assert len(seed) == 20
assert len(seed_key) == 20
assert len(prng_key) == 10
seed = list(seed)
xor_subroutine(seed, seed_key)
key = prng_key
size = 5
state = bytearray(plaintext)
plaintext_size = len(state)
plaintext_index = 0
break_flag = False
# requires one round warmup for full diffusion
# a + b, a + c, a + d
# b + c, b + d
# c + d
assert size - 1
for index in range(size - 1):
for index2 in range(index, size):
permutation(seed, key, index, index2, wordsize)
transposition(seed)
while True:
for index in range(size - 1):
for index2 in range(index + 1, size):
permutation(seed, key, index, index2, wordsize)
combine_key_stream(state, seed, plaintext_index, index, index2)
transposition(seed)
plaintext_index += 4
if plaintext_index >= plaintext_size:
break_flag = True
break
if break_flag:
break
if break_flag:
break
try:
plaintext[:] = state
except TypeError:
pass
return state
def generate_keys():
return bytearray(urandom(KEY_SIZE)), bytearray(urandom(SEED_SIZE))
def generate_seed(seed_key):
seed = bytearray(urandom(SEED_SIZE))
xor_subroutine(seed, seed_key)
return seed
def test_stream_cipher():
prng_key, seed_key = range(10), range(20)
seed = seed_key
message = bytearray("Awesome!")
_message = message[:]
stream_cipher(message, (prng_key, seed_key), seed)
ciphertext = message[:]
stream_cipher(message, (prng_key, seed_key), seed)
plaintext = message[:]
assert plaintext == _message, (plaintext, _message)
def test_metrics():
from crypto.analysis.metrics import test_stream_cipher
def keygen(byte):
key = [0] * 10
key[-1] = ord(byte)
return key, [0] * 20
def seedgen(padding, byte):
output = bytearray(20)
try:
output[-1] = byte
except (ValueError, TypeError):
output[-1] = byte[0]
return output
seed = [0] * 20
test_stream_cipher(stream_cipher, generate_keys(), seed, key_generation_function=keygen, seed_generation_function=seedgen)#,
#randomness_test=False, avalanche_test=False, bias_test=False)
if __name__ == "__main__":
test_stream_cipher()
test_metrics()
def test_metrics():
from crypto.analysis.metrics import test_stream_cipher
test_stream_cipher(stream_cipher, "\x00" * 16, "\x00" * 16)
def test_metrics(cls, *args, **kwargs):
from crypto.analysis.metrics import test_stream_cipher
cipher = cls(*args)
test_stream_cipher(cipher.encrypt, "\x00" * 16, "\x00" * 16, **kwargs)
def test_encrypt_metrics():
from crypto.analysis.metrics import test_stream_cipher, PERFORMANCE_TEST
print "Testing metrics of encryption algorithm"
test_stream_cipher(encrypt, "\x00" * 16, "\x00" * 16, performance_test_sizes=(1500, 4096), **PERFORMANCE_TEST)
def test_crypt_stream_metrics():
from crypto.analysis.metrics import test_stream_cipher
test_stream_cipher(crypt_stream, bytearray(32), bytearray(32))
def test_metrics(cls, *args, **kwargs):
from crypto.analysis.metrics import test_stream_cipher
cipher = cls(*args)
test_stream_cipher(cipher.encrypt, "\x00" * 16, "\x00" * 16, **kwargs)
