polyfile-weave 0.5.5__py3-none-any.whl

polyfile/kaitai/parsers/zisofs.py

@@ -0,0 +1,158 @@
+# 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 Zisofs(KaitaiStruct):
+    """zisofs is a compression format for files on ISO9660 file system. It has
+    limited support across operating systems, mainly Linux kernel. Typically a
+    directory tree is first preprocessed by mkzftree (from the zisofs-tools
+    package before being turned into an ISO9660 image by mkisofs, genisoimage
+    or similar tool. The data is zlib compressed.
+    
+    The specification here describes the structure of a file that has been
+    preprocessed by mkzftree, not of a full ISO9660 ziso. Data is not
+    decompressed, as blocks with length 0 have a special meaning. Decompression
+    and deconstruction of this data should be done outside of Kaitai Struct.
+    
+    .. seealso::
+       Source - https://web.archive.org/web/20200612093441/https://dev.lovelyhq.com/libburnia/web/-/wikis/zisofs
+    """
+    SEQ_FIELDS = ["header", "block_pointers"]
+    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['header']['start'] = self._io.pos()
+        self._raw_header = self._io.read_bytes(16)
+        _io__raw_header = KaitaiStream(BytesIO(self._raw_header))
+        self.header = Zisofs.Header(_io__raw_header, self, self._root)
+        self.header._read()
+        self._debug['header']['end'] = self._io.pos()
+        self._debug['block_pointers']['start'] = self._io.pos()
+        self.block_pointers = [None] * ((self.header.num_blocks + 1))
+        for i in range((self.header.num_blocks + 1)):
+            if not 'arr' in self._debug['block_pointers']:
+                self._debug['block_pointers']['arr'] = []
+            self._debug['block_pointers']['arr'].append({'start': self._io.pos()})
+            self.block_pointers[i] = self._io.read_u4le()
+            self._debug['block_pointers']['arr'][i]['end'] = self._io.pos()
+
+        self._debug['block_pointers']['end'] = self._io.pos()
+
+    class Header(KaitaiStruct):
+        SEQ_FIELDS = ["magic", "uncompressed_size", "len_header", "block_size_log2", "reserved"]
+        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(8)
+            self._debug['magic']['end'] = self._io.pos()
+            if not self.magic == b"\x37\xE4\x53\x96\xC9\xDB\xD6\x07":
+                raise kaitaistruct.ValidationNotEqualError(b"\x37\xE4\x53\x96\xC9\xDB\xD6\x07", self.magic, self._io, u"/types/header/seq/0")
+            self._debug['uncompressed_size']['start'] = self._io.pos()
+            self.uncompressed_size = self._io.read_u4le()
+            self._debug['uncompressed_size']['end'] = self._io.pos()
+            self._debug['len_header']['start'] = self._io.pos()
+            self.len_header = self._io.read_u1()
+            self._debug['len_header']['end'] = self._io.pos()
+            if not self.len_header == 4:
+                raise kaitaistruct.ValidationNotEqualError(4, self.len_header, self._io, u"/types/header/seq/2")
+            self._debug['block_size_log2']['start'] = self._io.pos()
+            self.block_size_log2 = self._io.read_u1()
+            self._debug['block_size_log2']['end'] = self._io.pos()
+            if not  ((self.block_size_log2 == 15) or (self.block_size_log2 == 16) or (self.block_size_log2 == 17)) :
+                raise kaitaistruct.ValidationNotAnyOfError(self.block_size_log2, self._io, u"/types/header/seq/3")
+            self._debug['reserved']['start'] = self._io.pos()
+            self.reserved = self._io.read_bytes(2)
+            self._debug['reserved']['end'] = self._io.pos()
+            if not self.reserved == b"\x00\x00":
+                raise kaitaistruct.ValidationNotEqualError(b"\x00\x00", self.reserved, self._io, u"/types/header/seq/4")
+
+        @property
+        def block_size(self):
+            if hasattr(self, '_m_block_size'):
+                return self._m_block_size if hasattr(self, '_m_block_size') else None
+
+            self._m_block_size = (1 << self.block_size_log2)
+            return self._m_block_size if hasattr(self, '_m_block_size') else None
+
+        @property
+        def num_blocks(self):
+            """ceil(uncompressed_size / block_size)."""
+            if hasattr(self, '_m_num_blocks'):
+                return self._m_num_blocks if hasattr(self, '_m_num_blocks') else None
+
+            self._m_num_blocks = (self.uncompressed_size // self.block_size + (1 if (self.uncompressed_size % self.block_size) != 0 else 0))
+            return self._m_num_blocks if hasattr(self, '_m_num_blocks') else None
+
+
+    class Block(KaitaiStruct):
+        SEQ_FIELDS = []
+        def __init__(self, ofs_start, ofs_end, _io, _parent=None, _root=None):
+            self._io = _io
+            self._parent = _parent
+            self._root = _root if _root else self
+            self.ofs_start = ofs_start
+            self.ofs_end = ofs_end
+            self._debug = collections.defaultdict(dict)
+
+        def _read(self):
+            pass
+
+        @property
+        def len_data(self):
+            if hasattr(self, '_m_len_data'):
+                return self._m_len_data if hasattr(self, '_m_len_data') else None
+
+            self._m_len_data = (self.ofs_end - self.ofs_start)
+            return self._m_len_data if hasattr(self, '_m_len_data') else None
+
+        @property
+        def data(self):
+            if hasattr(self, '_m_data'):
+                return self._m_data if hasattr(self, '_m_data') else None
+
+            io = self._root._io
+            _pos = io.pos()
+            io.seek(self.ofs_start)
+            self._debug['_m_data']['start'] = io.pos()
+            self._m_data = io.read_bytes(self.len_data)
+            self._debug['_m_data']['end'] = io.pos()
+            io.seek(_pos)
+            return self._m_data if hasattr(self, '_m_data') else None
+
+
+    @property
+    def blocks(self):
+        if hasattr(self, '_m_blocks'):
+            return self._m_blocks if hasattr(self, '_m_blocks') else None
+
+        self._debug['_m_blocks']['start'] = self._io.pos()
+        self._m_blocks = [None] * (self.header.num_blocks)
+        for i in range(self.header.num_blocks):
+            if not 'arr' in self._debug['_m_blocks']:
+                self._debug['_m_blocks']['arr'] = []
+            self._debug['_m_blocks']['arr'].append({'start': self._io.pos()})
+            _t__m_blocks = Zisofs.Block(self.block_pointers[i], self.block_pointers[(i + 1)], self._io, self, self._root)
+            _t__m_blocks._read()
+            self._m_blocks[i] = _t__m_blocks
+            self._debug['_m_blocks']['arr'][i]['end'] = self._io.pos()
+
+        self._debug['_m_blocks']['end'] = self._io.pos()
+        return self._m_blocks if hasattr(self, '_m_blocks') else None
+
+

polyfile/kaitai/parsers/zx_spectrum_tap.py

@@ -0,0 +1,184 @@
+# 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 ZxSpectrumTap(KaitaiStruct):
+    """TAP files are used by emulators of ZX Spectrum computer (released in
+    1982 by Sinclair Research). TAP file stores blocks of data as if
+    they are written to magnetic tape, which was used as primary media
+    for ZX Spectrum. Contents of this file can be viewed as a very
+    simple linear filesystem, storing named files with some basic
+    metainformation prepended as a header.
+    
+    .. seealso::
+       Source - https://sinclair.wiki.zxnet.co.uk/wiki/TAP_format
+    """
+
+    class FlagEnum(Enum):
+        header = 0
+        data = 255
+
+    class HeaderTypeEnum(Enum):
+        program = 0
+        num_array = 1
+        char_array = 2
+        bytes = 3
+    SEQ_FIELDS = ["blocks"]
+    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['blocks']['start'] = self._io.pos()
+        self.blocks = []
+        i = 0
+        while not self._io.is_eof():
+            if not 'arr' in self._debug['blocks']:
+                self._debug['blocks']['arr'] = []
+            self._debug['blocks']['arr'].append({'start': self._io.pos()})
+            _t_blocks = ZxSpectrumTap.Block(self._io, self, self._root)
+            _t_blocks._read()
+            self.blocks.append(_t_blocks)
+            self._debug['blocks']['arr'][len(self.blocks) - 1]['end'] = self._io.pos()
+            i += 1
+
+        self._debug['blocks']['end'] = self._io.pos()
+
+    class Block(KaitaiStruct):
+        SEQ_FIELDS = ["len_block", "flag", "header", "data", "headerless_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['len_block']['start'] = self._io.pos()
+            self.len_block = self._io.read_u2le()
+            self._debug['len_block']['end'] = self._io.pos()
+            self._debug['flag']['start'] = self._io.pos()
+            self.flag = KaitaiStream.resolve_enum(ZxSpectrumTap.FlagEnum, self._io.read_u1())
+            self._debug['flag']['end'] = self._io.pos()
+            if  ((self.len_block == 19) and (self.flag == ZxSpectrumTap.FlagEnum.header)) :
+                self._debug['header']['start'] = self._io.pos()
+                self.header = ZxSpectrumTap.Header(self._io, self, self._root)
+                self.header._read()
+                self._debug['header']['end'] = self._io.pos()
+
+            if self.len_block == 19:
+                self._debug['data']['start'] = self._io.pos()
+                self.data = self._io.read_bytes((self.header.len_data + 4))
+                self._debug['data']['end'] = self._io.pos()
+
+            if self.flag == ZxSpectrumTap.FlagEnum.data:
+                self._debug['headerless_data']['start'] = self._io.pos()
+                self.headerless_data = self._io.read_bytes((self.len_block - 1))
+                self._debug['headerless_data']['end'] = self._io.pos()
+
+
+
+    class ProgramParams(KaitaiStruct):
+        SEQ_FIELDS = ["autostart_line", "len_program"]
+        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['autostart_line']['start'] = self._io.pos()
+            self.autostart_line = self._io.read_u2le()
+            self._debug['autostart_line']['end'] = self._io.pos()
+            self._debug['len_program']['start'] = self._io.pos()
+            self.len_program = self._io.read_u2le()
+            self._debug['len_program']['end'] = self._io.pos()
+
+
+    class BytesParams(KaitaiStruct):
+        SEQ_FIELDS = ["start_address", "reserved"]
+        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['start_address']['start'] = self._io.pos()
+            self.start_address = self._io.read_u2le()
+            self._debug['start_address']['end'] = self._io.pos()
+            self._debug['reserved']['start'] = self._io.pos()
+            self.reserved = self._io.read_bytes(2)
+            self._debug['reserved']['end'] = self._io.pos()
+
+
+    class Header(KaitaiStruct):
+        SEQ_FIELDS = ["header_type", "filename", "len_data", "params", "checksum"]
+        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['header_type']['start'] = self._io.pos()
+            self.header_type = KaitaiStream.resolve_enum(ZxSpectrumTap.HeaderTypeEnum, self._io.read_u1())
+            self._debug['header_type']['end'] = self._io.pos()
+            self._debug['filename']['start'] = self._io.pos()
+            self.filename = KaitaiStream.bytes_strip_right(self._io.read_bytes(10), 32)
+            self._debug['filename']['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['params']['start'] = self._io.pos()
+            _on = self.header_type
+            if _on == ZxSpectrumTap.HeaderTypeEnum.program:
+                self.params = ZxSpectrumTap.ProgramParams(self._io, self, self._root)
+                self.params._read()
+            elif _on == ZxSpectrumTap.HeaderTypeEnum.num_array:
+                self.params = ZxSpectrumTap.ArrayParams(self._io, self, self._root)
+                self.params._read()
+            elif _on == ZxSpectrumTap.HeaderTypeEnum.char_array:
+                self.params = ZxSpectrumTap.ArrayParams(self._io, self, self._root)
+                self.params._read()
+            elif _on == ZxSpectrumTap.HeaderTypeEnum.bytes:
+                self.params = ZxSpectrumTap.BytesParams(self._io, self, self._root)
+                self.params._read()
+            self._debug['params']['end'] = self._io.pos()
+            self._debug['checksum']['start'] = self._io.pos()
+            self.checksum = self._io.read_u1()
+            self._debug['checksum']['end'] = self._io.pos()
+
+
+    class ArrayParams(KaitaiStruct):
+        SEQ_FIELDS = ["reserved", "var_name", "reserved1"]
+        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['reserved']['start'] = self._io.pos()
+            self.reserved = self._io.read_u1()
+            self._debug['reserved']['end'] = self._io.pos()
+            self._debug['var_name']['start'] = self._io.pos()
+            self.var_name = self._io.read_u1()
+            self._debug['var_name']['end'] = self._io.pos()
+            self._debug['reserved1']['start'] = self._io.pos()
+            self.reserved1 = self._io.read_bytes(2)
+            self._debug['reserved1']['end'] = self._io.pos()
+            if not self.reserved1 == b"\x00\x80":
+                raise kaitaistruct.ValidationNotEqualError(b"\x00\x80", self.reserved1, self._io, u"/types/array_params/seq/2")
+
+
+

polyfile/kaitaimatcher.py

@@ -0,0 +1,113 @@
+import base64
+import re
+from typing import Dict, Iterator, List, Tuple, Type
+
+from kaitaistruct import KaitaiStruct, KaitaiStructError
+
+from .kaitai.parser import ASTNode, KaitaiParser, RootNode
+from .kaitai.parsers.gif import Gif
+from .kaitai.parsers.jpeg import Jpeg
+from .kaitai.parsers.png import Png
+from .logger import getStatusLogger
+from .polyfile import register_parser, InvalidMatch, Match, Parser, Submatch
+
+
+log = getStatusLogger(__name__)
+
+KAITAI_MIME_MAPPING: Dict[str, str] = {
+    "image/gif": "image/gif.ksy",
+    "image/png": "image/png.ksy",
+    "image/jpeg": "image/jpeg.ksy",
+    "image/vnd.microsoft.icon": "image/ico.ksy",
+#    "image/wmf": "image/wmf.ksy",  # there is currently a problem with this parser in Python
+    "application/vnd.nitf": "image/nitf.ksy",
+    "application/vnd.tcpdump.pcap": "network/pcap.ksy",
+    "application/x-sqlite3": "database/sqlite3.ksy",
+    "application/x-rar": "archive/rar.ksy",
+    "font/sfnt": "font/ttf.ksy",
+    "application/x-pie-executable": "executable/elf.ksy",
+    "application/gzip": "archive/gzip.ksy",
+    "application/x-xar": "archive/xar.ksy",
+    "application/x-python-code": "executable/python_pyc_27.ksy",
+    "application/x-shockwave-flash": "executable/swf.ksy",
+    "application/x-doom": "game/doom_wad.ksy",
+    "image/x-dcx": "image/pcx_dcx.ksy",
+    "model/gltf-binary": "3d/gltf_binary.ksy",
+    "application/x-rpm": "archive/rpm.ksy",
+    "application/x-cpio": "archive/cpio_old_le.ksy",
+    "image/x-gimp-gbr": "image/gimp_brush.ksy",
+#    "application/dicom": "image/dicom.ksy",  # there is currently a problem with this parser in Python
+    "image/bmp": "image/bmp.ksy",
+    "application/x-blender": "media/blender_blend.ksy",
+    "audio/x-voc": "media/creative_voice_file.ksy",
+    "audio/midi": "media/standard_midi_file.ksy",
+    "application/dime": "network/dime_message.ksy",
+    "application/bson": "serialization/bson.ksy",
+    "application/x-ms-shortcut": "windows/windows_lnk_file.ksy",
+    "application/x-java-applet": "executable/java_class.ksy",
+    # Uncomment this when/if Kaitai fixes its upstream compilation bug for ICC
+# (https://github.com/kaitai-io/kaitai_struct_formats/issues/347#ref-commit-fde2866)
+#    "application/vnd.iccprofile": "image/icc_4.ksy"
+}
+
+IMAGE_MIMETYPES = {
+    "image/gif",
+    "image/jpeg",
+    "image/png",
+    "image/bmp",
+}
+
+MIME_BY_PARSER: Dict[Type[KaitaiStruct], str] = {}
+
+
+def ast_to_matches(ast: RootNode, parent: Match) -> Iterator[Submatch]:
+    stack: List[Tuple[Match, ASTNode]] = [(parent, ast)]
+    while stack:
+        parent, node = stack.pop()
+
+        new_node = Submatch(
+            name=node.name,
+            match_obj=node.raw_value,
+            relative_offset=node.start - parent.offset,
+            length=len(node.segment),
+            parent=parent
+        )
+
+        if node is ast and node.obj.__class__ in MIME_BY_PARSER:  # type: ignore
+            mtype = MIME_BY_PARSER[node.obj.__class__]  # type: ignore
+            if mtype in IMAGE_MIMETYPES:  # type: ignore
+                # this is an image type, so create a preview
+                new_node.img_data = f"data:{mtype};base64,{base64.b64encode(ast.raw_value).decode('utf-8')}"
+
+        yield new_node
+        stack.extend(reversed([(new_node, c) for c in node.children]))
+
+
+for mimetype, kaitai_path in KAITAI_MIME_MAPPING.items():
+    class parse_:
+        kaitai_parser = KaitaiParser.load(kaitai_path)
+
+        def __call__(self, stream, match):
+            try:
+                ast = self.kaitai_parser.parse(stream).ast
+            except KaitaiStructError as e:
+                log.warning(f"Error parsing {stream.name} using {self.kaitai_parser}: {e!s}")
+                raise InvalidMatch()
+            except Exception as e:
+                log.error(f"Unexpected exception parsing {stream.name} using {self.kaitai_parser}: {e!s}")
+                raise InvalidMatch()
+            yield from ast_to_matches(ast, parent=match)
+
+    func_name = mimetype.replace("/", "_").replace("-", "_")
+
+    parse_.__name__ = f"{parse_.__name__}{func_name}"
+    parse_.__qualname__ = f"{parse_.__qualname__}{func_name}"
+
+    register_parser(mimetype)(parse_())
+
+    MIME_BY_PARSER[parse_.kaitai_parser.struct_type] = mimetype
+
+del func_name
+del kaitai_path
+del mimetype
+del parse_

polyfile/languagematcher.py

@@ -0,0 +1,217 @@
+from enum import Enum
+from typing import List, Optional, Sequence
+
+from .logger import StatusLogger
+from .polyfile import Match, Submatch, register_parser
+from .magic import AbsoluteOffset, FailedTest, MagicMatcher, MagicTest, MatchedTest, TestResult, TestType
+
+
+log = StatusLogger("polyfile")
+
+
+class BFCommandType(Enum):
+    LOOP_START = "["
+    LOOP_END = "]"
+    INPUT = ","
+    PRINT = "."
+    SHIFT_RIGHT = ">"
+    SHIFT_LEFT = "<"
+    INCREMENT = "+"
+    DECREMENT = "-"
+
+
+class BFCommand:
+    def __init__(self, command_type: BFCommandType, offset: int):
+        self.command_type: BFCommandType = command_type
+        self.offset: int = offset
+
+    def __str__(self):
+        return self.command_type.value
+
+    def __repr__(self):
+        return f"{self.__class__.__name__}(command_type={self.command_type!r}, offset={self.offset!r})"
+
+
+class BFParseError(RuntimeError):
+    def __init__(self, message: str, offset: int):
+        super().__init__(message)
+        self.offset: int = offset
+
+
+class BFProgram:
+    def __init__(self, commands: Sequence[BFCommand]):
+        self.commands: Sequence[BFCommand] = commands
+        self._num_loops: Optional[int] = None
+
+    @property
+    def num_loops(self) -> int:
+        if self._num_loops is None:
+            self._num_loops = sum(1 for c in self.commands if c.command_type == BFCommandType.LOOP_START)
+        return self._num_loops
+
+    def __bytes__(self):
+        return bytes(bytearray(
+            [ord(c.command_type.value) for c in self.commands]
+        ))
+
+    def __str__(self):
+        ret = []
+        indent = 0
+        for c in self.commands:
+            command_type = c.command_type
+            if command_type == BFCommandType.LOOP_START:
+                indent_str = "    " * indent
+                ret.append(f"\n{indent_str}[\n{indent_str}{indent_str}")
+                indent += 1
+            elif command_type == BFCommandType.LOOP_END:
+                indent -= 1
+                indent_str = "    " * indent
+                ret.append(f"\n{indent_str}]\n{indent_str}")
+            else:
+                ret.append(command_type.value)
+        return "".join(ret)
+
+    @classmethod
+    def parse(cls, data: bytes) -> "BFProgram":
+        opened = 0
+        offset = 0
+        commands: List[BFCommand] = []
+        for offset, c in enumerate(data):
+            try:
+                command = BFCommand(BFCommandType(chr(c)), offset)
+            except ValueError:
+                continue
+            commands.append(command)
+            if command.command_type == BFCommandType.LOOP_START:
+                opened += 1
+            elif command.command_type == BFCommandType.LOOP_END:
+                opened -= 1
+                if opened < 0:
+                    break
+        if opened != 0:
+            raise BFParseError("unbalanced square brackets", offset=offset)
+        return BFProgram(tuple(commands))
+
+
+class BFMatcher(MagicTest):
+    min_bf_commands: int = 24
+    """The minimum number of BF commands that must appear for the file to be classified as a BF program
+
+    This is an arbitrary value; the default is high enough to eliminate most false-positives, at the expense of missing
+    the detection of shorter BrainFu programs.
+    """
+
+    min_bf_loops: int = 2
+    """The minimum number of BF loops that must appear for the file to be classified as a BF program
+
+    This is an arbitrary value that we have set high enough to eliminate most false-positives, at the expense of missing
+    the detection of simpler BrainFu programs.
+    """
+
+    reject_arithmetical_noops: bool = False
+    """If True, then reject any BF program that contains arithmetic that cancels itself
+
+    For example: `-+` or `+-`
+    """
+
+    def __init__(self):
+        super().__init__(
+            offset=AbsoluteOffset(0),
+            mime="application/x-brainfuck",
+            extensions=("bf",),
+            message="Brainfu** Program"
+        )
+
+    def subtest_type(self) -> TestType:
+        # BF can technically contain any arbitrary bytes, which are interpreted as comments,
+        # so declare this as a binary test so we don't miss BF polyglots.
+        return TestType.BINARY
+
+    def test(self, data: bytes, absolute_offset: int, parent_match: Optional[TestResult]) -> TestResult:
+        try:
+            program = BFProgram.parse(data[absolute_offset:])
+        except BFParseError as e:
+            return FailedTest(self, offset=e.offset, message=str(e))
+        important_commands = frozenset(BFCommandType) - {BFCommandType.INPUT}
+        unique_commands = {c.command_type for c in program.commands}
+        if program.commands:
+            first_command = program.commands[0].offset
+            last_command = program.commands[-1].offset
+        else:
+            first_command = 0
+            last_command = 0
+        if important_commands - unique_commands:
+            return FailedTest(self, offset=first_command,
+                              message=f"missing commands "
+                                      f"{', '.join((cmd.value for cmd in important_commands - unique_commands))}")
+        elif self.min_bf_loops > program.num_loops:
+            return FailedTest(self, offset=first_command, message=f"expected at least {self.min_bf_loops} BrainFu loops "
+                                                                  f"but only found {program.num_loops}")
+        elif self.min_bf_commands > len(program.commands):
+            return FailedTest(self, offset=first_command, message=f"expected at least {self.min_bf_commands} BrainFu "
+                                                                  f"commands but only found {len(program.commands)}")
+        elif self.reject_arithmetical_noops:
+            for c1, c2 in zip(program.commands, program.commands[1:]):
+                if c2.offset == c1.offset + 1 and \
+                        {c1.command_type, c2.command_type} == {BFCommandType.INCREMENT, BFCommandType.DECREMENT}:
+                    return FailedTest(self, offset=c1.offset, message="BrainFu program contains arithmetic that "
+                                                                      "cancels itself out")
+        else:
+            assert 0 <= first_command <= last_command
+            return MatchedTest(self, value=bytes(program), offset=first_command,
+                               length=last_command - first_command)
+
+
+MagicMatcher.DEFAULT_INSTANCE.add(BFMatcher())
+
+
+@register_parser("application/x-brainfuck")
+def parse_bf(file_stream, match):
+    commands = {
+        ord('['): "LoopStart",
+        ord(']'): "LoopEnd",
+        ord('.'): "Print",
+        ord('+'): "Increment",
+        ord('-'): "Decrement",
+        ord('>'): "MoveRight",
+        ord('<'): "MoveLeft",
+        ord(','): "Input",
+    }
+    relative_offset = 0
+    loop_stack = []
+
+    while True:
+        b = file_stream.read(1)
+        if len(b) < 1:
+            break
+        if b[0] in commands:
+            if loop_stack:
+                parent: Match = loop_stack[-1]
+            else:
+                parent = match
+            if b == b"[":
+                loop = Submatch(
+                    "Loop",
+                    match_obj="",
+                    relative_offset=relative_offset,
+                    parent=parent,
+                    matcher=match.matcher
+                )
+                yield loop
+                loop_stack.append(loop)
+                parent = loop
+            elif b == b"]":
+                if not loop_stack:
+                    log.warning(f"Unexpected closing bracket at offset {relative_offset + match.offset}")
+                else:
+                    loop_stack.pop()
+            s = Submatch(
+                commands[b[0]],
+                match_obj=b,
+                relative_offset=relative_offset - (parent.offset - match.offset),
+                length=1,
+                parent=parent,
+                matcher=match.matcher
+            )
+            yield s
+        relative_offset += 1