polyfile-weave 0.5.5__py3-none-any.whl

polyfile/kaitai/parsers/gzip.py

@@ -0,0 +1,232 @@
+# This is a generated file! Please edit source .ksy file and use kaitai-struct-compiler to rebuild
+
+from pkg_resources import parse_version
+import kaitaistruct
+from kaitaistruct import KaitaiStruct, KaitaiStream, BytesIO
+from enum import Enum
+import collections
+
+
+if parse_version(kaitaistruct.__version__) < parse_version('0.9'):
+    raise Exception("Incompatible Kaitai Struct Python API: 0.9 or later is required, but you have %s" % (kaitaistruct.__version__))
+
+class Gzip(KaitaiStruct):
+    """Gzip is a popular and standard single-file archiving format. It
+    essentially provides a container that stores original file name,
+    timestamp and a few other things (like optional comment), basic
+    CRCs, etc, and a file compressed by a chosen compression algorithm.
+    
+    As of 2019, there is actually only one working solution for
+    compression algorithms, so it's typically raw DEFLATE stream
+    (without zlib header) in all gzipped files.
+    
+    .. seealso::
+       Source - https://www.rfc-editor.org/rfc/rfc1952
+    """
+
+    class CompressionMethods(Enum):
+        deflate = 8
+
+    class Oses(Enum):
+        fat = 0
+        amiga = 1
+        vms = 2
+        unix = 3
+        vm_cms = 4
+        atari_tos = 5
+        hpfs = 6
+        macintosh = 7
+        z_system = 8
+        cp_m = 9
+        tops_20 = 10
+        ntfs = 11
+        qdos = 12
+        acorn_riscos = 13
+        unknown = 255
+    SEQ_FIELDS = ["magic", "compression_method", "flags", "mod_time", "extra_flags", "os", "extras", "name", "comment", "header_crc16", "body", "body_crc32", "len_uncompressed"]
+    def __init__(self, _io, _parent=None, _root=None):
+        self._io = _io
+        self._parent = _parent
+        self._root = _root if _root else self
+        self._debug = collections.defaultdict(dict)
+
+    def _read(self):
+        self._debug['magic']['start'] = self._io.pos()
+        self.magic = self._io.read_bytes(2)
+        self._debug['magic']['end'] = self._io.pos()
+        if not self.magic == b"\x1F\x8B":
+            raise kaitaistruct.ValidationNotEqualError(b"\x1F\x8B", self.magic, self._io, u"/seq/0")
+        self._debug['compression_method']['start'] = self._io.pos()
+        self.compression_method = KaitaiStream.resolve_enum(Gzip.CompressionMethods, self._io.read_u1())
+        self._debug['compression_method']['end'] = self._io.pos()
+        self._debug['flags']['start'] = self._io.pos()
+        self.flags = Gzip.Flags(self._io, self, self._root)
+        self.flags._read()
+        self._debug['flags']['end'] = self._io.pos()
+        self._debug['mod_time']['start'] = self._io.pos()
+        self.mod_time = self._io.read_u4le()
+        self._debug['mod_time']['end'] = self._io.pos()
+        self._debug['extra_flags']['start'] = self._io.pos()
+        _on = self.compression_method
+        if _on == Gzip.CompressionMethods.deflate:
+            self.extra_flags = Gzip.ExtraFlagsDeflate(self._io, self, self._root)
+            self.extra_flags._read()
+        self._debug['extra_flags']['end'] = self._io.pos()
+        self._debug['os']['start'] = self._io.pos()
+        self.os = KaitaiStream.resolve_enum(Gzip.Oses, self._io.read_u1())
+        self._debug['os']['end'] = self._io.pos()
+        if self.flags.has_extra:
+            self._debug['extras']['start'] = self._io.pos()
+            self.extras = Gzip.Extras(self._io, self, self._root)
+            self.extras._read()
+            self._debug['extras']['end'] = self._io.pos()
+
+        if self.flags.has_name:
+            self._debug['name']['start'] = self._io.pos()
+            self.name = self._io.read_bytes_term(0, False, True, True)
+            self._debug['name']['end'] = self._io.pos()
+
+        if self.flags.has_comment:
+            self._debug['comment']['start'] = self._io.pos()
+            self.comment = self._io.read_bytes_term(0, False, True, True)
+            self._debug['comment']['end'] = self._io.pos()
+
+        if self.flags.has_header_crc:
+            self._debug['header_crc16']['start'] = self._io.pos()
+            self.header_crc16 = self._io.read_u2le()
+            self._debug['header_crc16']['end'] = self._io.pos()
+
+        self._debug['body']['start'] = self._io.pos()
+        self.body = self._io.read_bytes(((self._io.size() - self._io.pos()) - 8))
+        self._debug['body']['end'] = self._io.pos()
+        self._debug['body_crc32']['start'] = self._io.pos()
+        self.body_crc32 = self._io.read_u4le()
+        self._debug['body_crc32']['end'] = self._io.pos()
+        self._debug['len_uncompressed']['start'] = self._io.pos()
+        self.len_uncompressed = self._io.read_u4le()
+        self._debug['len_uncompressed']['end'] = self._io.pos()
+
+    class Flags(KaitaiStruct):
+        SEQ_FIELDS = ["reserved1", "has_comment", "has_name", "has_extra", "has_header_crc", "is_text"]
+        def __init__(self, _io, _parent=None, _root=None):
+            self._io = _io
+            self._parent = _parent
+            self._root = _root if _root else self
+            self._debug = collections.defaultdict(dict)
+
+        def _read(self):
+            self._debug['reserved1']['start'] = self._io.pos()
+            self.reserved1 = self._io.read_bits_int_be(3)
+            self._debug['reserved1']['end'] = self._io.pos()
+            self._debug['has_comment']['start'] = self._io.pos()
+            self.has_comment = self._io.read_bits_int_be(1) != 0
+            self._debug['has_comment']['end'] = self._io.pos()
+            self._debug['has_name']['start'] = self._io.pos()
+            self.has_name = self._io.read_bits_int_be(1) != 0
+            self._debug['has_name']['end'] = self._io.pos()
+            self._debug['has_extra']['start'] = self._io.pos()
+            self.has_extra = self._io.read_bits_int_be(1) != 0
+            self._debug['has_extra']['end'] = self._io.pos()
+            self._debug['has_header_crc']['start'] = self._io.pos()
+            self.has_header_crc = self._io.read_bits_int_be(1) != 0
+            self._debug['has_header_crc']['end'] = self._io.pos()
+            self._debug['is_text']['start'] = self._io.pos()
+            self.is_text = self._io.read_bits_int_be(1) != 0
+            self._debug['is_text']['end'] = self._io.pos()
+
+
+    class ExtraFlagsDeflate(KaitaiStruct):
+
+        class CompressionStrengths(Enum):
+            best = 2
+            fast = 4
+        SEQ_FIELDS = ["compression_strength"]
+        def __init__(self, _io, _parent=None, _root=None):
+            self._io = _io
+            self._parent = _parent
+            self._root = _root if _root else self
+            self._debug = collections.defaultdict(dict)
+
+        def _read(self):
+            self._debug['compression_strength']['start'] = self._io.pos()
+            self.compression_strength = KaitaiStream.resolve_enum(Gzip.ExtraFlagsDeflate.CompressionStrengths, self._io.read_u1())
+            self._debug['compression_strength']['end'] = self._io.pos()
+
+
+    class Subfields(KaitaiStruct):
+        """Container for many subfields, constrained by size of stream.
+        """
+        SEQ_FIELDS = ["entries"]
+        def __init__(self, _io, _parent=None, _root=None):
+            self._io = _io
+            self._parent = _parent
+            self._root = _root if _root else self
+            self._debug = collections.defaultdict(dict)
+
+        def _read(self):
+            self._debug['entries']['start'] = self._io.pos()
+            self.entries = []
+            i = 0
+            while not self._io.is_eof():
+                if not 'arr' in self._debug['entries']:
+                    self._debug['entries']['arr'] = []
+                self._debug['entries']['arr'].append({'start': self._io.pos()})
+                _t_entries = Gzip.Subfield(self._io, self, self._root)
+                _t_entries._read()
+                self.entries.append(_t_entries)
+                self._debug['entries']['arr'][len(self.entries) - 1]['end'] = self._io.pos()
+                i += 1
+
+            self._debug['entries']['end'] = self._io.pos()
+
+
+    class Subfield(KaitaiStruct):
+        """Every subfield follows typical [TLV scheme](https://en.wikipedia.org/wiki/Type-length-value):
+        
+        * `id` serves role of "T"ype
+        * `len_data` serves role of "L"ength
+        * `data` serves role of "V"alue
+        
+        This way it's possible to for arbitrary parser to skip over
+        subfields it does not support.
+        """
+        SEQ_FIELDS = ["id", "len_data", "data"]
+        def __init__(self, _io, _parent=None, _root=None):
+            self._io = _io
+            self._parent = _parent
+            self._root = _root if _root else self
+            self._debug = collections.defaultdict(dict)
+
+        def _read(self):
+            self._debug['id']['start'] = self._io.pos()
+            self.id = self._io.read_u2le()
+            self._debug['id']['end'] = self._io.pos()
+            self._debug['len_data']['start'] = self._io.pos()
+            self.len_data = self._io.read_u2le()
+            self._debug['len_data']['end'] = self._io.pos()
+            self._debug['data']['start'] = self._io.pos()
+            self.data = self._io.read_bytes(self.len_data)
+            self._debug['data']['end'] = self._io.pos()
+
+
+    class Extras(KaitaiStruct):
+        SEQ_FIELDS = ["len_subfields", "subfields"]
+        def __init__(self, _io, _parent=None, _root=None):
+            self._io = _io
+            self._parent = _parent
+            self._root = _root if _root else self
+            self._debug = collections.defaultdict(dict)
+
+        def _read(self):
+            self._debug['len_subfields']['start'] = self._io.pos()
+            self.len_subfields = self._io.read_u2le()
+            self._debug['len_subfields']['end'] = self._io.pos()
+            self._debug['subfields']['start'] = self._io.pos()
+            self._raw_subfields = self._io.read_bytes(self.len_subfields)
+            _io__raw_subfields = KaitaiStream(BytesIO(self._raw_subfields))
+            self.subfields = Gzip.Subfields(_io__raw_subfields, self, self._root)
+            self.subfields._read()
+            self._debug['subfields']['end'] = self._io.pos()
+
+
+

