def decode_boot_sector(self, stream: bitstring.BitStream):
self.bpb = BiosParameterBlock()
jmp, oem = stream.readlist(['bytes:3', 'bytes:8'])
self.bpb.bytes_per_sector = stream.read('uintle:16')
self.bpb.sectors_per_cluster = stream.read('uintle:8')
self.bpb.reserved_sectors = stream.read('uintle:16')
self.bpb.fats_count = stream.read('uintle:8')
roots = stream.read('uintle:16')
sectors = stream.read('uintle:16')
self.bpb.media_descriptor = stream.read('bytes:1')
sec_per_fat = stream.read('uintle:16')
self.bpb.sec_per_track = stream.read('uintle:16')
self.bpb.heads = stream.read('uintle:16')
self.bpb.hidden_sectors = stream.read('uintle:32')
self.bpb.sectors = stream.read('uintle:32')
self.bpb.sec_per_fat = stream.read('uintle:32')
active_fat, _, fat_is_mirrored, _ = stream.readlist([4, 2, 1, 9])
fs_version = stream.read('uintle:16')
self.bpb.root_cluster = stream.read('uintle:32')
fs_info = stream.read('uintle:16')
backup_boot_sector = stream.read('uintle:16')
_, drive_num, _, boot_sig, volume_id, volume_label, fs_type = stream.readlist([
'bytes:12', 'uintle:8', 'bytes:1', 'uintle:8', 'uintle:32', 'bytes:11', 'bytes:8'
])
remaining_stuff = stream.read('bytes:' + str(self.bpb.bytes_per_sector - stream.bytepos))
self.skip_sectors(stream, n=self.bpb.reserved_sectors - 1)
def unformat_message(text:BitStream)->bytes :
"""Raises ValueError if the message has been tampered with."""
try :
sha, len = text.readlist("bytes:64, ue")
message = text.read(f"bytes:{len}")
except ReadError as e :
raise ValueError("No valid message found — read error.") from e
if hashlib.sha512(message).digest() != sha :
raise ValueError("No valid message found — SHA mismatch.")
return message
def load_from_file(model_file, bits_per_block, p_scale_number, seeds_number):
"""Retrieve the p_scales and the seeds from file
Parameters
---------
model_file: str
bits_per_block: int
p_scale_number: int
How many p scales do we read
seeds_number: int
How many seeds do we read
"""
with open(model_file, mode='rb') as f:
stream = BitStream(f)
p_scale_vars = list()
for index in range(p_scale_number):
p_scale_vars += stream.readlist('float: {}'.format(P_SCALE_LENGTH))
seeds = list()
for index in range(seeds_number):
seeds += stream.readlist('uint: {}'.format(bits_per_block))
return p_scale_vars, seeds
def DecodeGSM(gsm):
'''
Decode the encoded message from the GSM 03.38 character set.
Args:
gsm: The GSM 03.38 encoded text as byte array.
Returns:
The decoded text as UTF-8 encoded byte array.
'''
# convert to bit stream
bits = BitStream(gsm)
# get the indices, characters, and merge together
res = ''.join(__gsm[idx]
for idx in bits.readlist('{}'.format(len(bits) // 7) +
'*uint:7')).encode('utf-8')
# strip last character in case we have a perfect wrapping
if len(bits) % 7 == 0 and chr(res[-1]):
res = res[0:len(res) - 1]
return res
def DecodeSixbit(six):
'''
Decode the encoded message from the AIS Sixbit ASCII character set.
Args:
six: The AIS Sixbit encoded text as byte array.
Returns:
The decoded text as UTF-8 encoded byte array.
'''
# convert to bit stream
bits = BitStream(six)
# get the indices, characters, and merge together
res = ''.join(__sixbit[idx]
for idx in bits.readlist('{}'.format(len(bits) // 6) +
'*uint:6')).encode('utf-8')
# strip last character in case we have a perfect wrapping
if len(bits) % 6 == 0 and chr(res[-1]):
res = res[0:len(res) - 1]
return res
class CIQA(common_classes.LossyCompression):
def encode_image(self):
##### Read input image and separate into coding blocks.
self._separate_blocks()
##### Quantize image.
self._compute_coefficients()
##### Instantiate and write bitstring
self._write_bitstring()
return
def decode_binary(self):
##### Obtain bitstring
self._get_bitstring()
##### Read header and decode bitstring.
self._read_coefficientes()
def _compute_coefficients(self):
##### Get minimum and maximum values by patch
min_values = np.expand_dims(np.amin(self.patches, axis=2), axis=2)
max_values = np.expand_dims(np.amax(self.patches, axis=2), axis=2)
##### Compute deltas
deltas = (max_values - min_values) / self.M
##### Quantize patches
normalized_patches = self.patches - min_values
quantized_patches = np.clip(np.floor(normalized_patches / deltas), 0,
self.M - 1)
##### Stack information to be sent to the decoder and reshape them.
info_to_be_sent = np.concatenate(
(min_values, max_values, quantized_patches), axis=2)
info_to_be_sent = np.reshape(info_to_be_sent, (int(
np.prod(info_to_be_sent.shape[:2])), info_to_be_sent.shape[-1]))
self.info_to_be_sent = info_to_be_sent.astype(np.uint8)
return
def _write_bitstring(self):
##### Write information about patch size and quantization levels.
# The first is the difference between width and height:
# NOTE: The maximum patch dimension is 32, while the maximum quantization level is 16.
self.bitstring = BitStream(
f'int:7={self.patches.shape[1] - self.patches.shape[0]}, '
f'uint:5={self.N - 1}, uint:4={self.M - 1}')
##### Write patch coefficients into the bitstring.
bits_for_quantized_values = int(np.ceil(math.log2(self.M)))
for patch_information in self.info_to_be_sent:
##### Write minimum and maximum values.
self.bitstring.append(
f'uint:8={patch_information[0]}, uint:8={patch_information[1]}'
)
##### Write coefficients.
list(
map(
lambda quantized: self.bitstring.append(
f'uint:{bits_for_quantized_values}={quantized}'),
patch_information[2:]))
return
def _read_coefficientes(self):
##### Read header
patches_diff, self.N, self.M = self.bitstring.readlist(
f'int:7, uint:5, uint:4')
self.N += 1
self.M += 1
##### Obtain image dimensions
bits_for_quantized_values = int(np.ceil(math.log2(self.M)))
bits_per_patch = 2 * 8 + np.ceil(math.log2(self.M)) * self.N**2
patches_amount = len(
self.bitstring.bin.__str__()[16:]) / bits_per_patch
patches_shape = self._compute_dimensions(patches_diff, patches_amount)
image_shape = patches_shape * self.N
##### Decode patches
self.quantized_image = np.zeros(image_shape)
for v in range(patches_shape[0]):
for h in range(patches_shape[1]):
##### Get index mapping within a patch
min_value, max_value = self.bitstring.readlist(
f'uint:8, uint:8')
index_mapping = np.linspace(min_value, max_value, num=self.M)
##### Read index
indexes = np.reshape(list(\
map(lambda pixel_idx: self.bitstring.read(f'uint:{bits_for_quantized_values}'), range(self.N**2))), \
(self.N, self.N))
##### Decode and store patch.
reconstructed_patch = index_mapping[indexes]
self.quantized_image[v * self.N:(v + 1) * self.N,
h * self.N:(h + 1) *
self.N] = reconstructed_patch
##### Cast patch to uint8.
self.quantized_image = self.quantized_image.astype(np.uint8)
return
messageBuffer = BitStream()
i = 0
pumpSession = MedtronicSession()
for packet in cap:
# Make sure the data is coming from one of the USB endpoints we care about.
# Skip anything else
usbEndpoint = int( packet.usb.endpoint_number, 16 )
if( usbEndpoint != INCOMING_ENDPOINT and
usbEndpoint != OUTGOING_ENDPOINT ):
continue
usbBuffer = BitStream('0x%s' % ( packet.data.usb_capdata.replace( ':', '' ) ) )
usbHeader = usbBuffer.readlist( 'bytes:3, uint:8' )
# Validate the header
if( usbEndpoint == OUTGOING_ENDPOINT and usbHeader[0].encode( 'hex' ) != '000000' ):
print 'Unexpected USB Header. Expected "0x000000", got "0x%s".' % ( usbHeader[0].encode( 'hex' ) )
raise Exception
if( usbEndpoint == INCOMING_ENDPOINT and usbHeader[0] != 'ABC' ):
print 'Unexpected USB Header. Expected "0x414243", got "0x%s".' % ( usbHeader[0].encode( 'hex' ) )
raise Exception
messageBuffer.append( usbBuffer.read( usbHeader[1] * 8 ) )
# Clear the messageBuffer if we have a full message
# TODO - we need to be able to figure out if all 60 bytes are conusumed, but it's the end of the message
if( usbHeader[1] < USB_PACKET_SIZE ):
print >> sys.stderr, 'Message %s' % ( 'OUT' if usbEndpoint == OUTGOING_ENDPOINT else 'IN' )
i = 0
pumpSession = MedtronicSession(args.encyption_key)
for packet in cap:
# Make sure the data is coming from one of the USB endpoints we care about.
# Skip anything else
usbEndpoint = int(packet.usb.endpoint_number, 16)
if (usbEndpoint != INCOMING_ENDPOINT
and usbEndpoint != OUTGOING_ENDPOINT):
continue
usbBuffer = BitStream('0x%s' %
(packet.data.usb_capdata.replace(':', '')))
usbHeader = usbBuffer.readlist('bytes:3, uint:8')
# Validate the header
if (usbEndpoint == OUTGOING_ENDPOINT
and usbHeader[0].encode('hex') != '000000'):
print 'Unexpected USB Header. Expected "0x000000", got "0x%s".' % (
usbHeader[0].encode('hex'))
raise Exception
if (usbEndpoint == INCOMING_ENDPOINT and usbHeader[0] != 'ABC'):
print 'Unexpected USB Header. Expected "0x414243", got "0x%s".' % (
usbHeader[0].encode('hex'))
raise Exception
messageBuffer.append(usbBuffer.read(usbHeader[1] * 8))
# Clear the messageBuffer if we have a full message
UDP_IP = "127.0.0.1"
UDP_PORT = 40868
sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
sock.bind((UDP_IP, UDP_PORT))
while True:
try:
data, addr = sock.recvfrom(1024)
data = data.split(b'\x5e')[1]
data = data.split(b'\xd5')[0]
tlm = BitStream(data)
print(tlm.bin)
fps, err, Ax, Ay, Az, Gx, Gy, Gz, roll, pitch, yaw, alt, temp, volts, resv = tlm.readlist('bits:6, bits:6, int:6, int:6, int:9, int:10, int:10, int:12, int:9, int:9, int:9, uint:12, int:8, uint:8, bits:8')
Ax /= 10
Ay /= 10
Az /= 10
volts /= 10
print("FPS = {}".format(fps))
print("err = {}".format(err))
print(" Ax = {}".format(Ax))
print(" Ay = {}".format(Ay))
print(" Az = {}".format(Az))
print(" Gx = {}".format(Gx))
print(" Gy = {}".format(Gy))
print(" Gz = {}".format(Gz))
print("rol = {}".format(roll))
def parse_sps_data(self):
s = BitStream('0x' + self.data.encode('hex'))
self.forbidden_bit = s.read('uint:1')
self.nal_ref_idc = s.read('uint:2')
self.nal_unit_type = s.read('uint:5')
self.profile_idc = s.read('uint:8')
self.constraint_flags = s.readlist('4*uint:1')
self.reserved_bits = s.read('uint:4')
self.level_idc = s.read('uint:8')
self.seq_parameter_set_id = s.read('ue')
if self.profile_idc in self.chroma_profiles:
self.chroma_format_idc = s.read('ue')
if self.chroma_format_idc == 3:
self.separate_color_plane_flag = s.read('uint:1')
self.bit_depth_luma_minus8 = s.read('ue')
self.bit_depth_chroma_minus8 = s.read('ue')
self.qpprime_y_zero_transform_bypass_flag = s.read('uint:1')
self.seq_scaling_matrix_present_flag = s.read('uint:1')
if self.seq_scaling_matrix_present_flag:
seq_scaling_list_present = s.read('uint:1')
scaling_list_count = 12 if self.chroma_format_idc == 3 else 8
for i in xrange(scaling_list_count):
if seq_scaling_list_present:
last_scale = 8
next_scale = 8
list_size = 16 if i < 6 else 64
for j in xrange(list_size):
delta_scale = s.read('ue')
self.log2_max_frame_num_minus4 = s.read('ue')
self.log2_max_frame_num = self.log2_max_frame_num_minus4 + 4
frame_num_width = self.log2_max_frame_num
self.pic_order_cnt_type = s.read('ue')
if self.pic_order_cnt_type == 0:
self.log2_max_pic_order_cnt_lsb_minus4 = s.read('ue')
elif self.pic_order_cnt_type == 1:
self.delta_pic_order_always_zero_flag = s.read('uint:1')
self.offset_for_non_ref_pic = s.read('se')
self.offset_for_top_to_bottom_field = s.read('se')
self.num_ref_frames_in_pic_order_cnt_cycle = s.read('ue')
self.offsets_for_ref_frame = s.readlist('4*')
self.max_num_ref_frames = s.read('ue')
self.gaps_in_frame_num_value_allowed_flag = s.read('uint:1')
self.pic_width_in_mbs_minus1 = s.read('ue')
self.pic_height_in_map_units_minus1 = s.read('ue')
self.frame_mbs_only_flag = s.read('uint:1')
if self.frame_mbs_only_flag == 0:
self.mb_adaptive_frame_field_flag = s.read('uint:1')
self.direct_8x8_inference_flag = s.read('uint:1')
self.frame_cropping_flag = s.read('uint:1')
self.frame_crop_offsets = s.readlist('4*ue')
self.vui_parameters_present_flag = s.read('uint:1')
self.width = 16 * (self.pic_width_in_mbs_minus1 + 1)
self.height = 16 * (2 - self.frame_mbs_only_flag) * (
self.pic_height_in_map_units_minus1 + 1)
if self.separate_color_plane_flag or self.chroma_format_idc == 0:
self.frame_crop_offsets[CROP_BOTTOM] = self.frame_crop_offsets[
CROP_BOTTOM] * (2 - self.frame_mbs_only_flag)
self.frame_crop_offsets[CROP_TOP] = self.frame_crop_offsets[
CROP_TOP] * (2 - self.frame_mbs_only_flag)
elif not self.separate_color_plane_flag and self.chroma_format_idc > 0:
if self.chroma_format_idc == 1 or self.chroma_format_idc == 2:
self.frame_crop_offsets[
CROP_LEFT] = self.frame_crop_offsets[CROP_LEFT] * 2
self.frame_crop_offsets[
CROP_RIGHT] = self.frame_crop_offsets[CROP_RIGHT] * 2
if self.chroma_format_idc == 1:
self.frame_crop_offsets[
CROP_TOP] = self.frame_crop_offsets[CROP_TOP] * 2
self.frame_crop_offsets[
CROP_BOTTOM] = self.frame_crop_offsets[CROP_BOTTOM] * 2
self.width = self.width - (self.frame_crop_offsets[CROP_LEFT] +
self.frame_crop_offsets[CROP_RIGHT])
self.height = self.height - (self.frame_crop_offsets[CROP_TOP] +
self.frame_crop_offsets[CROP_BOTTOM])
