unidecompiler-plugin-python-pyc 0.1.1__py3-none-any.whl

unidecompiler_plugin_python_pyc/plugin.py

@@ -0,0 +1,47 @@
+from __future__ import annotations
+
+from unidecompiler.core.ir import ModuleIR
+from unidecompiler.plugins import FrontendModule
+from unidecompiler_plugin_python_pyc.lifter import lift_pyc_module
+from unidecompiler_plugin_python_pyc.pyc import decode_pyc, looks_like_pyc
+from unidecompiler_plugin_python_pyc.simulation import PythonPycSimulationAdapter
+from unidecompiler_plugin_python_pyc.support import PYTHON_PYC_VERSION_SUPPORT
+
+
+class PythonPycFrontendPlugin:
+    id = "python-pyc"
+    display_name = "Python bytecode"
+    supported_inputs = (".pyc",)
+    version_support = PYTHON_PYC_VERSION_SUPPORT
+    simulation_adapter = PythonPycSimulationAdapter
+
+    def can_load(self, data: bytes, filename: str | None = None) -> bool:
+        return looks_like_pyc(data)
+
+    def decode(self, data: bytes, filename: str | None = None) -> FrontendModule:
+        module = decode_pyc(data, filename)
+        return FrontendModule(
+            frontend_id=self.id,
+            payload=module,
+            metadata={
+                "filename": filename,
+                "format": "pyc",
+                "version": module.magic.hex(),
+                "endianness": "little",
+                "debug_info_present": True,
+                "diagnostics": [],
+                "python": {
+                    "flags": module.flags,
+                    "decoder": "stdlib-marshal-dis",
+                    "root_name": module.code.name,
+                },
+            },
+        )
+
+    def lift(self, module: FrontendModule) -> ModuleIR:
+        if module.frontend_id != self.id:
+            raise TypeError(
+                f"Python pyc frontend cannot lift module from {module.frontend_id!r}"
+            )
+
+        return lift_pyc_module(module.payload, module.metadata)

unidecompiler_plugin_python_pyc/pyc.py