polyfile/kaitai/parsers/hashcat_restore.py

@@ -0,0 +1,60 @@
+# This is a generated file! Please edit source .ksy file and use kaitai-struct-compiler to rebuild
+
+from pkg_resources import parse_version
+import kaitaistruct
+from kaitaistruct import KaitaiStruct, KaitaiStream, BytesIO
+import collections
+
+
+if parse_version(kaitaistruct.__version__) < parse_version('0.9'):
+    raise Exception("Incompatible Kaitai Struct Python API: 0.9 or later is required, but you have %s" % (kaitaistruct.__version__))
+
+class HashcatRestore(KaitaiStruct):
+    """
+    .. seealso::
+       Source - https://hashcat.net/wiki/doku.php?id=restore
+    """
+    SEQ_FIELDS = ["version", "cwd", "dicts_pos", "masks_pos", "padding", "current_restore_point", "argc", "padding2", "argv"]
+    def __init__(self, _io, _parent=None, _root=None):
+        self._io = _io
+        self._parent = _parent
+        self._root = _root if _root else self
+        self._debug = collections.defaultdict(dict)
+
+    def _read(self):
+        self._debug['version']['start'] = self._io.pos()
+        self.version = self._io.read_u4le()
+        self._debug['version']['end'] = self._io.pos()
+        self._debug['cwd']['start'] = self._io.pos()
+        self.cwd = (KaitaiStream.bytes_terminate(self._io.read_bytes(256), 0, False)).decode(u"UTF-8")
+        self._debug['cwd']['end'] = self._io.pos()
+        self._debug['dicts_pos']['start'] = self._io.pos()
+        self.dicts_pos = self._io.read_u4le()
+        self._debug['dicts_pos']['end'] = self._io.pos()
+        self._debug['masks_pos']['start'] = self._io.pos()
+        self.masks_pos = self._io.read_u4le()
+        self._debug['masks_pos']['end'] = self._io.pos()
+        self._debug['padding']['start'] = self._io.pos()
+        self.padding = self._io.read_bytes(4)
+        self._debug['padding']['end'] = self._io.pos()
+        self._debug['current_restore_point']['start'] = self._io.pos()
+        self.current_restore_point = self._io.read_u8le()
+        self._debug['current_restore_point']['end'] = self._io.pos()
+        self._debug['argc']['start'] = self._io.pos()
+        self.argc = self._io.read_u4le()
+        self._debug['argc']['end'] = self._io.pos()
+        self._debug['padding2']['start'] = self._io.pos()
+        self.padding2 = self._io.read_bytes(12)
+        self._debug['padding2']['end'] = self._io.pos()
+        self._debug['argv']['start'] = self._io.pos()
+        self.argv = [None] * (self.argc)
+        for i in range(self.argc):
+            if not 'arr' in self._debug['argv']:
+                self._debug['argv']['arr'] = []
+            self._debug['argv']['arr'].append({'start': self._io.pos()})
+            self.argv[i] = (self._io.read_bytes_term(10, False, True, True)).decode(u"UTF-8")
+            self._debug['argv']['arr'][i]['end'] = self._io.pos()
+
+        self._debug['argv']['end'] = self._io.pos()
+
+

