def generate_simon_version(n, rounds, a=8, b=1, c=2):
simon = CipherDescription(2*n)
for i in range(n):
input_1 = "s{}".format((i-a)%n+n)
input_2 = "s{}".format((i-b)%n+n)
product = "t{}".format(2*i)
simon.apply_and(input_1, input_2, product)
input_3 = "s{}".format((i-c)%n+n)
xor = "t{}".format(2*i+1)
simon.apply_xor(product, input_3, xor)
right_side = "s{}".format(i)
simon.apply_xor(xor, right_side, right_side)
for i in range(n):
right_side = "s{}".format(i)
left_side = "s{}".format(i+n)
simon.apply_permutation( (right_side, left_side) )
simon.set_rounds(rounds)
return simon
def generate_speck_version(n, a, b):
speck = CipherDescription(2 * n)
s = ['s{}'.format(i) for i in range(2 * n)]
'''
if n == 16:
a = 7
b = 2
else:
a = 8
b = 3
'''
x = s[n:]
y = s[:n]
if n % a == 0:
for j in range(a):
shift = [
's{}'.format(n + j + (i * (n - a)) % n) for i in range(n / a)
]
speck.apply_permutation(shift)
else:
shift = ['s{}'.format(n + (i * (n - a)) % n) for i in range(n)]
speck.apply_permutation(shift)
speck.add_mod(x, y, x, n, 0)
if n % b == 0:
for j in range(b):
shift = ['s{}'.format(j + i * b) for i in range(n / b)]
speck.apply_permutation(shift)
else:
shift = ['s{}'.format((i * b) % n) for i in range(n)]
speck.apply_permutation(shift)
for i in range(n):
speck.apply_xor(x[i], y[i], y[i])
return speck
def generate_Kreyvium_version(rounds):
kreyvium = CipherDescription(416)
for i in range(128):
kreyvium.apply_mov("s{}".format(93+i), "s{}".format(288+i))
for r in range(rounds):
kreyvium.apply_xor("s65", "s92", "t1")
kreyvium.apply_xor("s161", "s176", "t2")
kreyvium.apply_xor("s242", "s287", "t3")
kreyvium.apply_and("s90", "s91", "tand1")
kreyvium.apply_and("s174", "s175", "tand2")
kreyvium.apply_and("s285", "s286", "tand3")
kreyvium.apply_xor("t1", "tand1", "t1")
kreyvium.apply_xor("t1", "s415", "t1")
kreyvium.apply_xor("t1", "s170", "s92")
kreyvium.apply_xor("t2", "tand2", "t2")
kreyvium.apply_xor("t2", "s263", "s176")
kreyvium.apply_xor("t3", "tand3", "t3")
kreyvium.apply_xor("t3", "s68", "s287")
switch_last_bits = ("s92", "s176", "s287")
kreyvium.apply_permutation(switch_last_bits)
permutation_1 = tuple("s{}".format(i) for i in range(93))
permutation_2 = tuple("s{}".format(i) for i in range(93, 177))
permutation_3 = tuple("s{}".format(i) for i in range(177, 288))
permutation_4 = tuple("s{}".format(i) for i in range(288, 416))
kreyvium.apply_permutation(permutation_1)
kreyvium.apply_permutation(permutation_2)
kreyvium.apply_permutation(permutation_3)
kreyvium.apply_permutation(permutation_4)
return kreyvium
from cipher_description import CipherDescription
trivium = CipherDescription(288)
trivium.apply_xor("s65", "s92", "t1")
trivium.apply_xor("s161", "s176", "t2")
trivium.apply_xor("s242", "s287", "t3")
trivium.apply_and("s90", "s91", "tand1")
trivium.apply_and("s174", "s175", "tand2")
trivium.apply_and("s285", "s286", "tand3")
trivium.apply_xor("t1", "tand1", "t1")
trivium.apply_xor("t1", "s170", "s92")
trivium.apply_xor("t2", "tand2", "t2")
trivium.apply_xor("t2", "s263", "s176")
trivium.apply_xor("t3", "tand3", "t3")
trivium.apply_xor("t3", "s68", "s287")
switch_last_bits = ("s92", "s176", "s287")
trivium.apply_permutation(switch_last_bits)
permutation_1 = tuple("s{}".format(i) for i in range(93))
permutation_2 = tuple("s{}".format(i) for i in range(93, 177))
permutation_3 = tuple("s{}".format(i) for i in range(177, 288))
trivium.apply_permutation(permutation_1)
trivium.apply_permutation(permutation_2)
trivium.apply_permutation(permutation_3)
trivium.set_rounds(1152)
def generate_skinny_version(wordsize, rounds):
# State
# 0 1 2 3
# 4 5 6 7
# 8 9 10 11
# 12 13 14 15
if wordsize == 4:
skinny_sbox = [
0xC, 0x6, 0x9, 0x0, 0x1, 0xa, 0x2, 0xb, 0x3, 0x8, 0x5, 0xd, 0x4,
0xe, 0x7, 0xf
]
elif wordsize == 8:
skinny_sbox = [
0x65, 0x4c, 0x6a, 0x42, 0x4b, 0x63, 0x43, 0x6b, 0x55, 0x75, 0x5a,
0x7a, 0x53, 0x73, 0x5b, 0x7b, 0x35, 0x8c, 0x3a, 0x81, 0x89, 0x33,
0x80, 0x3b, 0x95, 0x25, 0x98, 0x2a, 0x90, 0x23, 0x99, 0x2b, 0xe5,
0xcc, 0xe8, 0xc1, 0xc9, 0xe0, 0xc0, 0xe9, 0xd5, 0xf5, 0xd8, 0xf8,
0xd0, 0xf0, 0xd9, 0xf9, 0xa5, 0x1c, 0xa8, 0x12, 0x1b, 0xa0, 0x13,
0xa9, 0x05, 0xb5, 0x0a, 0xb8, 0x03, 0xb0, 0x0b, 0xb9, 0x32, 0x88,
0x3c, 0x85, 0x8d, 0x34, 0x84, 0x3d, 0x91, 0x22, 0x9c, 0x2c, 0x94,
0x24, 0x9d, 0x2d, 0x62, 0x4a, 0x6c, 0x45, 0x4d, 0x64, 0x44, 0x6d,
0x52, 0x72, 0x5c, 0x7c, 0x54, 0x74, 0x5d, 0x7d, 0xa1, 0x1a, 0xac,
0x15, 0x1d, 0xa4, 0x14, 0xad, 0x02, 0xb1, 0x0c, 0xbc, 0x04, 0xb4,
0x0d, 0xbd, 0xe1, 0xc8, 0xec, 0xc5, 0xcd, 0xe4, 0xc4, 0xed, 0xd1,
0xf1, 0xdc, 0xfc, 0xd4, 0xf4, 0xdd, 0xfd, 0x36, 0x8e, 0x38, 0x82,
0x8b, 0x30, 0x83, 0x39, 0x96, 0x26, 0x9a, 0x28, 0x93, 0x20, 0x9b,
0x29, 0x66, 0x4e, 0x68, 0x41, 0x49, 0x60, 0x40, 0x69, 0x56, 0x76,
0x58, 0x78, 0x50, 0x70, 0x59, 0x79, 0xa6, 0x1e, 0xaa, 0x11, 0x19,
0xa3, 0x10, 0xab, 0x06, 0xb6, 0x08, 0xba, 0x00, 0xb3, 0x09, 0xbb,
0xe6, 0xce, 0xea, 0xc2, 0xcb, 0xe3, 0xc3, 0xeb, 0xd6, 0xf6, 0xda,
0xfa, 0xd3, 0xf3, 0xdb, 0xfb, 0x31, 0x8a, 0x3e, 0x86, 0x8f, 0x37,
0x87, 0x3f, 0x92, 0x21, 0x9e, 0x2e, 0x97, 0x27, 0x9f, 0x2f, 0x61,
0x48, 0x6e, 0x46, 0x4f, 0x67, 0x47, 0x6f, 0x51, 0x71, 0x5e, 0x7e,
0x57, 0x77, 0x5f, 0x7f, 0xa2, 0x18, 0xae, 0x16, 0x1f, 0xa7, 0x17,
0xaf, 0x01, 0xb2, 0x0e, 0xbe, 0x07, 0xb7, 0x0f, 0xbf, 0xe2, 0xca,
0xee, 0xc6, 0xcf, 0xe7, 0xc7, 0xef, 0xd2, 0xf2, 0xde, 0xfe, 0xd7,
0xf7, 0xdf, 0xff
]
# ShiftRows
shiftrows = []
for bit in range(wordsize):
# Second Row
shiftrows.append([
"s{}".format(wordsize * 4 + bit), "s{}".format(wordsize * 5 + bit),
"s{}".format(wordsize * 6 + bit), "s{}".format(wordsize * 7 + bit)
])
# Third Row
shiftrows.append([
"s{}".format(wordsize * 8 + bit), "s{}".format(wordsize * 10 + bit)
])
shiftrows.append([
"s{}".format(wordsize * 9 + bit), "s{}".format(wordsize * 11 + bit)
])
# Fourth Row
shiftrows.append([
"s{}".format(wordsize * 12 + bit),
"s{}".format(wordsize * 15 + bit),
"s{}".format(wordsize * 14 + bit),
"s{}".format(wordsize * 13 + bit)
])
skinny = CipherDescription(wordsize * 16)
skinny.add_sbox('S-box', skinny_sbox)
# SubCells
for word in range(16):
bits = ["s{}".format(wordsize * word + i) for i in range(wordsize)]
skinny.apply_sbox('S-box', bits, bits)
# ShiftRows
for shift in shiftrows:
skinny.apply_permutation(shift)
# MixColumns
for col in range(4):
for bit in range(wordsize):
x0 = "s{}".format(bit + col * wordsize)
x1 = "s{}".format(bit + 4 * wordsize + col * wordsize)
x2 = "s{}".format(bit + 4 * 2 * wordsize + col * wordsize)
x3 = "s{}".format(bit + 4 * 3 * wordsize + col * wordsize)
skinny.apply_xor(x1, x2, x1)
skinny.apply_xor(x2, x0, x2)
skinny.apply_xor(x2, x3, x3)
skinny.apply_permutation([x0, x1, x2, x3])
return skinny
from cipher_description import CipherDescription
rectangle_sbox = [
0x6, 0x5, 0xC, 0xA, 0x1, 0xE, 0x7, 0x9, 0xB, 0x0, 0x3, 0xD, 0x8, 0xF, 0x4,
0x2
]
rectangle_permutations = [\
['s16', 's17', 's18','s19','s20','s21','s22','s23','s24','s25','s26','s27','s28','s29','s30','s31'],
['s32', 's44', 's40','s36'],
['s33', 's45', 's41','s37'],
['s34', 's46', 's42','s38'],
['s35', 's47', 's43','s39'],
['s48', 's61', 's58','s55','s52','s49','s62','s59','s56','s53','s50','s63','s60','s57','s54','s51'],
]
rectangle = CipherDescription(64)
rectangle.add_sbox('S-box', rectangle_sbox)
for i in range(16):
bits = [
"s{}".format(i + 0), "s{}".format(i + 16), "s{}".format(i + 32),
"s{}".format(i + 48)
]
rectangle.apply_sbox('S-box', bits, bits)
for p in rectangle_permutations:
rectangle.apply_permutation(p)
['s2', 's32', 's8'],
['s3', 's48', 's12'],
['s5', 's17', 's20'],
['s6', 's33', 's24'],
['s7', 's49', 's28'],
['s9', 's18', 's36'],
['s10', 's34', 's40'],
['s11', 's50', 's44'],
['s13', 's19', 's52'],
['s14', 's35', 's56'],
['s15', 's51', 's60'],
['s22', 's37', 's25'],
['s23', 's53', 's29'],
['s26', 's38', 's41'],
['s27', 's54', 's45'],
['s30', 's39', 's57'],
['s31', 's55', 's61'],
['s43', 's58', 's46'],
['s47', 's59', 's62']]
present = CipherDescription(64)
present.add_sbox('S-box', present_sbox)
for i in range(16):
bits = [
"s{}".format(4 * i + 0), "s{}".format(4 * i + 1),
"s{}".format(4 * i + 2), "s{}".format(4 * i + 3)
]
present.apply_sbox('S-box', bits, bits)
for p in present_permutations:
present.apply_permutation(p)
# Update State
acorn.apply_xor("s289", "s235", "t1")
acorn.apply_xor("t1", "s230", "s289")
acorn.apply_xor("s230", "s196", "t1")
acorn.apply_xor("t1", "s193", "s230")
acorn.apply_xor("s193", "s160", "t1")
acorn.apply_xor("t1", "s154", "s193")
acorn.apply_xor("s154", "s111", "t1")
acorn.apply_xor("t1", "s107", "s154")
acorn.apply_xor("s107", "s66", "t1")
acorn.apply_xor("t1", "s61", "s107")
acorn.apply_xor("s61", "s23", "t1")
acorn.apply_xor("t1", "s0", "s61")
# Compute Feedback Bit
# f = s0 + ~s107 + maj(s244, s23, s160) + ch(s230, s111, s66) + s196 + k
maj(acorn, "s244", "s23", "s160", "tmaj2")
ch(acorn, "s230", "s111", "s66", "tch")
acorn.apply_xor("s0", "s107", "t1") # TODO: Add not to second parameter
acorn.apply_xor("t1", "tmaj2", "t2")
acorn.apply_xor("t2", "tch", "t3")
acorn.apply_xor("t3", "s196", "t4")
acorn.apply_xor("t4", "tk", "s0") # s0 gets feedback bit
# Shift everything
permutation = tuple("s{}".format(i) for i in range(292, -1, -1))
acorn.apply_permutation(permutation)
acorn.set_rounds(1536)
def generate_midori_version(wordsize, rounds):
# State
# 0 4 8 12
# 1 5 9 13
# 2 6 10 14
# 3 7 11 15
if wordsize == 4:
midori_sbox = [
0xC, 0xA, 0xD, 0x3, 0xE, 0xB, 0xF, 0x7, 0x8, 0x9, 0x1, 0x5, 0x0,
0x2, 0x4, 0x6
]
elif wordsize == 8:
midori_sbox = [
0x1, 0x0, 0x5, 0x3, 0xe, 0x2, 0xf, 0x7, 0xd, 0xa, 0x9, 0xb, 0xc,
0x8, 0x4, 0x6
]
# Shuffle Cells
shuffle_cells = []
for bit in range(wordsize):
shuffle_cells.append([
"s{}".format(wordsize * 10 + bit),
"s{}".format(wordsize * 1 + bit), "s{}".format(wordsize * 7 + bit),
"s{}".format(wordsize * 12 + bit)
])
shuffle_cells.append([
"s{}".format(wordsize * 5 + bit), "s{}".format(wordsize * 2 + bit),
"s{}".format(wordsize * 14 + bit), "s{}".format(wordsize * 4 + bit)
])
shuffle_cells.append([
"s{}".format(wordsize * 15 + bit),
"s{}".format(wordsize * 3 + bit), "s{}".format(wordsize * 9 + bit),
"s{}".format(wordsize * 8 + bit)
])
shuffle_cells.append([
"s{}".format(wordsize * 11 + bit), "s{}".format(wordsize * 6 + bit)
])
midori = CipherDescription(wordsize * 16)
midori.add_sbox('S-box', midori_sbox)
# SubCell
for i in range(16):
if wordsize == 4:
bits = [
"s{}".format(4 * i + 3), "s{}".format(4 * i + 2),
"s{}".format(4 * i + 1), "s{}".format(4 * i + 0)
]
midori.apply_sbox('S-box', bits, bits)
else:
# Apply bit permutation
bit_perm = [sb_perm[i % 4][j] for j in range(8)]
for cycle in decompose_permutation(bit_perm):
cycle_bits = []
for v in cycle:
cycle_bits.append("s{}".format(8 * i + v))
midori.apply_permutation(cycle_bits)
# Apply S-box
bits = [
"s{}".format(8 * i + 0), "s{}".format(8 * i + 1),
"s{}".format(8 * i + 2), "s{}".format(8 * i + 3)
]
midori.apply_sbox('S-box', bits, bits)
bits = [
"s{}".format(8 * i + 4), "s{}".format(8 * i + 5),
"s{}".format(8 * i + 6), "s{}".format(8 * i + 7)
]
midori.apply_sbox('S-box', bits, bits)
# Apply bit permutation
bit_perm = [8 * i + sb_perminv[i % 4][j] for j in range(8)]
for cycle in decompose_permutation(bit_perm):
cycle_bits = []
for v in cycle:
cycle_bits.append("s{}".format(8 * i + v))
midori.apply_permutation(cycle_bits)
# ShuffleCell
for shuffle in shuffle_cells:
midori.apply_permutation(shuffle)
# MixColumn
for col in range(4):
for bit in range(wordsize):
x0 = "s{}".format(bit + col * wordsize * 4)
x1 = "s{}".format(bit + wordsize + col * wordsize * 4)
x2 = "s{}".format(bit + 2 * wordsize + col * wordsize * 4)
x3 = "s{}".format(bit + 3 * wordsize + col * wordsize * 4)
midori.apply_xor(x0, x1, "txor01")
midori.apply_xor(x0, x2, "txor02")
midori.apply_xor(x1, x2, "txor12")
midori.apply_xor(x1, "txor12", "tx2")
midori.apply_xor("txor12", x3, x0)
midori.apply_xor("txor02", x3, x1)
midori.apply_xor("txor01", x3, x2)
midori.apply_xor("txor01", "tx2", x3)
# midori.apply_xor(x0, x1, "txor01")
# midori.apply_xor("txor01", x2, "tx3p")
#
# midori.apply_xor("txor01", x3, "tx2p")
#
# midori.apply_xor(x0, x2, "txor02")
# midori.apply_xor("txor02", x3, "tx1p")
#
# midori.apply_xor(x1, x2, "txor12")
# midori.apply_xor("txor12", x3, "tx0p")
#
# midori.apply_mov("tx0p", x0)
# midori.apply_mov("tx1p", x1)
# midori.apply_mov("tx2p", x2)
# midori.apply_mov("tx3p", x3)
return midori
from cipher_description import CipherDescription
bivium = CipherDescription(177)
bivium.apply_xor("s65", "s92", "t0")
bivium.apply_and("s90", "s91", "t1")
bivium.apply_xor("t0", "t1", "t2")
bivium.apply_xor("t2", "s170", "s92")
bivium.apply_xor("s161", "s176", "t3")
bivium.apply_and("s174", "s175", "t4")
bivium.apply_xor("t3", "t4", "t5")
bivium.apply_xor("t5", "s68", "s176")
switch_last_bits = ("s92", "s176")
bivium.apply_permutation(switch_last_bits)
permutation_1 = tuple("s{}".format(i) for i in range(93))
permutation_2 = tuple("s{}".format(i) for i in range(93, 177))
bivium.apply_permutation(permutation_1)
bivium.apply_permutation(permutation_2)
bivium.set_rounds(708)
for bit in range(lanesize):
x = "s{}".format(bit + lanesize * col + (5 * row) * lanesize)
D = "tD{}".format(bit + lanesize * col)
keccak.apply_xor(x, D, x)
# Rho
for row in range(5):
for col in range(5):
bit = col * lanesize + (5 * row * lanesize)
rot_perm = [(i + rot_const[col][row]) % lanesize
for i in range(lanesize)]
for cycle in decompose_permutation(rot_perm):
cycle_bits = []
for v in cycle:
cycle_bits.append("s{}".format(v + bit))
keccak.apply_permutation(cycle_bits)
# Pi
pi_perm = [
1, 15, 22, 16, 12, 13, 3, 20, 11, 23, 6, 9, 4, 10, 8, 14, 18, 17, 2, 5, 19,
7, 24, 21
]
for bit in range(lanesize):
perm = ['s{}'.format(i * lanesize + bit) for i in pi_perm]
keccak.apply_permutation(perm)
for row in range(5):
for bit in range(lanesize):
bits = [
"s{}".format(bit + (5 * row) * lanesize),