def huffmanencodefile(filename): """ Read and Encode a File using Huffman Codes""" counts = getfilecharactercounts(filename) #get the counts from the file huffmantree = createhuffmantree(counts) #create and encode the characters codehuffmantree(huffmantree,bitstring.BitString()) codelist = [None]*256 listhuffmancodes(huffmantree, codelist) #get the codes for each character for i in range(0,256): if codelist[i] != None: print("character ", chr(i), " maps to code ", codelist[i].bin) #encode the file with open(filename, 'rb') as f: filecode = bitstring.BitString() while True: c = f.read(1) index = int.from_bytes(c, sys.byteorder) if c: filecode.append(codelist[index]) else: break #eof #write the file with open(filename + ".huf", 'wb') as coded_file:
def shift_in_and_out_sequence_until(match): MAX_DEPTH = 1024 log(" shifting until: %s" % match.hex) rx = bitstring.BitString(length=0) i = 0 while True: pin_low(CLK) #assuming MSB first set_pin(MOSI, match[i % match.len]) sleep(DELAY) pin_high(CLK) sleep(DELAY) rx.append(bitstring.BitString(bin='%d' % get_pin(MISO))) if rx.endswith(match): break i = i + 1 if i > MAX_DEPTH: break pin_low(CLK) if rx.len % 4 == 0: display = rx.hex else: display = rx.bin log(" received: %s" % display) return rx
def go(self): tx = "%s\n" % bitstring.BitString(self.input).hex self.conn.send(tx.encode('utf-8')) rx = self.conn.recv(32 + 1) rx = rx[0:32] self.output = bytearray(bitstring.BitString(hex=rx).tobytes()) return
def test_packet_binary(self): packet_bits_1 = bitstring.BitString(packet_string_1) packet = Packet(packet_bits_1) self.assertEqual(packet.to_binary().hex, packet_test_string_1) packet_bits_2 = bitstring.BitString(packet_string_2) packet = Packet(packet_bits_2) self.assertEqual(packet.to_binary().hex, packet_test_string_2)
def padding(x): l = len(x) bit = bs.BitString(bin = '0b1') x.append(bit) k1 = bs.BitString(uint = 0, length = (448 - len(x)) % 512) x.append(k1) k2 = bs.BitString(uint = l, length = 64) x.append(k2) return x
def make_bit_string(top_unigrams, list, filename): bit_string = bitstring.BitString() for top_unigram in top_unigrams: if list.count(top_unigram) > 0: bit_string += bitstring.BitString('0b1') else: bit_string += bitstring.BitString('0b0') f = open(filename, 'w') f.write(bit_string.bin.format()) f.close()
def test_packet_init(self): packet_bits_1 = bitstring.BitString(packet_string_1) packet = Packet(packet_bits_1) self.assertEqual(packet.DID, packet_test_dict["DID"]) self.assertEqual(packet.SDID, packet_test_dict["SDID"]) self.assertEqual(packet.word_count, packet_test_dict["Data Count"]) self.assertEqual(packet.UDW, packet_test_dict["UDW"]) packet_bits_2 = bitstring.BitString(packet_string_2) packet = Packet(packet_bits_2) self.assertEqual(packet.to_binary().hex, packet_test_string_2) self.assertIsInstance(packet.UDW, SpliceEvent)
def runTest(self): self.assertEquals(self.DAC.getConfigCode(), bitstring.BitString('0xC')) # Starts at 0 self.assertEqual(self.DAC.getCtrlValue(), bitstring.BitString('0x0000')) # Test Upper Limit self.DAC.voltage = 9.9999 self.assertEquals(self.DAC.getCtrlValue(), bitstring.BitString('0x7FFF')) self.DAC.voltage = 10.0000 self.assertEquals(self.DAC.getCtrlValue(), bitstring.BitString('0x7FFF')) self.DAC.voltage = 10.1 self.assertEquals(self.DAC.getCtrlValue(), bitstring.BitString('0x7FFF')) # Test Lower Limit self.DAC.voltage = -9.9999 self.assertEquals(self.DAC.getCtrlValue(), bitstring.BitString('0x8001')) self.DAC.voltage = -10.000 self.assertEquals(self.DAC.getCtrlValue(), bitstring.BitString('0x8001')) self.DAC.voltage = -10.1 self.assertEquals(self.DAC.getCtrlValue(), bitstring.BitString('0x8001')) self.assertEquals(self.DAC.getCtrlValue().unpack('int:16')[0], -32767)
def header(ver, prevh, merkle, time, bit, non): version = bs.BitString(ver) version = bs.BitString(uint=version.uintle, length=32) prevhash = bs.BitString(prevh) version.append(bs.BitString(uint=prevhash.uintle, length=256)) merkle_root = bs.BitString(merkle) version.append(bs.BitString(uint=merkle_root.uintle, length=256)) time_bit = bs.BitString(uint=time, length=32) version.append(bs.BitString(uint=time_bit.uintle, length=32)) bits = bs.BitString(uint=bit, length=32) version.append(hex(bits.uintle)) nonce = bs.BitString(uint=non, length=32) version.append(hex(nonce.uintle)) return version
def loadHostPopulation(FILE): '''Takes the file with the Host population HostGenomesFile.XXXX.csv and picks unique genes from it. Produces two lists: one containing ancestry of each gene (tags of all predecessors) and the second, corresponding containing times when each mutation arose in the genes time line.''' B_list = [] Mut_tags = [] Mut_times = [] try: with open(FILE) as infile: for line in infile: if re.search(r"#", line): continue elif re.search(r"===", line): continue else: LL = line.split() bb = bts.BitString(bin=LL[0]).int if bb in B_list: pass else: # print(LL[5::2]) B_list.append(bb) tagz = LL[5::2] tagz.append(LL[3]) Mut_tags.append(tagz) timez = LL[4::2] timez.append(LL[2]) Mut_times.append(timez) return Mut_tags, Mut_times except IOError as e: print("I/O error({0}) in".format(e.errno) + " loadTheHostPopulation(): {0}".format(e.strerror))
def main(): print('Python version {}.{}.{}'.format(*sys.version_info)) print(sys.platform) print() import os print(os.name) print(os.getenv('PATH')) print(os.getcwd()) # import urllib.request # page = urllib.request.urlopen('http://app.collectriumdev.com') # for line in page: # print(str(line, encoding='utf_8'), end='') # print() import datetime now = datetime.datetime.now() print(now) print(now.year, now.month, now.day) print() # run `pip3 install bitstring` in cmd import bitstring a = bitstring.BitString(bin='01010101') print(a.hex, a.bin, a.uint) import time, SayTime t = time.localtime() print("Content-type: text/html\n") print( "In Phoenix, Arizona, it is now " + SayTime.SayTimeT(t).words() + time.strftime(', on %A, %d %B %Y.') )
def byte_out(self): T = np.right_shift(self.C, 19) if T > 0xFF: self.B += 1 self.stuff_0() self.output_stacked_zeros() self.BP += 1 self.B = T self.Bx = True if not T == 0xFF: self.output_stacked_xffs() self.BP += 1 self.B = T # Not according to Standard if self.B != 0 and not self.Bx: self.out.append(hex(self.B)) if self.B != 0 and self.Bx: last_entry = int(self.out[-8:].bin, 2) self.out = self.out[:-8] self.out.append(hex(last_entry + 1)) self.out.append(bs.BitString(uint=0, length=8)) self.Bx = False else: self.ST += 1 self.C = np.bitwise_and(self.C, 0x7FFFF)
def h0(): n = 8 h = prime_seq(n) h_0 = bs.BitString('') for i in range(0, n): h_0.append(hex8(h[i], 2)) return h_0
def __reassembly(self): sar = None type = None packet = b'' segment = yield while True: try: sar, type, segment = bitstring.BitString(segment).unpack( SarProcessor.PDU_FORMAT) sar = SarFlag(sar) type = ProxyPDUType(type) except ValueError: segment = yield continue if sar == SarFlag.COMPLETE: segment = yield segment, type elif sar == SarFlag.FIRST: packet = segment segment = yield elif sar == SarFlag.CONTINUATION: packet += segment segment = yield elif sar == SarFlag.LAST: packet += segment segment = yield packet, type else: segment = yield
def main(): print('Python version {}.{}.{}'.format(*sys.version_info)) print('sys.platform {}'.format(sys.platform)) # can import within a function import os print('os.name {}'.format(os.name)) print("os.getenv('PATH') {}".format(os.getenv('PATH'))) print("os.getcwd() {}".format(os.getcwd())) # urandom(n) returns n random bytes print("os.urandom(25) {}".format(os.urandom(25))) page = urllib.request.urlopen('http://bw.org/') for line in page: # print(str(line, encoding = 'utf_8'), end = '') pass print(random.randint(1, 1000)) x = list(range(25)) print('x {}'.format(x)) random.shuffle(x) print('shuffle(x) {}'.format(x)) now = datetime.datetime.now() print(now) print(now.year, now.month, now.day, now.minute, now.second, now.microsecond) a = bitstring.BitString(bin = '01010101') # expected output 55 01010101 85 print(a.hex, a.bin, a.uint)
def loadHostPopulation(FILE): '''Takes the file with all the hosts data loads it to a list. Each individual is loaded as a list of bit strings.And the population is a list of individuals.''' LL = [] ll = [] nextHost = False try: with open(FILE) as infile: for line in infile: if re.search(r"#", line): continue elif re.search(r"===", line): if nextHost: LL.append(ll) ll = [] else: nextHost = True bitt = line.split()[0] ll.append(bts.BitString(bin=bitt).int) LL.append(np.array(ll, dtype=int)) # print j + 1 return LL except IOError as e: print("I/O error({0}) in".format(e.errno), "loadHostPopulation(): {0}".format(e.strerror))
def __init__(self, data, source): self.source = source packet = bitstring.BitString(data) packet_length = packet.len / 8 # Ensure packet is sufficiently long to attempt unpacking it if packet_length < MIN_PACKET_SIZE: raise IOError('Packet size below mininum correct value.') self.version, self.diag, self.state, self.poll, self.final, \ self.control_plane_independent, self.authentication_present,\ self.demand_mode, self.multipoint, self.detect_mult, self.length, \ self.my_discr, self.your_discr, self.desired_min_tx_interval, \ self.required_min_rx_interval, self.required_min_echo_rx_interval \ = packet.unpack(PACKET_FORMAT) log.debug(PACKET_DEBUG_MSG, self.version, self.diag, self.state, self.poll, self.final, self.control_plane_independent, self.authentication_present, self.demand_mode, self.multipoint, self.detect_mult, self.length, self.my_discr, self.your_discr, self.desired_min_tx_interval, self.required_min_rx_interval, self.required_min_echo_rx_interval) self.validate(packet_length)
def main(): print('Python version {}.{}.{}'.format(*sys.version_info)) print(sys.platform) # can import within function, i.e. do things one way or another depending on the platform import os print(os.name) print(os.getenv('PATH')) print(os.getcwd()) # current working dir import random print(random.randint(1, 1000)) # random num between 1-1000 x = list(range(25)) print(x) random.shuffle(x) print(x) import datetime now = datetime.datetime.now() print(now) print(now.year, now.month, now.day, now.hour, now.minute, now.second, now.microsecond) # THIRD-PARTY # read doc and source code, try out - don't reinvent wheel! import bitstring a = bitstring.BitString(bin='01010101') print(a.hex, a.bin, a.uint)
def bs_sum(*args): aux = 0 for arg in args: w = len(arg) aux += arg.uint aux = aux % (2**w) return bs.BitString(uint=aux, length=w)
def loadHostPopulation(FILE): '''Takes the file with all the hosts data and loads it to a list. Each individual is loaded as a list of bit strings. And the population is a list of individuals.''' B_list = [] Mut_list = [] try: with open(FILE) as infile: for line in infile: if re.search(r"#", line): continue elif re.search(r"===", line): continue else: LL = line.split() # bb = int(LL[3]) bb = bts.BitString(bin=LL[0]).int if bb in B_list: pass else: B_list.append(bb) Mut_list.append((len(LL) - 4) // 2) return np.array(Mut_list) except IOError as e: print("I/O error({0}) in".format(e.errno) + " loadTheHostPopulation(): {0}".format(e.strerror))
def to_binary(self): # self.values_dict["Line Number"] = 0x7FF # self.values_dict["Horizontal Offset"] = 0xFFF binary_str = "" udw_bin = "" if not isinstance(self.UDW, int): udw_bit_array = self.UDW.to_binary() udw_bit_array.prepend(self.payload_descriptor) udw_hex = udw_bit_array.hex self.word_count = int(len(udw_hex) / 2) udw_bin = convert_8_to_10_bit_words(udw_bit_array) else: udw_bin = int_to_bin(self.UDW, self.word_count * 10) c = self.values_dict["C"] line_num = self.values_dict["Line Number"] horiz_offset = self.values_dict["Horizontal Offset"] s = self.values_dict["S"] stream_num = self.values_dict["StreamNum"] checksum = self.values_dict["Checksum Word"] binary_str += int_to_bin(c, 1) binary_str += int_to_bin(line_num, 11) binary_str += int_to_bin(horiz_offset, 12) binary_str += int_to_bin(s, 1) binary_str += int_to_bin(stream_num, 7) did = int_to_bin(self.DID, 8) sdid = int_to_bin(self.SDID, 8) data_count = int_to_bin(self.word_count, 8) binary_str += convert_8_to_10_bit_words( bitstring.BitString(bin=did + sdid + data_count)) binary_str += udw_bin checksum_bin = int_to_bin(checksum, 9) checksum_parity = "0" if checksum_bin[0] == "0": checksum_parity = "1" binary_str += checksum_parity binary_str += checksum_bin word_align = 32 - ((self.word_count * 10 - 2 + 10) % 32) binary_str += '0' * int(word_align) return bitstring.BitString(bin=binary_str)
def unpack(cls, beacon): uuid, oob, uri_hash = bitstring.BitString(beacon).unpack( cls.BEACON_FORMAT) if uri_hash and len(uri_hash) != 4: raise ValueError("Wrong size of URI hash, expected 4 bytes") return cls(UUID(bytes=uuid), oob, uri_hash or None)
def decrypt(cls, ttl, src, dst, transport_pdu): seg, opcode = bitstring.BitString(transport_pdu).unpack( "uint:1, uint:7") # works only for unsegmented messages! if seg: raise NotImplementedError return ControlMessage(src, dst, ttl, opcode, transport_pdu[1:])
def unpack( cls, app_key: ApplicationKey, net_key: NetworkKey, local_iv_index: int, network_pdu: bytes, proxy=False, ): # pylint: disable=R0914 _nid, encryption_key, privacy_key = net_key.encryption_keys last_iv, nid, obfuscated_header, encoded_data_mic = bitstring.BitString( network_pdu).unpack("uint:1, uint:7, bytes:6, bytes") if nid != _nid: raise KeyError iv_index = (local_iv_index if (local_iv_index & 0x01) == last_iv else local_iv_index - 1) privacy_random = bitstring.pack("pad:40, uintbe:32, bytes:7", iv_index, encoded_data_mic[:7]).bytes pecb = aes_ecb(privacy_key, privacy_random)[:6] deobfuscated = bytes(map(operator.xor, obfuscated_header, pecb)) ctl, ttl, seq, src = bitstring.BitString(deobfuscated).unpack( "uint:1, uint:7, uintbe:24, uintbe:16") net_mic_len = 8 if ctl else 4 nonce = (Nonce(src, 0, ttl, ctl).proxy if proxy else Nonce( src, 0, ttl, ctl).network)(seq, iv_index) decrypted_net = aes_ccm_decrypt(encryption_key, nonce, encoded_data_mic, tag_length=net_mic_len) dst, transport_pdu = bitstring.BitString(decrypted_net).unpack( "uintbe:16, bytes") if proxy: transport_msg = ProxyConfigMessage.decrypt(src, transport_pdu) elif ctl: transport_msg = ControlMessage.decrypt(ttl, src, dst, transport_pdu) else: transport_msg = AccessMessage.decrypt(app_key, iv_index, ctl, ttl, seq, src, dst, transport_pdu) net_message = NetworkMessage(transport_msg) return iv_index, seq, net_message
def unpack(cls, message): beacon, auth = message[:-cls.BEACON_AUTH_SIZE], message[ -cls.BEACON_AUTH_SIZE:] iv_update, key_refresh, network_id, iv_index = \ bitstring.BitString(beacon).unpack(cls.BEACON_FORMAT) return cls(bool(key_refresh), bool(iv_update), iv_index, network_id), auth
def k4(N): SALT = s1(b"smk4") T = aes_cmac(SALT, N) k = aes_cmac(T, b"id6\x01")[-1:] (aid, ) = bitstring.BitString(k).unpack("pad:2, uint:6") return aid
def k4(N): SALT = s1(b'smk4') T = aes_cmac(SALT, N) k = aes_cmac(T, b'id6\x01')[-1:] aid, = bitstring.BitString(k).unpack('pad:2, uint:6') return aid
def output_stacked_xffs(self): while self.ST != 0: self.BP += 1 self.B = 0xFF self.out.append(hex(self.B)) self.BP += 1 self.B = 0 self.out.append(bs.BitString(uint=0, length=8)) self.ST -= 1
def clock_in_clock_out(first_input_sequence, second_input_sequence, inter_frame_action, unexpected_output_action, serial_handler): enable_shift() output_sequence = bytearray() for i in range(0, int(512 / 8)): rx = shift_in_and_out_byte(first_input_sequence.tobytes()[i]) output_sequence.append(rx) line = get_any_serial() if not line == '': if serial_handler(line): log("FAIL: serial message on test-sequence:") print_a_sequence(first_input_sequence.tobytes()) log("") return None disable_shift() if unexpected_output_action(output_sequence): log("FAIL: unexpected output:") print_a_sequence(output_sequence) log("") inter_frame_action() line = get_any_serial() if not line == '': if serial_handler(line): log("FAIL: serial message on test-sequence:") print_a_sequence(first_input_sequence.tobytes()) log("\n") return None enable_shift() output_sequence = bytearray() for i in range(0, int(512 / 8)): rx = shift_in_and_out_byte(second_input_sequence.tobytes()[i]) output_sequence.append(rx) line = get_any_serial() if not line == '': if serial_handler(line): log("FAIL: serial message. first input sequence:") print_a_sequence(first_input_sequence.tobytes()) log("") return None disable_shift() if unexpected_output_action(output_sequence): log("FAIL: unexpected output:") print_a_sequence(output_sequence) log("") return bitstring.BitString(output_sequence)
def _ReadSector(self, track, sector): offset = track * TRACK_SIZE + sector * SECTOR_SIZE if sector >= SECTORS_PER_TRACK or offset > len(self.data): raise IOError("Track $%02x sector $%02x out of bounds" % (track, sector)) data = bitstring.BitString(self.data[offset:offset + SECTOR_SIZE]) # This calls SetSectorOwner to register in self.sectors return Sector(self, track, sector, data)