polyfile/kaitai/parsers/hccap.py

@@ -0,0 +1,111 @@
+# This is a generated file! Please edit source .ksy file and use kaitai-struct-compiler to rebuild
+
+from pkg_resources import parse_version
+import kaitaistruct
+from kaitaistruct import KaitaiStruct, KaitaiStream, BytesIO
+import collections
+
+
+if parse_version(kaitaistruct.__version__) < parse_version('0.9'):
+    raise Exception("Incompatible Kaitai Struct Python API: 0.9 or later is required, but you have %s" % (kaitaistruct.__version__))
+
+class Hccap(KaitaiStruct):
+    """Native format of Hashcat password "recovery" utility.
+    
+    A sample of file for testing can be downloaded from
+    <https://web.archive.org/web/20150220013635if_/http://hashcat.net:80/misc/example_hashes/hashcat.hccap>
+    
+    .. seealso::
+       Source - https://hashcat.net/wiki/doku.php?id=hccap
+    """
+    SEQ_FIELDS = ["records"]
+    def __init__(self, _io, _parent=None, _root=None):
+        self._io = _io
+        self._parent = _parent
+        self._root = _root if _root else self
+        self._debug = collections.defaultdict(dict)
+
+    def _read(self):
+        self._debug['records']['start'] = self._io.pos()
+        self.records = []
+        i = 0
+        while not self._io.is_eof():
+            if not 'arr' in self._debug['records']:
+                self._debug['records']['arr'] = []
+            self._debug['records']['arr'].append({'start': self._io.pos()})
+            _t_records = Hccap.HccapRecord(self._io, self, self._root)
+            _t_records._read()
+            self.records.append(_t_records)
+            self._debug['records']['arr'][len(self.records) - 1]['end'] = self._io.pos()
+            i += 1
+
+        self._debug['records']['end'] = self._io.pos()
+
+    class HccapRecord(KaitaiStruct):
+        SEQ_FIELDS = ["essid", "mac_ap", "mac_station", "nonce_station", "nonce_ap", "eapol_buffer", "len_eapol", "keyver", "keymic"]
+        def __init__(self, _io, _parent=None, _root=None):
+            self._io = _io
+            self._parent = _parent
+            self._root = _root if _root else self
+            self._debug = collections.defaultdict(dict)
+
+        def _read(self):
+            self._debug['essid']['start'] = self._io.pos()
+            self.essid = self._io.read_bytes(36)
+            self._debug['essid']['end'] = self._io.pos()
+            self._debug['mac_ap']['start'] = self._io.pos()
+            self.mac_ap = self._io.read_bytes(6)
+            self._debug['mac_ap']['end'] = self._io.pos()
+            self._debug['mac_station']['start'] = self._io.pos()
+            self.mac_station = self._io.read_bytes(6)
+            self._debug['mac_station']['end'] = self._io.pos()
+            self._debug['nonce_station']['start'] = self._io.pos()
+            self.nonce_station = self._io.read_bytes(32)
+            self._debug['nonce_station']['end'] = self._io.pos()
+            self._debug['nonce_ap']['start'] = self._io.pos()
+            self.nonce_ap = self._io.read_bytes(32)
+            self._debug['nonce_ap']['end'] = self._io.pos()
+            self._debug['eapol_buffer']['start'] = self._io.pos()
+            self._raw_eapol_buffer = self._io.read_bytes(256)
+            _io__raw_eapol_buffer = KaitaiStream(BytesIO(self._raw_eapol_buffer))
+            self.eapol_buffer = Hccap.EapolDummy(_io__raw_eapol_buffer, self, self._root)
+            self.eapol_buffer._read()
+            self._debug['eapol_buffer']['end'] = self._io.pos()
+            self._debug['len_eapol']['start'] = self._io.pos()
+            self.len_eapol = self._io.read_u4le()
+            self._debug['len_eapol']['end'] = self._io.pos()
+            self._debug['keyver']['start'] = self._io.pos()
+            self.keyver = self._io.read_u4le()
+            self._debug['keyver']['end'] = self._io.pos()
+            self._debug['keymic']['start'] = self._io.pos()
+            self.keymic = self._io.read_bytes(16)
+            self._debug['keymic']['end'] = self._io.pos()
+
+        @property
+        def eapol(self):
+            if hasattr(self, '_m_eapol'):
+                return self._m_eapol if hasattr(self, '_m_eapol') else None
+
+            io = self.eapol_buffer._io
+            _pos = io.pos()
+            io.seek(0)
+            self._debug['_m_eapol']['start'] = io.pos()
+            self._m_eapol = io.read_bytes(self.len_eapol)
+            self._debug['_m_eapol']['end'] = io.pos()
+            io.seek(_pos)
+            return self._m_eapol if hasattr(self, '_m_eapol') else None
+
+
+    class EapolDummy(KaitaiStruct):
+        SEQ_FIELDS = []
+        def __init__(self, _io, _parent=None, _root=None):
+            self._io = _io
+            self._parent = _parent
+            self._root = _root if _root else self
+            self._debug = collections.defaultdict(dict)
+
+        def _read(self):
+            pass
+
+
+

