toycipher_definition.sage

from sage.crypto.sbox import SBox

# function that maps a list of 4-bits (e.g. [1,0,1,1]) to an integer (e.g. in this case 8+2+1=11)
def bits2word(L): return L[0]*8+L[1]*4+L[2]*2+L[3]

# inverse of bits2word
def word2bits(W): return [(W//8)%2, (W//4)%2, (W//2)%2, W%2]

# xor 2 bits
def xorbits(x,y): return (((x)+(y))%2)

# xor 2 lists of bits elementwise
def xor(L,M): return map(xorbits,L,M)

# function that maps an integer i in [0,65536) to list of 16 bits (left-most bit is MSB)
def int2state(i): return [((i//(2**(15-b)))%2) for b in range(16)]

# inverse of int2state
def state2int(L): return sum([(L[b]*(2**(15-b))) for b in range(16)],0)

# function to generate a list of 16 random bits
def randkey(): return int2state(getrandbits(16))

# permute bits in list of 16 bits as Pi_P in lecture notes
PP=[0,4,8,12,1,5,9,13,2,6,10,14,3,7,11,15]
def permbits(L): return [L[PP[i]] for i in range(16)]

# inverse of permbits is permbits itself
def permbitsinv(L): return permbits(L)

# function to split a state (list of 16 bits) into 4 words of 4 bits
def state2words(L): return [bits2word(L[0:4]), bits2word(L[4:8]),bits2word(L[8:12]), bits2word(L[12:16])]

# inverse of state2words
def words2state(L): return sum(map(word2bits, L),[])

# SBox and inverse SBox definitions
SB=SBox(14,4,13,1,2,15,11,8,3,10,6,12,5,9,0,7);
SBinv=SBox(14,3,4,8,1,12,10,15,7,13,9,6,11,2,0,5);

# apply SBox on state (list of 16 bits)
def substbits(L): return words2state(map(SB, state2words(L)))

# apply inverse SBox on state
def substbitsinv(L): return words2state(map(SBinv, state2words(L)))

# do one round of encryption given state L and round key K
def encryptround(L,K): return permbits(substbits(xor(L,K)))

# do final round of encryption given state L and round key K1 and final round key K2
def encryptfinalround(L,K1,K2): return xor(substbits(xor(L,K1)),K2)

# do encryption (4 rounds) with globally defined round keys: k1,k2,k3,k4,k5
def encrypt(L): return encryptfinalround(encryptround(encryptround(encryptround(L,k1),k2),k3),k4,k5)

# do decryption of one round
def decryptround(L,K): return xor(substbitsinv(permbitsinv(L)),K)

# do decryption of final round
def decryptfinalround(L,K1,K2): return xor(substbitsinv(xor(L,K2)),K1)

# do decryption with globally defined round keys: k1,k2,k3,k4,k5
def decrypt(L): return decryptround(decryptround(decryptround(decryptfinalround(L,k4,k5),k3),k2),k1)