@@ -0,0 +1,136 @@
+from __future__ import annotations
+
+import dis
+import importlib.util
+import marshal
+import types
+from dataclasses import dataclass
+
+from unidecompiler.plugins import FrontendDecodeError
+
+
+PYC_MIN_HEADER_SIZE = 16
+
+
+class PycDecodeError(FrontendDecodeError):
+    pass
+
+
+@dataclass(frozen=True)
+class PycInstruction:
+    offset: int
+    opname: str
+    arg: int | None
+    argval: object
+    argrepr: str
+    starts_line: int | None
+
+
+@dataclass(frozen=True)
+class PycExceptionRegion:
+    """Decoded CPython exception-table entry expressed as bytecode offsets."""
+
+    start: int
+    end: int
+    target: int
+    depth: int
+    lasti: bool
+
+
+@dataclass(frozen=True)
+class PycCodeObject:
+    name: str
+    argcount: int
+    kwonlyargcount: int
+    flags: int
+    varnames: tuple[str, ...]
+    cellvars: tuple[str, ...]
+    freevars: tuple[str, ...]
+    names: tuple[str, ...]
+    consts: tuple[object, ...]
+    instructions: tuple[PycInstruction, ...]
+    exception_regions: tuple[PycExceptionRegion, ...]
+    children: tuple["PycCodeObject", ...]
+
+
+@dataclass(frozen=True)
+class PycModule:
+    magic: bytes
+    flags: int
+    code: PycCodeObject
+    filename: str | None = None
+
+
+def looks_like_pyc(data: bytes) -> bool:
+    return len(data) > PYC_MIN_HEADER_SIZE and data[:4] == importlib.util.MAGIC_NUMBER and data[4:8] in {
+        b"\x00\x00\x00\x00",
+        b"\x01\x00\x00\x00",
+        b"\x03\x00\x00\x00",
+    }
+
+
+def decode_pyc(data: bytes, filename: str | None = None) -> PycModule:
+    if len(data) <= PYC_MIN_HEADER_SIZE:
+        raise PycDecodeError("truncated pyc file")
+
+    flags = int.from_bytes(data[4:8], "little")
+    try:
+        code = marshal.loads(data[PYC_MIN_HEADER_SIZE:])
+    except Exception as error:  # marshal gives several low-level exceptions.
+        raise PycDecodeError(f"failed to unmarshal pyc code object: {error}") from error
+
+    if not isinstance(code, types.CodeType):
+        raise PycDecodeError("pyc payload is not a code object")
+
+    return PycModule(
+        magic=data[:4],
+        flags=flags,
+        code=_decode_code_object(code),
+        filename=filename,
+    )
+
+
+def _decode_code_object(code: types.CodeType) -> PycCodeObject:
+    children = tuple(
+        _decode_code_object(const)
+        for const in code.co_consts
+        if isinstance(const, types.CodeType)
+    )
+    return PycCodeObject(
+        name=code.co_name,
+        argcount=code.co_argcount,
+        kwonlyargcount=code.co_kwonlyargcount,
+        flags=code.co_flags,
+        varnames=tuple(code.co_varnames),
+        cellvars=tuple(code.co_cellvars),
+        freevars=tuple(code.co_freevars),
+        names=tuple(code.co_names),
+        consts=tuple(
+            f"<code {const.co_name}>"
+            if isinstance(const, types.CodeType)
+            else const
+            for const in code.co_consts
+        ),
+        instructions=tuple(
+            PycInstruction(
+                offset=instruction.offset,
+                opname=instruction.opname,
+                arg=instruction.arg,
+                argval=instruction.argval,
+                argrepr=instruction.argrepr,
+                starts_line=instruction.starts_line,
+            )
+            for instruction in dis.get_instructions(code)
+        ),
+        exception_regions=tuple(
+            PycExceptionRegion(
+                start=entry.start,
+                end=entry.end,
+                target=entry.target,
+                depth=entry.depth,
+                lasti=entry.lasti,
+            )
+            for entry in dis.Bytecode(code).exception_entries
+        ),
+        children=children,
+    )

unidecompiler_plugin_python_pyc/simulation.py

@@ -0,0 +1,54 @@
+"""Optional Python function lookup for the decoupled generic IR simulator."""
+
+from __future__ import annotations
+
+
+class PythonPycSimulationAdapter:
+    frontend_id = "python-pyc"
+
+    def resolve_function(self, query, decoded_module, lifted_module):
+        from unidecompiler_simulator import NotHandled, ResolvedFunction
+
+        if not isinstance(query, str):
+            return NotHandled
+        context = self._function_context(lifted_module.functions)
+        matches = context.get(query, ())
+        if len(matches) != 1:
+            return NotHandled
+        return ResolvedFunction(matches[0], context=context, identifier=query)
+
+    def resolve_global(self, name, context):
+        from unidecompiler_simulator import IntrinsicCall, NotHandled, ResolvedFunction
+
+        if name in {"len", "range", "iter_has_next", "iter_next"}:
+            return IntrinsicCall(name)
+
+        if not isinstance(context, dict):
+            return NotHandled
+        matches = context.get(name, ())
+        if len(matches) != 1:
+            return NotHandled
+        return ResolvedFunction(matches[0], context=context, identifier=name)
+
+    def list_simulation_targets(self, decoded_module, lifted_module):
+        from unidecompiler_simulator import SimulationTargetCandidate
+
+        context = self._function_context(lifted_module.functions)
+        return tuple(
+            SimulationTargetCandidate(name, name)
+            for name, matches in context.items()
+            if len(matches) == 1
+        )
+
+    @classmethod
+    def _function_context(cls, functions):
+        context = {}
+        for function in cls._walk(functions):
+            context.setdefault(function.name, []).append(function)
+        return {name: tuple(matches) for name, matches in context.items()}
+
+    @staticmethod
+    def _walk(functions):
+        for function in functions:
+            yield function
+            yield from PythonPycSimulationAdapter._walk(function.nested_functions)

unidecompiler_plugin_python_pyc/support.py

