def buildcustomrandomdata(orderedrandomlist, lengthin, digits=8): if digits == 8: random4 = '' for x in range(0, lengthin): random4 += str(orderedrandomlist[random.randint(0, 7)]) ssxwrite = open('orighex_eight.bin', 'wb') BitString(hex=random4).tofile(ssxwrite) ssxwrite.close() with zipfile.ZipFile('orighex_eight.zip', 'w', zipfile.ZIP_DEFLATED) as myzip: myzip.write('orighex_eight.bin') return random4 elif digits == 4: random4 = '' for x in range(0, lengthin): random4 += str(orderedrandomlist[random.randint(0, 3)]) ssxwrite = open('orighex.bin', 'wb') BitString(hex=random4).tofile(ssxwrite) ssxwrite.close() with zipfile.ZipFile('orighex.zip', 'w', zipfile.ZIP_DEFLATED) as myzip: myzip.write('orighex.bin') return random4
def __init__(self, parent, param, skip_read=False): self.parent = parent self.name = param.name self.alias = param.alias self.id = param.id self.rd_addr = param.rd_addr self.wr_addr = param.wr_addr self.write_disable_bit = param.write_disable_bit self.read_disable_bit = param.read_disable_bit self.len = param.len self.key_purpose_name = param.key_purpose bit_block_len = self.get_block_len() * 8 self.bitarray = BitString(bit_block_len) self.bitarray.set(0) self.wr_bitarray = BitString(bit_block_len) self.wr_bitarray.set(0) self.fail = False self.num_errors = 0 if self.id == 0: self.err_bitarray = BitString(bit_block_len) self.err_bitarray.set(0) else: self.err_bitarray = None if not skip_read: self.read()
def tobits(n, nbits=8, signed=False): # convert the integer n to a bit string of n bits # if signed then the returned value is 2's comp if not signed: return BitString(uint=n, length=nbits).bin else: return BitString(int=n, length=nbits).bin
def check_data_block_in_log(self, log, file_path, repeat=1, reverse_order=False, offset=0): with open(file_path, 'rb') as f: data = BitString('0x00') * offset + BitString(f) blk = data.readlist("%d*uint:8" % (data.len // 8)) blk = blk[::-1] if reverse_order else blk hex_blk = " ".join("{:02x}".format(num) for num in blk) self.assertEqual(repeat, log.count(hex_blk))
def __init__(self, efuse_file=None, debug=False): self.debug = debug self.efuse_file = efuse_file if self.efuse_file: try: self.mem = BitString(open(self.efuse_file, 'a+b'), length=(self.REGS.EFUSE_MEM_SIZE & self.REGS.EFUSE_ADDR_MASK) * 8) except ValueError: # the file is empty or does not fit the length. self.mem = BitString(length=(self.REGS.EFUSE_MEM_SIZE & self.REGS.EFUSE_ADDR_MASK) * 8) self.mem.set(0) self.mem.tofile(open(self.efuse_file, 'a+b')) else: # efuse_file is not provided it means we do not want to keep the result of efuse operations self.mem = BitString((self.REGS.EFUSE_MEM_SIZE & self.REGS.EFUSE_ADDR_MASK) * 8) self.mem.set(0)
def parse(self,data): totalbits = len(data)*8 b = BitString(bytes=data) self.sizelen = b.read('uint:5') if self.sizelen>0: self.xmin = b.read('uint:%d'%self.sizelen) self.xmax = b.read('uint:%d'%self.sizelen) self.ymin = b.read('uint:%d'%self.sizelen) self.ymax = b.read('uint:%d'%self.sizelen) taillen = (self.sizelen*4+5)%8 != 0 and 8-(self.sizelen*4+5)%8 or 0 else: self.xmin=self.xmax=self.ymin=self.ymax=0 taillen = 3 b.read('uint:%d'%taillen) self.framerate = b.read('uint:16') self.framecount = b.read('uintle:16') #print self.sizelen,self.xmin,self.xmax,self.ymin,self.ymax #print self.framerate,self.framecount while b.pos<totalbits: tagcl = b.read('uintle:16') tagcode = (tagcl>>6) taglen = tagcl&0x3f if taglen == 0x3f: taglen = b.read('intle:32') tagdata = b.read('bytes:%d'%taglen) self.tags.append( [tagcode,tagdata] )
def encode_datalist(x): return (NEXT_ELEMENT.join( MORE_BYTES.join( BitString(bytes=byte) for byte in data) for data in x) .tobytes()) # zero-pads if needed
def __init__(self, parent, name, category, block, word, pos, efuse_type, write_disable_bit, read_disable_bit, efuse_class, description, dict_value): self.category = category self.parent = parent self.block = block self.word = word self.pos = pos self.write_disable_bit = write_disable_bit self.read_disable_bit = read_disable_bit self.name = name self.efuse_class = efuse_class self.efuse_type = efuse_type self.description = description self.dict_value = dict_value if self.efuse_type.startswith("bool"): field_len = 1 else: field_len = int(re.search(r'\d+', self.efuse_type).group()) if self.efuse_type.startswith("bytes"): field_len *= 8 self.bitarray = BitString(field_len) self.bit_len = field_len self.bitarray.set(0) self.update(self.parent.blocks[self.block].bitarray)
def encode(self, message): output = [] main_dictionary = {} for i in range(256): main_dictionary[chr(i)] = i string = message[0] curr_index = 0 l = len(message) while curr_index < l - 1: symbol = message[curr_index + 1] if string + symbol in main_dictionary: string += symbol else: output.append(main_dictionary[string]) max_key = max(main_dictionary, key=main_dictionary.get) max_val = main_dictionary[max_key] if max_val == 2**16 - 1: main_dictionary = {} for i in range(256): main_dictionary[chr(i)] = i #main_dictionary[string+symbol]=0 else: main_dictionary[string + symbol] = max_val + 1 string = symbol curr_index += 1 output.append(main_dictionary[string]) bits = BitString() bits.pack_numbers(output, 16) return bits
def check_rd_protection_area(self): # checks fields which have the read protection bits. # if the read protection bit is set then we need to reset this field to 0. def get_read_disable_mask(blk): mask = 0 if isinstance(blk.read_disable_bit, list): for i in blk.read_disable_bit: mask |= (1 << i) else: mask = (1 << blk.read_disable_bit) return mask read_disable_bit = self.read_field("RD_DIS", bitstring=False) for b in self.Blocks.BLOCKS: blk = self.Blocks.get(b) block = self.read_block(blk.id) if blk.read_disable_bit is not None and read_disable_bit & get_read_disable_mask(blk): if isinstance(blk.read_disable_bit, list): if read_disable_bit & (1 << blk.read_disable_bit[0]): block.set(0, [i for i in range(blk.len * 32 // 2, blk.len * 32)]) if read_disable_bit & (1 << blk.read_disable_bit[1]): block.set(0, [i for i in range(0, blk.len * 32 // 2)]) else: block.set(0) else: for e in self.Fields.EFUSES: field = self.Fields.get(e) if blk.id == field.block and field.read_disable_bit is not None and read_disable_bit & get_read_disable_mask(field): raw_data = self.read_field(field.name) raw_data.set(0) block.pos = block.length - (field.word * 32 + field.pos + raw_data.length) block.overwrite(BitString(raw_data.length)) self.overwrite_mem_from_block(blk, block)
def fFunction(k, R): R_expanded = permute(R, E) R_xor_k = R_expanded ^ k pieces6b = list(splitToN(R_xor_k, 8)) pieces4b = map(substitute, pieces6b, S) R_after_S = BitString('').join(pieces4b) return permute(R_after_S, P)
def get_correct_answer(bitstring: list, control_bits: int) -> int: bits = BitString(bitstring) _ctrl_bits = bits[:control_bits] _data_bits = bits[control_bits:] return int(_data_bits[_ctrl_bits.uint])
def subrank3(adj): """ subrank2 takes an adjacency dictionary in (nid, pids) format and returns a dictionary mapping nids to their SubRank. subrank3 uses BitStrings and the Warshall algorithm, so it is the most scalable python SubRank yet! """ # Map adj to a reversed bitstring adjacency matrix, for speed. matrixmap = {} A = [] for nid in adj: matrixmap[nid] = len(A) A.append(BitString(uint=0, length=len(adj))) for cid in adj: for pid in adj[cid]: A[matrixmap[pid]][matrixmap[cid]] = 1 # Compute SubRank. progress = ProgressBar('Computing SubRank') T = A for j in xrange(len(adj)): progress.next() for i in xrange(len(adj)): if T[i][j]: T[i] = T[i] | T[j] sys.stdout.write(' done.\n') sys.stdout.flush() return dict([(nid, float(sum(T[matrixmap[nid]]) + 1) / len(adj)) for nid in adj])
def __init__(self, parent, param): self.category = param.category self.parent = parent self.block = param.block self.word = param.word self.pos = param.pos self.write_disable_bit = param.write_disable_bit self.read_disable_bit = param.read_disable_bit self.name = param.name self.efuse_class = param.class_type self.efuse_type = param.type self.description = param.description self.dict_value = param.dictionary self.fail = False self.num_errors = 0 if self.efuse_type.startswith("bool"): field_len = 1 else: field_len = int(re.search(r"\d+", self.efuse_type).group()) if self.efuse_type.startswith("bytes"): field_len *= 8 self.bitarray = BitString(field_len) self.bit_len = field_len self.bitarray.set(0) self.update(self.parent.blocks[self.block].bitarray)
def check_rd_protection_area(self): # checks fields which have the read protection bits. # if the read protection bit is set then we need to reset this field to 0. read_disable_bit = self.read_field("RD_DIS", bitstring=False) for b in self.Blocks.BLOCKS: blk = self.Blocks.get(b) block = self.read_block(blk.id) if blk.read_disable_bit is not None and read_disable_bit & ( 1 << blk.read_disable_bit ): block.set(0) else: for e in self.Fields.EFUSES: field = self.Fields.get(e) if ( blk.id == field.block and field.read_disable_bit is not None and read_disable_bit & (1 << field.read_disable_bit) ): raw_data = self.read_field(field.name) raw_data.set(0) block.pos = block.length - ( field.word * 32 + field.pos + raw_data.length ) block.overwrite(BitString(raw_data.length)) self.overwrite_mem_from_block(blk, block)
def encode(self, message): #initializing Table[0 to 255] to corresponding ASCII charaters Table = initialize(encode=True) #initializing table index and P index = 256 counter = 0 output = [] P = '' #LZW compression algorithm while counter != len(message) + 1: try: C = message[counter] except IndexError: # for the last iteration, C is empty so just return P and exit output.append(Table[P]) break if P + C in Table: P = P + C else: output.append(Table[P]) Table[P + C] = index index += 1 P = C counter += 1 #if the dictionary outgrew the word_size, re_initialize the dictionary if index > 2**self.word_size: Table = initialize(encode=True) index = 256 packed_output = BitString() packed_output.pack_numbers(output, self.word_size) return packed_output
def __init__(self, bitstring_or_filename, **kwargs): "Takes either a filename or a BitString object. Optional: flowcell_layout {}, read_config [{},]" self.flowcell_layout = kwargs.get('flowcell_layout', FLOWCELL_LAYOUT_DEFAULTS) self.read_config = kwargs.get('read_config', READ_CONFIG_DEFAULTS) # see if it's a filename or a bitstring (aka bitstream) try: bitstring_or_filename.all( 1) # attempts to perform the "are these bits all 1s" method self.bs = bitstring_or_filename except AttributeError: # assume it's a filename, then. self.bs = BitString(bytes=open(bitstring_or_filename, 'rb').read()) self.num_tiles = reduce(lambda x, y: x * y, self.flowcell_layout.values()) self.num_reads = len(self.read_config) self._init_variables() if self.bs is None: raise Exception("bitstring empty; cannot parse metrics for %s" % self.__class__.__name__) else: self.parse_binary()
def check_wr_protection_area(self, num_blk, wr_data): # checks fields which have the write protection bit. # if the write protection bit is set, we need to protect that area from changes. write_disable_bit = self.read_field("WR_DIS", bitstring=False) mask_wr_data = BitString(len(wr_data)) mask_wr_data.set(0) blk = self.Blocks.get(self.Blocks.BLOCKS[num_blk]) if blk.write_disable_bit is not None and write_disable_bit & ( 1 << blk.write_disable_bit ): mask_wr_data.set(1) else: for e in self.Fields.EFUSES: field = self.Fields.get(e) if blk.id == field.block and field.block == num_blk: if field.write_disable_bit is not None and write_disable_bit & ( 1 << field.write_disable_bit ): data = self.read_field(field.name) data.set(1) mask_wr_data.pos = mask_wr_data.length - ( field.word * 32 + field.pos + data.len ) mask_wr_data.overwrite(data) mask_wr_data.invert() return wr_data & mask_wr_data
def byte_isMore_tuples(x): numBits = len(x) * 8 bs = BitString(bytes=x) pos = 0 while numBits - pos >= 8: yield ( bs[pos:pos + 8].bytes, bs[pos + 8] if (numBits - pos >= 9) else False) pos += 9
def __init__(self, parent, param, skip_read=False): self.parent = parent self.name = param[0] self.alias = param[1] self.id = param[2] self.rd_addr = param[3] self.wr_addr = param[4] self.write_disable_bit = param[5] self.read_disable_bit = param[6] self.len = param[7] self.key_purpose_name = param[8] bit_block_len = self.get_block_len() * 8 self.bitarray = BitString(bit_block_len) self.bitarray.set(0) self.wr_bitarray = BitString(bit_block_len) self.wr_bitarray.set(0) if not skip_read: self.read()
def save(self, new_data): # new_data will be checked by check_wr_data() during burn_all() # new_data (bytes) = [0][1][2] ... [N] (original data) # in string format = [0] [1] [2] ... [N] (util.hexify(data, " ")) # in hex format = 0x[N]....[2][1][0] (from bitstring print(data)) # in reg format = [3][2][1][0] ... [N][][][] (as it will be in the device) # in bitstring = [N] ... [2][1][0] (to get a correct bitstring need to reverse new_data) # *[x] - means a byte. data = BitString(bytes=new_data[::-1], length=len(new_data) * 8) if self.parent.debug: print("\twritten : {} ->\n\tto write: {}".format(self.get_bitstring(), data)) self.wr_bitarray.overwrite(data, pos=0)
def decodeBitsChannel(self, name: str, key: str = ""): v = self.rootgrp.variables[name] vstr = chartostring(v[:]).tostring() vstr = vstr.decode("US-ASCII") # 1 is good, everything else is bad vstr = re.sub('[023456789]', '0', vstr) bits = BitString(bin="0b" + vstr) vmissing = v._FillValue self.channels[self.getKey(key, name)] = Channel( name, bits, vmissing, v) # add as a sequence of bits, which is more efficient pass
def get_swf(self): if not self.parsed: return '' b = BitString(bytes='') b.append('uint:5=%d'%self.sizelen) if self.sizelen>0: b.append('uint:%d=%d'%(self.sizelen,self.xmin)) b.append('uint:%d=%d'%(self.sizelen,self.xmax)) b.append('uint:%d=%d'%(self.sizelen,self.ymin)) b.append('uint:%d=%d'%(self.sizelen,self.ymax)) taillen = (self.sizelen*4+5)%8 != 0 and 8-(self.sizelen*4+5)%8 or 0 else: taillen = 3 b.append('uint:%d=0'%taillen) b.append('uint:16=%d'%self.framerate) b.append('uintle:16=%d'%self.framecount) for tagcode,tagdata in self.tags: taglen = len(tagdata) if taglen >= 0x3f: b.append('uintle:16=%d'%((tagcode<<6)|0x3f)) b.append('intle:32=%d'%len(tagdata)) else: b.append('uintle:16=%d'%((tagcode<<6)|taglen)) b.append(BitString(bytes=tagdata)) data = b.tobytes() self.filelength = len(data) if self.signature == 'CWS': data = zlib.compress(data) b = BitString(bytes='') b.append(BitString(bytes=self.signature)) b.append(BitString('uint:8=%d'%self.version)) b.append(BitString('uintle:32=%d'%self.filelength)) header = b.tobytes() return header + data
def clear(self, offset, length, bit_offset=None, bit_length=None): """ If a whole register, writes ones to the whole register If a bit field, writes a one to the specified bit with everything else being zero """ bs = BitString(length=length) if bit_offset is None: bs = ~bs else: # Slice addresses are backward, ex: msb is 0, lsb is 31 so bit_offset 32 is slice[0] (for 32 bit) for i in range(length - (bit_offset + bit_length), length - bit_offset): bs[i] = 1 self.write(bs.uint, offset, length)
def write(self, value, offset, length, bit_offset=None, bit_length=None): """ If a whole register, writes value to the whole register If a bit field, reads the register and mods only the specified bit then writes that new value back """ if bit_offset is None: data = BitString(uint=value, length=length) else: orig = self.read(offset, length) #print "orig int 0x%x" % (orig) orig = BitString(uint=orig, length=length) #print "orig bs %s" % (orig.bin) new = BitString(uint=value, length=bit_length) #print "new bs %s going in at offset %d" % (new.bin, bit_offset) # Slice addresses are in reverse order orig.overwrite(new, length - (bit_offset + bit_length)) #orig.overwrite(new, bit_offset) data = orig #print "%s %s" % (data.hex, data.bin) data = self.swap_le_be(data) self.config.seek(offset) self.config.write(data.bytes)
def hexToBase64(hexString): byte_string = bytes.fromhex(hexString) num_bytes = len(byte_string) ba = BitArray(byte_string) chunked_byte_string = chunk_list(ba, 6) s = [] for i in range(len(chunked_byte_string)): s.append(b64_map[BitString([int(i) for i in chunked_byte_string[i]]).uint]) encoded_wo_padding = ''.join(s) ret_val = encoded_wo_padding if (num_bytes % 3 != 0): for i in range(3 - (num_bytes % 3)): ret_val += ('=') return ret_val
def clear(self, config): off = self.base_offset + self.offset data = BitString(length=self.length) if self.bit_offset is None: data = ~data else: for i in range(self.bit_offset, self.bit_offset+self.bit_length): data[i] = 1 #print data.bin # file objects config.seek(off) config.write(data.bytes)
def burn_bit(esp, efuses, args): num_block = efuses.get_index_block_by_name(args.block) block = efuses.blocks[num_block] data_block = BitString(block.get_block_len() * 8) data_block.set(0) try: data_block.set(True, args.bit_number) except IndexError: raise esptool.FatalError("%s has bit_number in [0..%d]" % (args.block, data_block.len - 1)) data_block.reverse() print("bit_number: [%-03d]........................................................[0]" % (data_block.len - 1)) print("BLOCK%-2d :" % block.id, data_block) block.print_block(data_block, "regs_to_write", debug=True) block.save(data_block.bytes[::-1]) efuses.burn_all() print("Successful")
def __init__(self, bytes=None, bits=None): if bytes: if isinstance(bytes, str): io = StringIO(bytes) elif hasattr(bytes, 'read'): io = bytes else: raise TypeError, 'not readable object' first_byte = io.read(1) self.field_bits_length = ord(first_byte) >> 3 bytes = first_byte + io.read(len(self) - 1) self.bits = BitString(bytes=bytes) elif bits: self.bits = bits self.field_bits_length = self.bits[:5].uint
def extract_bufr_from_lrit_file(file_path, prefix, output_dir): """ read lrit file """ file_size = os.path.getsize(file_path) fp = open(file_path, "rb") bs = BitString(fp) cpt = 0 print("==== Looking for Bufrs in %s\n" % (file_path)) # look for BUFR in hex 0x42554652 f_val = bs.find('0x42554652', bytealigned=True) while f_val: begin = bs.pos print("** Found Bufr in pos %s\n" % (begin)) # read size bufr_value = bs.read(32).hex size = bs.read('uint:24') print("size in decimal = %s" % (size)) if size > file_size: print("Size read in bufr %d is bigger than the file size %d\n" % (size, file_size)) return #read all bits (end-begin)+1 bs.pos = begin read_bits = bs.read(size) dest_fp = open("%s/%s_bufr_%s.bufr" % (output_dir, prefix, cpt), "wb") dest_fp.write(read_bits.tobytes()) dest_fp.close() cpt += 1 #look for the next grib f_val = bs.find('0x42554652', start=bs.pos, bytealigned=True)