polyfile/kaitai/parsers/hccapx.py

@@ -0,0 +1,103 @@
+# This is a generated file! Please edit source .ksy file and use kaitai-struct-compiler to rebuild
+
+from pkg_resources import parse_version
+import kaitaistruct
+from kaitaistruct import KaitaiStruct, KaitaiStream, BytesIO
+import collections
+
+
+if parse_version(kaitaistruct.__version__) < parse_version('0.9'):
+    raise Exception("Incompatible Kaitai Struct Python API: 0.9 or later is required, but you have %s" % (kaitaistruct.__version__))
+
+class Hccapx(KaitaiStruct):
+    """Native format of Hashcat password "recovery" utility
+    
+    .. seealso::
+       Source - https://hashcat.net/wiki/doku.php?id=hccapx
+    """
+    SEQ_FIELDS = ["records"]
+    def __init__(self, _io, _parent=None, _root=None):
+        self._io = _io
+        self._parent = _parent
+        self._root = _root if _root else self
+        self._debug = collections.defaultdict(dict)
+
+    def _read(self):
+        self._debug['records']['start'] = self._io.pos()
+        self.records = []
+        i = 0
+        while not self._io.is_eof():
+            if not 'arr' in self._debug['records']:
+                self._debug['records']['arr'] = []
+            self._debug['records']['arr'].append({'start': self._io.pos()})
+            _t_records = Hccapx.HccapxRecord(self._io, self, self._root)
+            _t_records._read()
+            self.records.append(_t_records)
+            self._debug['records']['arr'][len(self.records) - 1]['end'] = self._io.pos()
+            i += 1
+
+        self._debug['records']['end'] = self._io.pos()
+
+    class HccapxRecord(KaitaiStruct):
+        SEQ_FIELDS = ["magic", "version", "ignore_replay_counter", "message_pair", "len_essid", "essid", "padding1", "keyver", "keymic", "mac_ap", "nonce_ap", "mac_station", "nonce_station", "len_eapol", "eapol", "padding2"]
+        def __init__(self, _io, _parent=None, _root=None):
+            self._io = _io
+            self._parent = _parent
+            self._root = _root if _root else self
+            self._debug = collections.defaultdict(dict)
+
+        def _read(self):
+            self._debug['magic']['start'] = self._io.pos()
+            self.magic = self._io.read_bytes(4)
+            self._debug['magic']['end'] = self._io.pos()
+            if not self.magic == b"\x48\x43\x50\x58":
+                raise kaitaistruct.ValidationNotEqualError(b"\x48\x43\x50\x58", self.magic, self._io, u"/types/hccapx_record/seq/0")
+            self._debug['version']['start'] = self._io.pos()
+            self.version = self._io.read_u4le()
+            self._debug['version']['end'] = self._io.pos()
+            self._debug['ignore_replay_counter']['start'] = self._io.pos()
+            self.ignore_replay_counter = self._io.read_bits_int_be(1) != 0
+            self._debug['ignore_replay_counter']['end'] = self._io.pos()
+            self._debug['message_pair']['start'] = self._io.pos()
+            self.message_pair = self._io.read_bits_int_be(7)
+            self._debug['message_pair']['end'] = self._io.pos()
+            self._io.align_to_byte()
+            self._debug['len_essid']['start'] = self._io.pos()
+            self.len_essid = self._io.read_u1()
+            self._debug['len_essid']['end'] = self._io.pos()
+            self._debug['essid']['start'] = self._io.pos()
+            self.essid = self._io.read_bytes(self.len_essid)
+            self._debug['essid']['end'] = self._io.pos()
+            self._debug['padding1']['start'] = self._io.pos()
+            self.padding1 = self._io.read_bytes((32 - self.len_essid))
+            self._debug['padding1']['end'] = self._io.pos()
+            self._debug['keyver']['start'] = self._io.pos()
+            self.keyver = self._io.read_u1()
+            self._debug['keyver']['end'] = self._io.pos()
+            self._debug['keymic']['start'] = self._io.pos()
+            self.keymic = self._io.read_bytes(16)
+            self._debug['keymic']['end'] = self._io.pos()
+            self._debug['mac_ap']['start'] = self._io.pos()
+            self.mac_ap = self._io.read_bytes(6)
+            self._debug['mac_ap']['end'] = self._io.pos()
+            self._debug['nonce_ap']['start'] = self._io.pos()
+            self.nonce_ap = self._io.read_bytes(32)
+            self._debug['nonce_ap']['end'] = self._io.pos()
+            self._debug['mac_station']['start'] = self._io.pos()
+            self.mac_station = self._io.read_bytes(6)
+            self._debug['mac_station']['end'] = self._io.pos()
+            self._debug['nonce_station']['start'] = self._io.pos()
+            self.nonce_station = self._io.read_bytes(32)
+            self._debug['nonce_station']['end'] = self._io.pos()
+            self._debug['len_eapol']['start'] = self._io.pos()
+            self.len_eapol = self._io.read_u2le()
+            self._debug['len_eapol']['end'] = self._io.pos()
+            self._debug['eapol']['start'] = self._io.pos()
+            self.eapol = self._io.read_bytes(self.len_eapol)
+            self._debug['eapol']['end'] = self._io.pos()
+            self._debug['padding2']['start'] = self._io.pos()
+            self.padding2 = self._io.read_bytes((256 - self.len_eapol))
+            self._debug['padding2']['end'] = self._io.pos()
+
+
+