def create_modules(self): """ Construct all the required modules """ self.lfsr = lfsr(size=self.addr_size, name="bist_lfsr") self.add_mod(self.lfsr) self.fsm = fsm() self.add_mod(self.fsm) self.xor2 = xor2() self.add_mod(self.xor2) self.inv = pinv() self.add_mod(self.inv) if self.async_bist: self.osc = oscillator(self.delay) self.add_mod(self.osc) else: self.osc = frequency_divider() self.add_mod(self.osc) self.data_pattern = data_pattern(self.data_size) self.add_mod(self.data_pattern) self.comparator = comparator(self.data_size) self.add_mod(self.comparator)
def __init__(self, rom0mif, uart0_map): self.cpu0 = cpu(self.readFunction, self.writeFunction, self.retiFunction, self.interrupt, "cpu0") self.rom0 = rom(0x000000, 8, rom0mif, "rom0") self.ram0 = ram(0x000400, 10, "ram0") self.ram1 = ram(0x100000, 13, "ram1") self.systim0 = systim(0x000104, self.interrupt, "systim0") self.intControler0 = intControler(0x00010F, self.cpu0, "intControler0") self.uart0 = uart(0x000130, self.interrupt, uart0_map, "uart0") self.lfsr0 = lfsr(0x00010E, "lfsr0")
def generador_geffe(func1, sem1, func2, sem2, func3, sem3, l): x1 = lfsr(func1,sem1,l) x2 = lfsr(func2,sem2,l) x3 = lfsr(func3,sem3,l) s = [] for i in range(0,l): p1 = x1[i]*x2[i] p2 = x2[i]*x3[i] p3 = x3[i] f = p1 ^ p2 ^ p3 s.append(f) return s
def dft_attack(seq_s, fun_f, fun_g): n = fun_f.degree() field = GF(2 ** n, name = 'gamma', modulus = fun_f) gamma = field.gen() seq_b_iv = [] for i in range(n): seq_b_iv.append(trace(gamma ** i)) seq_b_generator = lfsr(seq_b_iv, fun_f) seq_b = [] for i in range(2 ** n - 1): seq_b.append(seq_b_generator.next()) # print 'seq_b', seq_b seq_a = [] seq_b_doubled = seq_b * 2 # for ease of programming for i in range(2 ** n - 1): seq_a.append(GF(2)(fun_g(seq_b_doubled[i : (i + n)]))) fun_p = bma(seq_a) if len(seq_s) < fun_p.degree(): os.stderr.write("algorithm failed\n") os.exit(-1) # 2 coset_leaders = coset(2 ** n - 1) for k in coset_leaders: # coset() is changed? if 1 == gcd(k, 2 ** n - 1) and k is not 1: break # k_inverse = field(k).pth_power(-1) # not right? for i in range(2 ** n - 1): if (i * k) % (2 ** n - 1) == 1: k_inverse = i break #print 'k_inverse', k_inverse # 3 # print 'seq_a', seq_a # print type(seq_a[0]) (A_k, S_k) = dft(seq_s, seq_a) # print 'A_k', A_k # online phase # 1 # print 'seq_s', seq_s # two dft computations are combined now # print 'S_k', S_k # 2 # print 'k', k # print 'k_inverse', k_inverse # k_inverse = 13 gamma_tau = (S_k[k] * (A_k[k] ** (-1))) ** (k_inverse) # print gamma_tau # 3 result_u = [] for i in range(n): result_u.append(trace(gamma_tau * (gamma_tau.parent().gen() ** i))) return result_u
def _set_lfsr(self, bits): ls = lfsr.lfsr(bits, [16, 18, 19, 21]) ls.advance(64) self._ar = Convert.to_byte_ar(ls.get_contents()) ls.advance(32) self._at = Convert.to_byte_ar(ls.get_contents())
n1 += 1 # no. of negative values else: n2 += 1 runs_exp = ((2 * n1 * n2) / (n1 + n2)) + 1 stan_dev = math.sqrt((2 * n1 * n2 * (2 * n1 * n2 - n1 - n2)) / (((n1 + n2)**2) * (n1 + n2 - 1))) z = (runs - runs_exp) / stan_dev return z test_lfsr = lfsr(26, [0, 1, 5, 25]) test_lfsr.input_seed('1') random_numbers_str = test_lfsr.generate(10000) random_numbers = [] for random_number_str in random_numbers_str: random_numbers.append(int(random_number_str, 2)) median = (2**test_lfsr.size - 1) / 2 Z = runs_test(random_numbers, median) Z_critical = 1.96 # Confidence level of 95% print('Z-statistic =', abs(Z), ", Should be less than Zcritical =", Z_critical) print('Median =', statistics.median(random_numbers), ", Should be similar to expected median =", median) print(f"The test { 'Passed' if (abs(Z) < Z_critical) else 'Failed'}"
def dft(sequence, reference=None): if None == reference: N = len(sequence) seq_a = list(sequence) else: N = len(reference) seq_a = list(reference) seq_a_target = list(sequence) fun_p = bma(seq_a * 2) # turn sequence as periodic L = fun_p.degree() # assert 2 * L <= len(seq_a) # selection of parameters # fine smallest n, s.t. N | (2^n - 1) n = 1 while 0 != (2**n - 1) % N: # this means N cannot be even number n += 1 # print n # define the extension field TheExtensionField = GF(2**n, 'beta') beta = TheExtensionField.gen() fun_f = TheExtensionField.polynomial() TheExtensionPolynomialRing = TheExtensionField['Y'] # print fun_f # construct a new m-seq {b_t} seq_b_iv = [] for i in range(n): seq_b_iv.append((beta**i).trace()) seq_b_generator = lfsr(seq_b_iv, fun_f) seq_b = [] for i in range(2**len(seq_b_iv) - 1): seq_b.append(seq_b_generator.next()) # print seq_b_iv # print seq_b # let alpha be an element in GF(2^n) with order N alpha = beta**((2**n - 1) / N) # print alpha, alpha ** N # procedure # step 1. compute coset I = coset(N) # print I # step 2. fun_p_extended = TheExtensionPolynomialRing(fun_p) # print fun_p_extended spectra_A = [None] * N spectra_A_target = [None] * N for k in I: if fun_p_extended(alpha**k) != 0: spectra_A[k] = 0 if reference: spectra_A_target[k] = 0 continue # print 'k', k, fun_p_extended(alpha ** k) # sub-routine for computing A_k # 1. get coset size m = I[k] # print k, m, n # 2. k-decimation sequence seq_c = [] if m == n: for t in range(2 * m): seq_c.append(seq_b[(t * k) % (2**n - 1)]) elif m < n: for t in range(2 * m): seq_c.append(trace(alpha**(k * t), m)) else: import sys sys.stderr.write("should never happen?\n") sys.exit(-1) # print seq_b # print seq_c fun_p_k = bma(seq_c) # print fun_p # print fun_p_k # print fun_p / fun_p_k matrix_M_ele = [] for i in range(m): for ele in range(i, m + i): matrix_M_ele.append(seq_c[ele]) matrix_M = matrix(GF(2), m, m, matrix_M_ele) # print 'matrix_M' # print matrix_M # 3. contruct a filter fun_q = fun_p.parent()(fun_p / fun_p_k) # print fun_q # print type(fun_q) # 4. compute the time convolution seq_v_generator = convolution(seq_a, fun_q) seq_v = [] for i in range(m): seq_v.append(seq_v_generator.next()) if reference: seq_v_target_generator = convolution(seq_a_target, fun_q) seq_v_target = [] for i in range(m): seq_v_target.append(seq_v_target_generator.next()) # 4.5 solve linear equations to get x_i matrix_x = matrix_M.inverse() * matrix(GF(2), m, 1, seq_v) # print 'matrix_x' # print matrix_x if reference: matrix_x_target = matrix_M.inverse() * matrix( GF(2), m, 1, seq_v_target) # print 'matrix_x_target' # print matrix_x_target # 5. compute A_k = V * T V = 0 for i in range(m): if 1 == matrix_x[i][0]: V += alpha**(i * k) if reference: V_target = 0 for i in range(m): if 1 == matrix_x_target[i][0]: V_target += alpha**(i * k) fun_q_extended = TheExtensionPolynomialRing(fun_q) # print fun_q_extended T = fun_q_extended(alpha**k)**(-1) # print T # print type(T) A_k = V * T # print A_k spectra_A[k] = A_k if reference: A_k_target = V_target * T spectra_A_target[k] = A_k_target # print spectra_A # print spectra_A_target # to compute the A_k where k is not coset leader for i in I: for j in range(1, I[i]): spectra_A[(i * (2**j)) % N] = spectra_A[i]**(2**j) if reference: spectra_A_target[(i * (2**j)) % N] = spectra_A_target[i]**(2**j) # print alpha ** 6 if None == reference: return spectra_A else: return spectra_A, spectra_A_target
def dft(sequence, reference=None): if None == reference: N = len(sequence) seq_a = list(sequence) else: N = len(reference) seq_a = list(reference) seq_a_target = list(sequence) fun_p = bma(seq_a * 2) # turn sequence as periodic L = fun_p.degree() # assert 2 * L <= len(seq_a) # selection of parameters # fine smallest n, s.t. N | (2^n - 1) n = 1 while 0 != (2 ** n - 1) % N: # this means N cannot be even number n += 1 # print n # define the extension field TheExtensionField = GF(2 ** n, "beta") beta = TheExtensionField.gen() fun_f = TheExtensionField.polynomial() TheExtensionPolynomialRing = TheExtensionField["Y"] # print fun_f # construct a new m-seq {b_t} seq_b_iv = [] for i in range(n): seq_b_iv.append((beta ** i).trace()) seq_b_generator = lfsr(seq_b_iv, fun_f) seq_b = [] for i in range(2 ** len(seq_b_iv) - 1): seq_b.append(seq_b_generator.next()) # print seq_b_iv # print seq_b # let alpha be an element in GF(2^n) with order N alpha = beta ** ((2 ** n - 1) / N) # print alpha, alpha ** N # procedure # step 1. compute coset I = coset(N) # print I # step 2. fun_p_extended = TheExtensionPolynomialRing(fun_p) # print fun_p_extended spectra_A = [None] * N spectra_A_target = [None] * N for k in I: if fun_p_extended(alpha ** k) != 0: spectra_A[k] = 0 if reference: spectra_A_target[k] = 0 continue # print 'k', k, fun_p_extended(alpha ** k) # sub-routine for computing A_k # 1. get coset size m = I[k] # print k, m, n # 2. k-decimation sequence seq_c = [] if m == n: for t in range(2 * m): seq_c.append(seq_b[(t * k) % (2 ** n - 1)]) elif m < n: for t in range(2 * m): seq_c.append(trace(alpha ** (k * t), m)) else: import sys sys.stderr.write("should never happen?\n") sys.exit(-1) # print seq_b # print seq_c fun_p_k = bma(seq_c) # print fun_p # print fun_p_k # print fun_p / fun_p_k matrix_M_ele = [] for i in range(m): for ele in range(i, m + i): matrix_M_ele.append(seq_c[ele]) matrix_M = matrix(GF(2), m, m, matrix_M_ele) # print 'matrix_M' # print matrix_M # 3. contruct a filter fun_q = fun_p.parent()(fun_p / fun_p_k) # print fun_q # print type(fun_q) # 4. compute the time convolution seq_v_generator = convolution(seq_a, fun_q) seq_v = [] for i in range(m): seq_v.append(seq_v_generator.next()) if reference: seq_v_target_generator = convolution(seq_a_target, fun_q) seq_v_target = [] for i in range(m): seq_v_target.append(seq_v_target_generator.next()) # 4.5 solve linear equations to get x_i matrix_x = matrix_M.inverse() * matrix(GF(2), m, 1, seq_v) # print 'matrix_x' # print matrix_x if reference: matrix_x_target = matrix_M.inverse() * matrix(GF(2), m, 1, seq_v_target) # print 'matrix_x_target' # print matrix_x_target # 5. compute A_k = V * T V = 0 for i in range(m): if 1 == matrix_x[i][0]: V += alpha ** (i * k) if reference: V_target = 0 for i in range(m): if 1 == matrix_x_target[i][0]: V_target += alpha ** (i * k) fun_q_extended = TheExtensionPolynomialRing(fun_q) # print fun_q_extended T = fun_q_extended(alpha ** k) ** (-1) # print T # print type(T) A_k = V * T # print A_k spectra_A[k] = A_k if reference: A_k_target = V_target * T spectra_A_target[k] = A_k_target # print spectra_A # print spectra_A_target # to compute the A_k where k is not coset leader for i in I: for j in range(1, I[i]): spectra_A[(i * (2 ** j)) % N] = spectra_A[i] ** (2 ** j) if reference: spectra_A_target[(i * (2 ** j)) % N] = spectra_A_target[i] ** (2 ** j) # print alpha ** 6 if None == reference: return spectra_A else: return spectra_A, spectra_A_target