def _read(self): self._debug['version']['start'] = self._io.pos() self.version = self._io.read_u2le() self._debug['version']['end'] = self._io.pos() self._debug['flags']['start'] = self._io.pos() self._raw_flags = self._io.read_bytes(2) _io__raw_flags = KaitaiStream(BytesIO(self._raw_flags)) self.flags = Zip.LocalFileHeader.GpFlags(_io__raw_flags, self, self._root) self.flags._read() self._debug['flags']['end'] = self._io.pos() self._debug['compression_method']['start'] = self._io.pos() self.compression_method = KaitaiStream.resolve_enum(Zip.Compression, self._io.read_u2le()) self._debug['compression_method']['end'] = self._io.pos() self._debug['file_mod_time']['start'] = self._io.pos() self._raw_file_mod_time = self._io.read_bytes(4) _io__raw_file_mod_time = KaitaiStream(BytesIO(self._raw_file_mod_time)) self.file_mod_time = dos_datetime.DosDatetime(_io__raw_file_mod_time) self.file_mod_time._read() self._debug['file_mod_time']['end'] = self._io.pos() self._debug['crc32']['start'] = self._io.pos() self.crc32 = self._io.read_u4le() self._debug['crc32']['end'] = self._io.pos() self._debug['len_body_compressed']['start'] = self._io.pos() self.len_body_compressed = self._io.read_u4le() self._debug['len_body_compressed']['end'] = self._io.pos() self._debug['len_body_uncompressed']['start'] = self._io.pos() self.len_body_uncompressed = self._io.read_u4le() self._debug['len_body_uncompressed']['end'] = self._io.pos() self._debug['len_file_name']['start'] = self._io.pos() self.len_file_name = self._io.read_u2le() self._debug['len_file_name']['end'] = self._io.pos() self._debug['len_extra']['start'] = self._io.pos() self.len_extra = self._io.read_u2le() self._debug['len_extra']['end'] = self._io.pos() self._debug['file_name']['start'] = self._io.pos() self.file_name = (self._io.read_bytes(self.len_file_name)).decode(u"UTF-8") self._debug['file_name']['end'] = self._io.pos() self._debug['extra']['start'] = self._io.pos() self._raw_extra = self._io.read_bytes(self.len_extra) _io__raw_extra = KaitaiStream(BytesIO(self._raw_extra)) self.extra = Zip.Extras(_io__raw_extra, self, self._root) self.extra._read() self._debug['extra']['end'] = self._io.pos()
def _read(self): self._debug['properties']['start'] = self._io.pos() self.properties = [] i = 0 while True: if not 'arr' in self._debug['properties']: self._debug['properties']['arr'] = [] self._debug['properties']['arr'].append({'start': self._io.pos()}) _t_properties = AllegroDat.Property(self._io, self, self._root) _t_properties._read() _ = _t_properties self.properties.append(_) self._debug['properties']['arr'][len(self.properties) - 1]['end'] = self._io.pos() if not (_.is_valid): break i += 1 self._debug['properties']['end'] = self._io.pos() self._debug['len_compressed']['start'] = self._io.pos() self.len_compressed = self._io.read_s4be() self._debug['len_compressed']['end'] = self._io.pos() self._debug['len_uncompressed']['start'] = self._io.pos() self.len_uncompressed = self._io.read_s4be() self._debug['len_uncompressed']['end'] = self._io.pos() self._debug['body']['start'] = self._io.pos() _on = self.type if _on == u"BMP ": self._raw_body = self._io.read_bytes(self.len_compressed) _io__raw_body = KaitaiStream(BytesIO(self._raw_body)) self.body = AllegroDat.DatBitmap(_io__raw_body, self, self._root) self.body._read() elif _on == u"RLE ": self._raw_body = self._io.read_bytes(self.len_compressed) _io__raw_body = KaitaiStream(BytesIO(self._raw_body)) self.body = AllegroDat.DatRleSprite(_io__raw_body, self, self._root) self.body._read() elif _on == u"FONT": self._raw_body = self._io.read_bytes(self.len_compressed) _io__raw_body = KaitaiStream(BytesIO(self._raw_body)) self.body = AllegroDat.DatFont(_io__raw_body, self, self._root) self.body._read() else: self.body = self._io.read_bytes(self.len_compressed) self._debug['body']['end'] = self._io.pos()
def data(self): if hasattr(self, '_m_data'): return self._m_data if hasattr(self, '_m_data') else None _pos = self._io.pos() self._io.seek(self.ofs_data) self._debug['_m_data']['start'] = self._io.pos() _on = self.stream_type if _on == self._root.StreamTypes.memory_list: self._raw__m_data = self._io.read_bytes(self.len_data) _io__raw__m_data = KaitaiStream(BytesIO(self._raw__m_data)) self._m_data = self._root.MemoryList(_io__raw__m_data, self, self._root) self._m_data._read() elif _on == self._root.StreamTypes.misc_info: self._raw__m_data = self._io.read_bytes(self.len_data) _io__raw__m_data = KaitaiStream(BytesIO(self._raw__m_data)) self._m_data = self._root.MiscInfo(_io__raw__m_data, self, self._root) self._m_data._read() elif _on == self._root.StreamTypes.thread_list: self._raw__m_data = self._io.read_bytes(self.len_data) _io__raw__m_data = KaitaiStream(BytesIO(self._raw__m_data)) self._m_data = self._root.ThreadList(_io__raw__m_data, self, self._root) self._m_data._read() elif _on == self._root.StreamTypes.exception: self._raw__m_data = self._io.read_bytes(self.len_data) _io__raw__m_data = KaitaiStream(BytesIO(self._raw__m_data)) self._m_data = self._root.ExceptionStream( _io__raw__m_data, self, self._root) self._m_data._read() elif _on == self._root.StreamTypes.system_info: self._raw__m_data = self._io.read_bytes(self.len_data) _io__raw__m_data = KaitaiStream(BytesIO(self._raw__m_data)) self._m_data = self._root.SystemInfo(_io__raw__m_data, self, self._root) self._m_data._read() else: self._m_data = self._io.read_bytes(self.len_data) self._debug['_m_data']['end'] = self._io.pos() self._io.seek(_pos) return self._m_data if hasattr(self, '_m_data') else None
def _read(self): self.delim = self._io.read_bytes(1) if not self.delim == b"\xAA": raise kaitaistruct.ValidationNotEqualError(b"\xAA", self.delim, self._io, u"/types/entry/seq/0") self.tag = self._io.read_u1() self.length = self._io.read_u2be() self.counter = self._io.read_u2be() _on = self.tag if _on == 0: self._raw_body = self._io.read_bytes((self.length - 6)) _io__raw_body = KaitaiStream(BytesIO(self._raw_body)) self.body = ModelSxLog.OnChange(_io__raw_body, self, self._root) elif _on == 1: self._raw_body = self._io.read_bytes((self.length - 6)) _io__raw_body = KaitaiStream(BytesIO(self._raw_body)) self.body = ModelSxLog.Periodic(_io__raw_body, self, self._root) else: self.body = self._io.read_bytes((self.length - 6)) self.checksum = self._io.read_u1()
def _read(self): self._debug['len_all']['start'] = self._io.pos() self.len_all = self._io.read_u4le() self._debug['len_all']['end'] = self._io.pos() self._debug['all']['start'] = self._io.pos() self._raw_all = self._io.read_bytes((self.len_all - 4)) _io__raw_all = KaitaiStream(BytesIO(self._raw_all)) self.all = self._root.LinkInfo.All(_io__raw_all, self, self._root) self.all._read() self._debug['all']['end'] = self._io.pos()
def _read(self): self._debug['b1']['start'] = self._io.pos() self.b1 = self._io.read_u1() self._debug['b1']['end'] = self._io.pos() self._debug['b2']['start'] = self._io.pos() self.b2 = self._io.read_u1() self._debug['b2']['end'] = self._io.pos() self._debug['total_length']['start'] = self._io.pos() self.total_length = self._io.read_u2be() self._debug['total_length']['end'] = self._io.pos() self._debug['identification']['start'] = self._io.pos() self.identification = self._io.read_u2be() self._debug['identification']['end'] = self._io.pos() self._debug['b67']['start'] = self._io.pos() self.b67 = self._io.read_u2be() self._debug['b67']['end'] = self._io.pos() self._debug['ttl']['start'] = self._io.pos() self.ttl = self._io.read_u1() self._debug['ttl']['end'] = self._io.pos() self._debug['protocol']['start'] = self._io.pos() self.protocol = self._io.read_u1() self._debug['protocol']['end'] = self._io.pos() self._debug['header_checksum']['start'] = self._io.pos() self.header_checksum = self._io.read_u2be() self._debug['header_checksum']['end'] = self._io.pos() self._debug['src_ip_addr']['start'] = self._io.pos() self.src_ip_addr = self._io.read_bytes(4) self._debug['src_ip_addr']['end'] = self._io.pos() self._debug['dst_ip_addr']['start'] = self._io.pos() self.dst_ip_addr = self._io.read_bytes(4) self._debug['dst_ip_addr']['end'] = self._io.pos() self._debug['options']['start'] = self._io.pos() self._raw_options = self._io.read_bytes((self.ihl_bytes - 20)) _io__raw_options = KaitaiStream(BytesIO(self._raw_options)) self.options = self._root.Ipv4Options(_io__raw_options, self, self._root) self.options._read() self._debug['options']['end'] = self._io.pos() self._debug['body']['start'] = self._io.pos() self._raw_body = self._io.read_bytes((self.total_length - self.ihl_bytes)) _io__raw_body = KaitaiStream(BytesIO(self._raw_body)) self.body = protocol_body.ProtocolBody(self.protocol, _io__raw_body) self.body._read() self._debug['body']['end'] = self._io.pos()
def _read(self): self._raw_header = self._io.read_bytes( (self._parent.header_len - 1)) io = KaitaiStream(BytesIO(self._raw_header)) self.header = self._root.Header(io, self, self._root) if self.header.header1.lha_level == 0: self.file_uncompr_crc16 = self._io.read_u2le() self.body = self._io.read_bytes( self.header.header1.file_size_compr)
def _read(self): self.magic = self._io.ensure_fixed_contents(b"\x4E\x45\x53\x1A") self.len_prg_rom = self._io.read_u1() self.len_chr_rom = self._io.read_u1() self._raw_f6 = self._io.read_bytes(1) io = KaitaiStream(BytesIO(self._raw_f6)) self.f6 = self._root.Header.F6(io, self, self._root) self._raw_f7 = self._io.read_bytes(1) io = KaitaiStream(BytesIO(self._raw_f7)) self.f7 = self._root.Header.F7(io, self, self._root) self.len_prg_ram = self._io.read_u1() self._raw_f9 = self._io.read_bytes(1) io = KaitaiStream(BytesIO(self._raw_f9)) self.f9 = self._root.Header.F9(io, self, self._root) self._raw_f10 = self._io.read_bytes(1) io = KaitaiStream(BytesIO(self._raw_f10)) self.f10 = self._root.Header.F10(io, self, self._root) self.reserved = self._io.ensure_fixed_contents( b"\x00\x00\x00\x00\x00")
def _read(self): self._debug['reserved']['start'] = self._io.pos() self.reserved = self._io.read_u1() self._debug['reserved']['end'] = self._io.pos() self._debug['configurations']['start'] = self._io.pos() self._raw_configurations = self._io.read_bytes((self._parent.header.length - 1)) _io__raw_configurations = KaitaiStream(BytesIO(self._raw_configurations)) self.configurations = SomeIpSdOptions.SdOption.SdConfigStringsContainer(_io__raw_configurations, self, self._root) self.configurations._read() self._debug['configurations']['end'] = self._io.pos()
def _read(self): self.code = self._io.read_u1() self.size = self._io.read_u4le() _on = self.code if _on == 17: self._raw_body = self._io.read_bytes(self.size) _io__raw_body = KaitaiStream(BytesIO(self._raw_body)) self.body = SwitchManualIntSizeElse.Chunk.ChunkMeta( _io__raw_body, self, self._root) elif _on == 34: self._raw_body = self._io.read_bytes(self.size) _io__raw_body = KaitaiStream(BytesIO(self._raw_body)) self.body = SwitchManualIntSizeElse.Chunk.ChunkDir( _io__raw_body, self, self._root) else: self._raw_body = self._io.read_bytes(self.size) _io__raw_body = KaitaiStream(BytesIO(self._raw_body)) self.body = SwitchManualIntSizeElse.Chunk.Dummy( _io__raw_body, self, self._root)
def _read(self): self.len_block = self._io.read_u4be() self.block_identifier = KaitaiStream.resolve_enum(MozillaMar.BlockIdentifiers, self._io.read_u4be()) _on = self.block_identifier if _on == MozillaMar.BlockIdentifiers.product_information: self._raw_bytes = self._io.read_bytes(((self.len_block - 4) - 4)) _io__raw_bytes = KaitaiStream(BytesIO(self._raw_bytes)) self.bytes = MozillaMar.ProductInformationBlock(_io__raw_bytes, self, self._root) else: self.bytes = self._io.read_bytes(((self.len_block - 4) - 4))
def _read(self): self.b1 = self._io.read_u1() self.b2 = self._io.read_u1() self.total_length = self._io.read_u2be() self.identification = self._io.read_u2be() self.b67 = self._io.read_u2be() self.ttl = self._io.read_u1() self.protocol = self._io.read_u1() self.header_checksum = self._io.read_u2be() self.src_ip_addr = self._io.read_bytes(4) self.dst_ip_addr = self._io.read_bytes(4) self._raw_options = self._io.read_bytes((self.ihl_bytes - 20)) _io__raw_options = KaitaiStream(BytesIO(self._raw_options)) self.options = Ipv4Packet.Ipv4Options(_io__raw_options, self, self._root) self._raw_body = self._io.read_bytes( (self.total_length - self.ihl_bytes)) _io__raw_body = KaitaiStream(BytesIO(self._raw_body)) self.body = protocol_body.ProtocolBody(self.protocol, _io__raw_body)
def _read(self): self.four_cc = KaitaiStream.resolve_enum(Avi.ChunkType, self._io.read_u4le()) self.block_size = self._io.read_u4le() _on = self.four_cc if _on == Avi.ChunkType.list: self._raw_data = self._io.read_bytes(self.block_size) _io__raw_data = KaitaiStream(BytesIO(self._raw_data)) self.data = Avi.ListBody(_io__raw_data, self, self._root) elif _on == Avi.ChunkType.avih: self._raw_data = self._io.read_bytes(self.block_size) _io__raw_data = KaitaiStream(BytesIO(self._raw_data)) self.data = Avi.AvihBody(_io__raw_data, self, self._root) elif _on == Avi.ChunkType.strh: self._raw_data = self._io.read_bytes(self.block_size) _io__raw_data = KaitaiStream(BytesIO(self._raw_data)) self.data = Avi.StrhBody(_io__raw_data, self, self._root) else: self.data = self._io.read_bytes(self.block_size)
def _read(self): self.string_magic = self._io.read_bytes(1) if not self.string_magic == b"\x73": raise kaitaistruct.ValidationNotEqualError( b"\x73", self.string_magic, self._io, u"/types/assembly/seq/0") self.length = self._io.read_u4le() self._raw_items = self._io.read_bytes(self.length) _io__raw_items = KaitaiStream(BytesIO(self._raw_items)) self.items = PythonPyc27.OpArgs(_io__raw_items, self, self._root)
def _read(self): self.meta_header = AndroidBootldrHuawei.MetaHdr( self._io, self, self._root) self.header_ext = self._io.read_bytes( (self.meta_header.len_meta_header - 76)) self._raw_image_header = self._io.read_bytes( self.meta_header.len_image_header) _io__raw_image_header = KaitaiStream(BytesIO(self._raw_image_header)) self.image_header = AndroidBootldrHuawei.ImageHdr( _io__raw_image_header, self, self._root)
def _read(self): self.b1 = self._io.read_u1() self.b2 = self._io.read_u1() self.total_length = self._io.read_u2be() self.identification = self._io.read_u2be() self.b67 = self._io.read_u2be() self.ttl = self._io.read_u1() self.protocol = self._io.read_u1() self.header_checksum = self._io.read_u2be() self.src_ip_addr = self._io.read_bytes(4) self.dst_ip_addr = self._io.read_bytes(4) self._raw_options = self._io.read_bytes((self.ihl_bytes - 20)) io = KaitaiStream(BytesIO(self._raw_options)) self.options = self._root.Ipv4Options(io, self, self._root) self.read_len = self.total_length if self.total_length > 0 else 64 self._raw_body = self._io.read_bytes(self.read_len - self.ihl_bytes) # self._raw_body = self._io.read_bytes((self.total_length - self.ihl_bytes)) io = KaitaiStream(BytesIO(self._raw_body)) self.body = ProtocolBody(self.protocol, io)
def _read(self): self.uuid = self._io.read_bytes(16) self.image_start_sector = self._io.read_u4be() self.image_size = self._io.read_u4be() self.audio_start_sector = self._io.read_u4be() self.audio_size = self._io.read_u4be() self._raw_navigation = self._io.read_bytes((512 - 32)) _io__raw_navigation = KaitaiStream(BytesIO(self._raw_navigation)) self.navigation = self._root.NavigationStruct( _io__raw_navigation, self, self._root)
def _read(self): self.dst_mac = self._io.read_bytes(6) self.src_mac = self._io.read_bytes(6) try: self.ether_type = self._root.EtherTypeEnum(self._io.read_u2be()) _on = self.ether_type except: self.ether_type = self._root.EtherTypeEnum(None) _on = None if _on == self._root.EtherTypeEnum.ipv4: self._raw_body = self._io.read_bytes_full() io = KaitaiStream(BytesIO(self._raw_body)) self.body = Ipv4Packet(io) elif _on == self._root.EtherTypeEnum.ipv6: self._raw_body = self._io.read_bytes_full() io = KaitaiStream(BytesIO(self._raw_body)) self.body = Ipv6Packet(io) else: self.body = self._io.read_bytes_full()
def _read(self): self.qty_entries = self._io.read_u4le() self.entries = [None] * (self.qty_entries) for i in range(self.qty_entries): self.entries[i] = InstanceIoUser.Entry(self._io, self, self._root) self._raw_strings = self._io.read_bytes_full() _io__raw_strings = KaitaiStream(BytesIO(self._raw_strings)) self.strings = InstanceIoUser.StringsObj(_io__raw_strings, self, self._root)
def _read(self): self._debug['decompressor_id']['start'] = self._io.pos() self.decompressor_id = self._io.read_s2be() self._debug['decompressor_id']['end'] = self._io.pos() self._debug['decompressor_specific_parameters_with_io']['start'] = self._io.pos() self._raw_decompressor_specific_parameters_with_io = self._io.read_bytes(4) _io__raw_decompressor_specific_parameters_with_io = KaitaiStream(BytesIO(self._raw_decompressor_specific_parameters_with_io)) self.decompressor_specific_parameters_with_io = bytes_with_io.BytesWithIo(_io__raw_decompressor_specific_parameters_with_io) self.decompressor_specific_parameters_with_io._read() self._debug['decompressor_specific_parameters_with_io']['end'] = self._io.pos()
def _read(self): self.len = self._io.read_s4le() self._raw_fields = self._io.read_bytes((self.len - 5)) _io__raw_fields = KaitaiStream(BytesIO(self._raw_fields)) self.fields = Bson.ElementsList(_io__raw_fields, self, self._root) self.terminator = self._io.read_bytes(1) if not self.terminator == b"\x00": raise kaitaistruct.ValidationNotEqualError(b"\x00", self.terminator, self._io, u"/seq/2")
def _read(self): self.header = self._root.ArchiveStorageHeader.Header( self._io, self, self._root) self._raw__raw_blocks_info = self._io.read_bytes( self.header.compressed_size) _process = Lz4process(self.header.uncompressed_size) self._raw_blocks_info = _process.decode(self._raw__raw_blocks_info) io = KaitaiStream(BytesIO(self._raw_blocks_info)) self.blocks_info = self._root.ArchiveStorageHeader.BlocksInfo( io, self, self._root)
def _read(self): self.signature = self._io.ensure_fixed_contents(b"\x01\xB0\x93\xFF") self.size = self._io.read_u4le() self.reserved0 = self._io.read_bytes(4) self.last_frame = self._io.read_u2le() self.reserved1 = self._io.read_bytes(18) self.wrond_doc = self._io.read_bytes(1) self._raw_frames = self._io.read_bytes(self.size) io = KaitaiStream(BytesIO(self._raw_frames)) self.frames = self._root.Framez(io, self, self._root)
def _read(self): self.tag = self._io.read_u2le() self.len_body = self._io.read_u2le() _on = self.tag if _on == 1: self._raw_body = self._io.read_bytes(self.len_body) _io__raw_body = KaitaiStream(BytesIO(self._raw_body)) self.body = Zip.ExtraField.Ntfs.Attribute1(_io__raw_body, self, self._root) else: self.body = self._io.read_bytes(self.len_body)
def _read(self): self.uid = self._io.read_u4be() _on = self.uid if _on == 1380273474: self._raw_contents = self._io.read_bytes_full() _io__raw_contents = KaitaiStream(BytesIO(self._raw_contents)) self.contents = RtcpPayload.PsfbAfbRembPacket( _io__raw_contents, self, self._root) else: self.contents = self._io.read_bytes_full()
def _read(self): self._debug['file_hdr']['start'] = self._io.pos() self.file_hdr = self._root.FileHeader(self._io, self, self._root) self.file_hdr._read() self._debug['file_hdr']['end'] = self._io.pos() self._debug['dib_info']['start'] = self._io.pos() self._raw_dib_info = self._io.read_bytes( (self.file_hdr.ofs_bitmap - 14)) _io__raw_dib_info = KaitaiStream(BytesIO(self._raw_dib_info)) self.dib_info = self._root.BitmapInfo(_io__raw_dib_info, self, self._root) self.dib_info._read() self._debug['dib_info']['end'] = self._io.pos() self._debug['bitmap']['start'] = self._io.pos() self._raw_bitmap = self._io.read_bytes_full() _io__raw_bitmap = KaitaiStream(BytesIO(self._raw_bitmap)) self.bitmap = self._root.Bitmap(_io__raw_bitmap, self, self._root) self.bitmap._read() self._debug['bitmap']['end'] = self._io.pos()
def parse_volume_keybag(unwrapped_keybag): """ Returns a kaitai struct structure of the unwrapped keybag param: unwrappped_keybag: The bytes like keybag that will be parsed return: keybag: The structured keybag """ stream = KaitaiStream(BytesIO(unwrapped_keybag)) keybag = media_keybag_t_kek(stream) return keybag
def _read(self): self.header = self._root.FileHeader(self._io, self, self._root) self._raw_hive_bins = [] self.hive_bins = [] i = 0 while not self._io.is_eof(): self._raw_hive_bins.append(self._io.read_bytes(4096)) io = KaitaiStream(BytesIO(self._raw_hive_bins[-1])) self.hive_bins.append(self._root.HiveBin(io, self, self._root)) i += 1
def _read(self): self._debug['header_length']['start'] = self._io.pos() self.header_length = self._io.read_u4le() self._debug['header_length']['end'] = self._io.pos() self._debug['main']['start'] = self._io.pos() self._raw_main = self._io.read_bytes((self.header_length - 4)) _io__raw_main = KaitaiStream(BytesIO(self._raw_main)) self.main = FasttrackerXmModule.Pattern.Header.HeaderMain(_io__raw_main, self, self._root) self.main._read() self._debug['main']['end'] = self._io.pos()
def _read(self): self.ssrc = self._io.read_u4be() self.ssrc_media_source = self._io.read_u4be() _on = self.fmt if _on == self._root.PsfbSubtype.afb: self._raw_fci_block = self._io.read_bytes_full() io = KaitaiStream(BytesIO(self._raw_fci_block)) self.fci_block = self._root.PsfbAfbPacket(io, self, self._root) else: self.fci_block = self._io.read_bytes_full()