def __init__(self, n, k, log2FieldSize=-1, systematic=1, shouldUseLUT=-1):
"""
Function: __init__(n,k,log2FieldSize,systematic,shouldUseLUT)
Purpose: Create a Reed-Solomon coder for an (n,k) code.
Notes: The last parameters, log2FieldSize, systematic
and shouldUseLUT are optional.
The log2FieldSize parameter
represents the base 2 logarithm of the field size.
If it is omitted, the field GF(2^p) is used where
p is the smalles integer where 2^p >= n.
If systematic is true then a systematic encoder
is created (i.e. one where the first k symbols
of the encoded result always match the data).
If shouldUseLUT = 1 then a lookup table is used for
computing finite field multiplies and divides.
If shouldUseLUT = 0 then no lookup table is used.
If shouldUseLUT = -1 (the default), then the code
decides when a lookup table should be used.
"""
if (log2FieldSize < 0):
log2FieldSize = int(math.ceil(math.log(n) / math.log(2)))
self.field = ffield.FField(log2FieldSize, useLUT=shouldUseLUT)
self.n = n
self.k = k
self.fieldSize = 1 << log2FieldSize
self.CreateEncoderMatrix()
if (systematic):
self.encoderMatrix.Transpose()
self.encoderMatrix.LowerGaussianElim()
self.encoderMatrix.UpperInverse()
self.encoderMatrix.Transpose()
def DegField1():
print "DegField1:",
F = ffield.FField(2)
f = [1, 3, 0, 2] #t*x^2 + 1
answer = 2
pol = FPolynom(F, [])
pol.FromPermutation(f)
Test(pol.Deg(), answer)
def FuncPolynom3():
print "FuncPolynom3:",
F = ffield.FField(2)
f = [1, 1, 1, 1]
answer = f
pol = FPolynom(F, [])
pol.FromPermutation(f)
Test(pol.Values(False), answer)
def FuncPolynom2():
print "FuncPolynom2:",
F = ffield.FField(2)
f = [1, 2, 2, 0] #x^3 + x^2 + x(t + 1) + 1
answer = FPolynom(F, [1, 3, 1, 1])
pol = FPolynom(F, [])
pol.FromPermutation(f)
Test(pol, answer)
def FuncPolynom1():
print "FuncPolynom1:",
F = ffield.FField(2)
f = [1, 3, 0, 2] #t*x^2 + 1
answer = FPolynom(
F, [FElement(F, 1),
FElement(F, 0),
FElement(F, 2),
FElement(F, 0)], True)
pol = FPolynom(F, [])
pol.FromPermutation(f)
Test(pol, answer)
def get_ecc(self, codewords):
"as described in BBC whitepaper..."
generator = table_generator[self.codewords - self.datawords]
F = ffield.FField(8)
acc = [0] * (len(codewords) + len(generator))
p = 0
for c in codewords:
acc[p] = F.Add(acc[p], c)
q = 1
for g in generator:
acc[p + q] = F.Add(acc[p + q], F.Multiply(acc[p], g))
q += 1
p += 1
return acc[len(codewords):]
sys.path.append("../FFIeldFunc")
sys.path.append("../FieldPolynom")
sys.path.append("../Cryptonalysis")
from DifferentialCryptanalisys import *
from LineCryptoanalisys import *
import ffield
from ffield import FElement
from boolean import *
from field_func import *
import itertools
from permutation import *
from field_polynom import *
n = 4
F = ffield.FField(n)
sbox = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 12, 15, 14]
print "S-box:"
print sbox
print
print "Differential table:"
50 2f b4 ed 6e 3d 63 9e 7a 1c a4 71 f9 f0 52 ce 0f 35 e5 02 2c 18 93 f7 f3 9c a7 7d b5 97 4d 00 7a 55 d9 d4 18 41 82 c6
11 70 f6 85 38 02 17 e1 06 6f 3b f6 7a 0b 93 5e 0f a8 2f 61 69 18 ee a2 57 3d 73 4b df c7 55 7c 27 3e a5 e5 8d a6 4f 37
50 63 f6 84 fa 7c 63 77 5e 6f 8b c8 26 f7 46 b1 1f bb 9a 61 7e 18 8a e8 d5 53 a7 d3 1f 4c 55 ae 7a b8 3e e5 cd 41 84 e5"""
# format cipher texts. all_ciphs is a list of all 8 ciphers,
# each one represented as a list of it's 40 message bytes
all_ciphs = string.split(eight_ciphs, "\n")
for i in xrange(len(all_ciphs)):
all_ciphs[i] = string.split(all_ciphs[i], " ")
# create pad hex bytes
hexdigits = string.hexdigits[:-6]
possible_pad_bytes = [i + j for i in hexdigits for j in hexdigits]
# Initialize finite field GF(8)
F = ffield.FField(8)
# Helper functions for computations
def hex2dec(hex_string):
'''converts hex value to dec'''
return int(hex_string, 16)
def dec2hex(dec):
'''converts int to hex string W/OUT '0x' in front'''
return hex(dec)[2:]
def resolve_mi(ci_hex, pi_hex, qi_hex):
'''given hex-valued values ci, pi, and qi, return mi,
import sys
sys.path.append("../Boolean")
sys.path.append("../Permutation")
sys.path.append("../FField")
sys.path.append("../FFieldFunc")
sys.path.append("../FieldPolynom")
import ffield
from ffield import FElement
from boolean import *
from field_func import *
import itertools
from permutation import *
from field_polynom import *
F = ffield.FField(2)
p = []
for i in range(2**F.n):
p.append(i)
perms = list(itertools.permutations(p))
c = FPolynom(F, []);
for j in range(len(perms)):
perm = perms[j]
fieldFunc = list(perm)
eq = FieldFuncToBooleanFunc(fieldFunc, F.n)
degs = ""
for q in eq:
degs = degs + str(Deg(q)) + ", "
degs = "[" + degs[0:-2] + "]"
c.FromPermutation(fieldFunc)
import sys
import os
import random
from os import path
import binascii
# Defining some constants for GF
mask1 = 128
mask2 = 127
polyred = 7
exp = [[] for i in range(128)]
io_dict = dict()
num_plain_texts = 0
# First we'll break the diagonal elements
import ffield
F = ffield.FField(7)
def addGF(p1,p2):
# Assume both a and b are integers
return p1^p2
def multGF(p1, p2):
return F.Multiply(p1,p2)
def convertHex(list_p1):
text = ""
for p1 in list_p1:
text += format(p1,'08b')
temp1 = ""
for i in range(0,len(text)//4):
temp1 = temp1 + chr(ord('f')+int(8*int(text[i*4])+4*int(text[i*4+1])+2*int(text[i*4+2])+int(text[i*4+3])))
