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)
