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)
