def main(): string1 = '' string2 = "c651ceb5fa05b4195f993513d8bb5381" crc = Crc(width = 16, poly = 0x8005, reflect_in = True, xor_in = 0x0000, reflect_out = True, xor_out = 0x0000) crc1 = 'a' crc2 = crc.table_driven(string2) print datetime.datetime.fromtimestamp(time.time()).strftime('%Y-%m-%d %H:%M:%S') while crc1 != crc2: string1 = ''.join(random.SystemRandom().choice(string.ascii_letters + \ string.digits) for _ in range(32)) crc1 = crc.table_driven(string1) print datetime.datetime.fromtimestamp(time.time()).strftime('%Y-%m-%d %H:%M:%S') print string1 print string2 print "CRC: " + str(crc1)
def check_string(opt): """ Return the calculated CRC sum of a string. """ error = False if opt.undefined_crc_parameters: sys.stderr.write("{0:s}: error: undefined parameters\n".format( sys.argv[0])) sys.exit(1) if opt.algorithm == 0: opt.algorithm = opt.algo_bit_by_bit | opt.algo_bit_by_bit_fast | opt.algo_table_driven alg = Crc(width=opt.width, poly=opt.poly, reflect_in=opt.reflect_in, xor_in=opt.xor_in, reflect_out=opt.reflect_out, xor_out=opt.xor_out, table_idx_width=opt.tbl_idx_width) crc = None if opt.algorithm & opt.algo_bit_by_bit: bbb_crc = alg.bit_by_bit(opt.check_string) if crc != None and bbb_crc != crc: error = True crc = bbb_crc if opt.algorithm & opt.algo_bit_by_bit_fast: bbf_crc = alg.bit_by_bit_fast(opt.check_string) if crc != None and bbf_crc != crc: error = True crc = bbf_crc if opt.algorithm & opt.algo_table_driven: # no point making the python implementation slower by using less than 8 bits as index. opt.tbl_idx_width = 8 tbl_crc = alg.table_driven(opt.check_string) if crc != None and tbl_crc != crc: error = True crc = tbl_crc if error: sys.stderr.write("{0:s}: error: different checksums!\n".format( sys.argv[0])) if opt.algorithm & opt.algo_bit_by_bit: sys.stderr.write( " bit-by-bit: {0:#x}\n".format(bbb_crc)) if opt.algorithm & opt.algo_bit_by_bit_fast: sys.stderr.write( " bit-by-bit-fast: {0:#x}\n".format(bbf_crc)) if opt.algorithm & opt.algo_table_driven: sys.stderr.write( " table_driven: {0:#x}\n".format(tbl_crc)) sys.exit(1) return crc
def check_string(opt): """ Return the calculated CRC sum of a string. """ error = False if opt.UndefinedCrcParameters: sys.stderr.write("%s: error: undefined parameters\n" % sys.argv[0]) sys.exit(1) #print(opt.Algorithm) if opt.Algorithm == 0: opt.Algorithm = opt.Algo_Bit_by_Bit | opt.Algo_Bit_by_Bit_Fast | opt.Algo_Table_Driven alg = Crc(width = opt.Width, poly = opt.Poly, reflect_in = opt.ReflectIn, xor_in = opt.XorIn, reflect_out = opt.ReflectOut, xor_out = opt.XorOut, table_idx_width = opt.TableIdxWidth) opt.Algorithm = opt.Algo_Table_Driven crc = None if opt.Algorithm & opt.Algo_Bit_by_Bit: #print( "bit_by_bit") bbb_crc = alg.bit_by_bit(opt.CheckString) if crc != None and bbb_crc != crc: error = True crc = bbb_crc if opt.Algorithm & opt.Algo_Bit_by_Bit_Fast: bbf_crc = alg.bit_by_bit_fast(opt.CheckString) #print( "bit_by_bit_fast") if crc != None and bbf_crc != crc: error = True crc = bbf_crc if opt.Algorithm & opt.Algo_Table_Driven: # no point making the python implementation slower by using less than 8 bits as index. opt.TableIdxWidth = 8 tbl_crc = alg.table_driven(opt.CheckString) if crc != None and tbl_crc != crc: error = True crc = tbl_crc if error: sys.stderr.write("%s: error: different checksums!\n" % sys.argv[0]) if opt.Algorithm & opt.Algo_Bit_by_Bit: sys.stderr.write(" bit-by-bit: 0x%x\n" % bbb_crc) if opt.Algorithm & opt.Algo_Bit_by_Bit_Fast: sys.stderr.write(" bit-by-bit-fast: 0x%x\n" % bbf_crc) if opt.Algorithm & opt.Algo_Table_Driven: sys.stderr.write(" table_driven: 0x%x\n" % tbl_crc) sys.exit(1) return crc
def check_string(opt): """ Return the calculated CRC sum of a string. """ error = False if opt.UndefinedCrcParameters: sys.stderr.write("%s: error: undefined parameters\n" % sys.argv[0]) sys.exit(1) if opt.Algorithm == 0: opt.Algorithm = opt.Algo_Bit_by_Bit | opt.Algo_Bit_by_Bit_Fast | opt.Algo_Table_Driven alg = Crc(width=opt.Width, poly=opt.Poly, reflect_in=opt.ReflectIn, xor_in=opt.XorIn, reflect_out=opt.ReflectOut, xor_out=opt.XorOut, table_idx_width=opt.TableIdxWidth) crc = None if opt.Algorithm & opt.Algo_Bit_by_Bit: bbb_crc = alg.bit_by_bit(opt.CheckString) if crc != None and bbb_crc != crc: error = True crc = bbb_crc if opt.Algorithm & opt.Algo_Bit_by_Bit_Fast: bbf_crc = alg.bit_by_bit_fast(opt.CheckString) if crc != None and bbf_crc != crc: error = True crc = bbf_crc if opt.Algorithm & opt.Algo_Table_Driven: # no point making the python implementation slower by using less than 8 bits as index. opt.TableIdxWidth = 8 tbl_crc = alg.table_driven(opt.CheckString) if crc != None and tbl_crc != crc: error = True crc = tbl_crc if error: sys.stderr.write("%s: error: different checksums!\n" % sys.argv[0]) if opt.Algorithm & opt.Algo_Bit_by_Bit: sys.stderr.write(" bit-by-bit: 0x%x\n" % bbb_crc) if opt.Algorithm & opt.Algo_Bit_by_Bit_Fast: sys.stderr.write(" bit-by-bit-fast: 0x%x\n" % bbf_crc) if opt.Algorithm & opt.Algo_Table_Driven: sys.stderr.write(" table_driven: 0x%x\n" % tbl_crc) sys.exit(1) return crc
def __get_crc(self, model, check_str='123456789', expected_crc=None): """ Get the CRC for a set of parameters from the Python reference implementation. """ if self.verbose: out_str = 'Crc(width = {width:d}, poly = {poly:#x}, reflect_in = {reflect_in}, xor_in = {xor_in:#x}, reflect_out = {reflect_out}, xor_out = {xor_out:#x})'.format( **model) if expected_crc is not None: out_str += ' [check = {0:#x}]'.format(expected_crc) print(out_str) alg = Crc(width=model['width'], poly=model['poly'], reflect_in=model['reflect_in'], xor_in=model['xor_in'], reflect_out=model['reflect_out'], xor_out=model['xor_out']) error = False crc = expected_crc if self.use_algo_bit_by_bit: bbb_crc = alg.bit_by_bit(check_str) if crc is None: crc = bbb_crc error = error or bbb_crc != crc if self.use_algo_bit_by_bit_fast: bbf_crc = alg.bit_by_bit_fast(check_str) if crc is None: crc = bbf_crc error = error or bbf_crc != crc if self.use_algo_table_driven: tbl_crc = alg.table_driven(check_str) if crc is None: crc = tbl_crc error = error or tbl_crc != crc if error: print('error: different checksums!') if expected_crc is not None: print(' check: {0:#x}'.format(expected_crc)) if self.use_algo_bit_by_bit: print(' bit-by-bit: {0:#x}'.format(bbb_crc)) if self.use_algo_bit_by_bit_fast: print(' bit-by-bit-fast: {0:#x}'.format(bbf_crc)) if self.use_algo_table_driven: print(' table_driven: {0:#x}'.format(tbl_crc)) return None return crc
def __get_crc(self, model, check_str="123456789", expected_crc=None): """ Get the CRC for a set of parameters from the Python reference implementation. """ if self.verbose: out_str = "Crc(width = %(width)d, poly = 0x%(poly)x, reflect_in = %(reflect_in)s, xor_in = 0x%(xor_in)x, reflect_out = %(reflect_out)s, xor_out = 0x%(xor_out)x)" % model if expected_crc is not None: out_str += " [check = 0x%x]" % expected_crc print(out_str) alg = Crc(width=model["width"], poly=model["poly"], reflect_in=model["reflect_in"], xor_in=model["xor_in"], reflect_out=model["reflect_out"], xor_out=model["xor_out"]) error = False crc = expected_crc if self.use_algo_bit_by_bit: bbb_crc = alg.bit_by_bit(check_str) if crc is None: crc = bbb_crc error = error or bbb_crc != crc if self.use_algo_bit_by_bit_fast: bbf_crc = alg.bit_by_bit_fast(check_str) if crc is None: crc = bbf_crc error = error or bbf_crc != crc if self.use_algo_table_driven: tbl_crc = alg.table_driven(check_str) if crc is None: crc = tbl_crc error = error or tbl_crc != crc if error: print("error: different checksums!") if expected_crc is not None: print(" check: 0x%x" % expected_crc) if self.use_algo_bit_by_bit: print(" bit-by-bit: 0x%x" % bbb_crc) if self.use_algo_bit_by_bit_fast: print(" bit-by-bit-fast: 0x%x" % bbf_crc) if self.use_algo_table_driven: print(" table_driven: 0x%x" % tbl_crc) return None return crc
def check_string(opt): """ Return the calculated CRC sum of a string. """ error = False if opt.undefined_crc_parameters: sys.stderr.write("{0:s}: error: undefined parameters\n".format(sys.argv[0])) sys.exit(1) if opt.algorithm == 0: opt.algorithm = opt.algo_bit_by_bit | opt.algo_bit_by_bit_fast | opt.algo_table_driven alg = Crc( width=opt.width, poly=opt.poly, reflect_in=opt.reflect_in, xor_in=opt.xor_in, reflect_out=opt.reflect_out, xor_out=opt.xor_out, table_idx_width=opt.tbl_idx_width) crc = None if opt.algorithm & opt.algo_bit_by_bit: bbb_crc = alg.bit_by_bit(opt.check_string) if crc != None and bbb_crc != crc: error = True crc = bbb_crc if opt.algorithm & opt.algo_bit_by_bit_fast: bbf_crc = alg.bit_by_bit_fast(opt.check_string) if crc != None and bbf_crc != crc: error = True crc = bbf_crc if opt.algorithm & opt.algo_table_driven: # no point making the python implementation slower by using less than 8 bits as index. opt.tbl_idx_width = 8 tbl_crc = alg.table_driven(opt.check_string) if crc != None and tbl_crc != crc: error = True crc = tbl_crc if error: sys.stderr.write("{0:s}: error: different checksums!\n".format(sys.argv[0])) if opt.algorithm & opt.algo_bit_by_bit: sys.stderr.write(" bit-by-bit: {0:#x}\n".format(bbb_crc)) if opt.algorithm & opt.algo_bit_by_bit_fast: sys.stderr.write(" bit-by-bit-fast: {0:#x}\n".format(bbf_crc)) if opt.algorithm & opt.algo_table_driven: sys.stderr.write(" table_driven: {0:#x}\n".format(tbl_crc)) sys.exit(1) return crc
def __get_crc(self, model, check_str = "123456789", expected_crc = None): """ Get the CRC for a set of parameters from the Python reference implementation. """ if self.verbose: out_str = "Crc(width = %(width)d, poly = 0x%(poly)x, reflect_in = %(reflect_in)s, xor_in = 0x%(xor_in)x, reflect_out = %(reflect_out)s, xor_out = 0x%(xor_out)x)" % model if expected_crc is not None: out_str += " [check = 0x%x]" % expected_crc print(out_str) alg = Crc(width = model["width"], poly = model["poly"], reflect_in = model["reflect_in"], xor_in = model["xor_in"], reflect_out = model["reflect_out"], xor_out = model["xor_out"]) error = False crc = expected_crc if self.use_algo_bit_by_bit: bbb_crc = alg.bit_by_bit(check_str) if crc is None: crc = bbb_crc error = error or bbb_crc != crc if self.use_algo_bit_by_bit_fast: bbf_crc = alg.bit_by_bit_fast(check_str) if crc is None: crc = bbf_crc error = error or bbf_crc != crc if self.use_algo_table_driven: tbl_crc = alg.table_driven(check_str) if crc is None: crc = tbl_crc error = error or tbl_crc != crc if error: print("error: different checksums!") if expected_crc is not None: print(" check: 0x%x" % expected_crc) if self.use_algo_bit_by_bit: print(" bit-by-bit: 0x%x" % bbb_crc) if self.use_algo_bit_by_bit_fast: print(" bit-by-bit-fast: 0x%x" % bbf_crc) if self.use_algo_table_driven: print(" table_driven: 0x%x" % tbl_crc) return None return crc
def __get_crc(self, model, check_str = '123456789', expected_crc = None): """ Get the CRC for a set of parameters from the Python reference implementation. """ if self.verbose: out_str = 'Crc(width = {width:d}, poly = {poly:#x}, reflect_in = {reflect_in}, xor_in = {xor_in:#x}, reflect_out = {reflect_out}, xor_out = {xor_out:#x})'.format(**model) if expected_crc is not None: out_str += ' [check = {0:#x}]'.format(expected_crc) print(out_str) alg = Crc(width = model['width'], poly = model['poly'], reflect_in = model['reflect_in'], xor_in = model['xor_in'], reflect_out = model['reflect_out'], xor_out = model['xor_out']) error = False crc = expected_crc if self.use_algo_bit_by_bit: bbb_crc = alg.bit_by_bit(check_str) if crc is None: crc = bbb_crc error = error or bbb_crc != crc if self.use_algo_bit_by_bit_fast: bbf_crc = alg.bit_by_bit_fast(check_str) if crc is None: crc = bbf_crc error = error or bbf_crc != crc if self.use_algo_table_driven: tbl_crc = alg.table_driven(check_str) if crc is None: crc = tbl_crc error = error or tbl_crc != crc if error: print('error: different checksums!') if expected_crc is not None: print(' check: {0:#x}'.format(expected_crc)) if self.use_algo_bit_by_bit: print(' bit-by-bit: {0:#x}'.format(bbb_crc)) if self.use_algo_bit_by_bit_fast: print(' bit-by-bit-fast: {0:#x}'.format(bbf_crc)) if self.use_algo_table_driven: print(' table_driven: {0:#x}'.format(tbl_crc)) return None return crc
class mfm_track: # ------------------------------------------------------------------- def __init__(self, fname): print "Loading track image: %s..." % fname f = open(fname, "r") self.data = bytearray(f.read()) f.close() self.samples = [] self.gaps = [] self.gap_hist = {} self.clock = [] self.a1 = [] self.a1_mark = [0, 1, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 1, 0, 0, 1] self.a1_buf = [] self.a1_clk = [] self.a1_pos = 0 self.crc = Crc(width = 16, poly = 0x1021, reflect_in = False, xor_in = 0xffff, reflect_out = False, xor_out = 0x0000); #self.crc = Crc(width = 16, poly = 0x140a0445, reflect_in = False, xor_in = 0xffffffff, reflect_out = False, xor_out = 0x0000); print "Unpacking..." self.explode() # ------------------------------------------------------------------- def explode(self): for byte in self.data: for bit in [7, 6, 5, 4, 3, 2, 1, 0]: v = (byte >> bit) & 1 # [value, clock, a1, cell, validdbit, bit, validbyte, byte, crcok] self.samples.append([v, 0, 0, 0, 0, 0, 0, 0, 0]) # ------------------------------------------------------------------- def clock_regen(self, clock_period, early_clock_margin, clock_offset=0): counter = 0 ov = 1 next_clock = 0 while counter < len(self.samples): v = self.samples[counter][0] self.samples[counter] = [v, 0, 0, 0, 0, 0, 0, 0, 0] # each rising edge restarts clock if (ov == 0) and (v == 1): # clock cleanup - remove previously inserted early clock ticks if early_clock_margin and not clock_offset: prev_clock_tick = self.clock[len(self.clock)-1] if counter - prev_clock_tick <= early_clock_margin: self.clock.pop() self.samples[prev_clock_tick][1] = 0 if not clock_offset: next_clock = counter + clock_period self.clock.append(counter) self.samples[counter][1] = 1 else: next_clock = counter + clock_offset # is it time for next clock tick? if counter >= next_clock: self.samples[counter][1] = 1 self.clock.append(counter) next_clock = counter + clock_period ov = v counter += 1 # ------------------------------------------------------------------- def a1_match(self, clock): bit = self.samples[clock][0] self.a1_buf.append(bit) self.a1_clk.append(clock) if len(self.a1_buf) == 16: if self.a1_buf == self.a1_mark: clk = self.a1_clk[0] self.a1_buf = [] self.a1_clk = [] return clk else: self.a1_buf.pop(0) self.a1_clk.pop(0) return 0 # ------------------------------------------------------------------- def a1_search(self): clk = 0 while clk < len(self.clock): a1beg = self.a1_match(self.clock[clk]) if a1beg: self.a1.append(clk) self.samples[a1beg][2] = 1 self.samples[self.clock[clk+1]][2] = 2 clk += 1 # ------------------------------------------------------------------- def calc_gaps(self): ls = 0 pos = opos = 0 for (s,c,a1,cell,valbit,bit,valbyte,byte,crcok) in self.samples: if (s != ls) and (s == 1): diff = pos-opos self.gaps.append(diff) if (self.gap_hist.has_key(diff)): self.gap_hist[diff] += 1 else: self.gap_hist[diff] = 1 opos = pos pos += 1 ls = s # ------------------------------------------------------------------- def read_bytes(self, clkpos, b): bit = 7 char = 0 data = [ 0xa1 ] cellmark = 1 crcok = False crc = 0 while b > 0: # prepare 0, +1 and +2 clocks clk0 = self.clock[clkpos] clk1 = self.clock[clkpos+1] clk2 = self.clock[clkpos+2] # mark cell start self.samples[clk0][3] = cellmark cellmark *= -1 # mark bit end self.samples[clk2][4] = 1 self.samples[clk2][5] = self.samples[clk1][0] # shift bit value into the byte char |= self.samples[clk1][0] << bit bit -= 1 if bit < 0: # append only data, not CRC if b > 2: data.append(char) elif b == 2: crc = self.crc.table_driven(''.join([chr(x) for x in data])) print "%x" % crc if char == (crc & 0xff00) >> 8: self.samples[clk2][8] = 1 crcok = True else: self.samples[clk2][8] = 2 crcok = False elif b == 1: if char == crc & 0xff: self.samples[clk2][8] = 1 crcok &= True else: self.samples[clk2][8] = 2 crcok = False # mark and store byte self.samples[clk2][6] = 1 self.samples[clk2][7] = char bit = 7 b -= 1 char = 0 clkpos += 2 self.samples[clk2][3] = 2 return data, crcok # ------------------------------------------------------------------- def analyze(self, clock, margin, offset): self.gaps = [] self.gap_hist = {} self.clock = [] self.a1 = [] print "Regenerating clock..." self.clock_regen(clock, margin, offset) print "Analyzing signal gaps..." self.calc_gaps() print "Looking for sector header/data marks..." self.a1_search() print "%i A1 marks found." % len(self.a1) print "Analyzing sectors..." count = 0 while count < len(self.a1): try: data, crcok = self.read_bytes(self.a1[count]+1, 6) print ''.join([chr(x) for x in data]) print "---- CRC: %s --------------------------------------------------------" % str(crcok) except Exception, e: print str(e) pass count += 1 try: data, crcok = self.read_bytes(self.a1[count]+1, 512 + 3) print ''.join([chr(x) for x in data]) print "---- CRC: %s --------------------------------------------------------" % str(crcok) except Exception, e: print str(e) pass count += 1