@@ -0,0 +1,15 @@
+from __future__ import annotations
+
+import importlib.util
+import sys
+
+from unidecompiler.plugins import FrontendVersionSupport
+
+
+PYTHON_PYC_VERSION_SUPPORT = FrontendVersionSupport(
+    family="CPython bytecode",
+    versions=(f"{sys.version_info.major}.{sys.version_info.minor}",),
+    parser="stdlib marshal/dis",
+    status="current interpreter magic decode + thin opcode submission",
+    notes=(f"magic={importlib.util.MAGIC_NUMBER.hex()}",),
+)

unidecompiler_plugin_python_pyc-0.1.1.dist-info/METADATA

@@ -0,0 +1,26 @@
+Metadata-Version: 2.4
+Name: unidecompiler-plugin-python-pyc
+Version: 0.1.1
+Summary: Python bytecode frontend plugin for unidecompiler
+Author-email: Wker <1670133844@qq.com>
+License-Expression: AGPL-3.0-or-later
+Project-URL: Homepage, https://github.com/Wker666/unidecompiler
+Project-URL: Repository, https://github.com/Wker666/unidecompiler
+Project-URL: Issues, https://github.com/Wker666/unidecompiler/issues
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+Requires-Dist: unidecompiler<0.2.0,>=0.1.1
+
+# unidecompiler-plugin-python-pyc
+
+Frontend plugin for Python `.pyc` bytecode files. It decodes Python bytecode
+and submits neutral thin IR to `unidecompiler`, where recovery and pseudocode
+rendering occur.
+
+Install with:
+
+```sh
+python -m pip install unidecompiler-plugin-python-pyc
+```
+
+The plugin is discovered automatically by compatible CLI and GUI hosts.

unidecompiler_plugin_python_pyc-0.1.1.dist-info/RECORD

@@ -0,0 +1,11 @@
+unidecompiler_plugin_python_pyc/__init__.py,sha256=hVoovcpsYUC1mNX2ZOw_gITFH8JIUelqdWQgjjzgNW4,29
+unidecompiler_plugin_python_pyc/lifter.py,sha256=v4aPxsvUEbrfL4o3ZxF_VLhNVO3AaXF0fpAxbbQhwzY,38731
+unidecompiler_plugin_python_pyc/plugin.py,sha256=xYGl2QaPOIQ8B3VQQSYC3SFLOeaA-VtN_uuD-d09yBk,1759
+unidecompiler_plugin_python_pyc/pyc.py,sha256=0q43DH5fBOokSHi1FtgU1jsi8eRlTY7Xj-uae5_UkkU,3597
+unidecompiler_plugin_python_pyc/simulation.py,sha256=_ZsytvY2-GpCHKcRKfL25ty2yLdEtPnT0tqkT4TVDWo,1965
+unidecompiler_plugin_python_pyc/support.py,sha256=U44X6nRbjIKJKZoCtdCzmJ7ryShbGpUxGKytUrUAYRo,449
+unidecompiler_plugin_python_pyc-0.1.1.dist-info/METADATA,sha256=qzsLA5mhEF42F-ElMP3LcngyAY7Ya9ypWOS8qS17XdI,878
+unidecompiler_plugin_python_pyc-0.1.1.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+unidecompiler_plugin_python_pyc-0.1.1.dist-info/entry_points.txt,sha256=iV_iOT4G7hxzxMFz9NSZNpSNrn6XrGXkgepQU2fYvww,102
+unidecompiler_plugin_python_pyc-0.1.1.dist-info/top_level.txt,sha256=WUNxCWlylGTlts-LVvZMQycGC4zmeBfASTYVoZWQAW8,32
+unidecompiler_plugin_python_pyc-0.1.1.dist-info/RECORD,,

unidecompiler_plugin_python_pyc-0.1.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

unidecompiler_plugin_python_pyc-0.1.1.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[unidecompiler.frontends]
+python-pyc = unidecompiler_plugin_python_pyc.plugin:PythonPycFrontendPlugin

unidecompiler_plugin_python_pyc-0.1.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+unidecompiler_plugin_python_pyc