qemux 1.0.0__tar.gz

qemux-1.0.0/LICENSE

@@ -0,0 +1,6 @@
+Copyright (c) 2026 Elseware. All rights reserved.
+
+This software and its associated documentation are proprietary and
+confidential. No part of this software may be copied, modified,
+distributed, sublicensed, or used without prior written permission from
+the copyright holder.

qemux-1.0.0/PKG-INFO

@@ -0,0 +1,39 @@
+Metadata-Version: 2.4
+Name: qemux
+Version: 1.0.0
+Summary: Dynamic binary instrumentation platform
+Author-email: Elseware <contact@elseware.io>
+License-Expression: LicenseRef-Proprietary
+Project-URL: homepage, https://elseware.io/qemux/
+Project-URL: documentation, https://qemux.elseware.io/
+Classifier: Development Status :: 3 - Alpha
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: typing_extensions
+Requires-Dist: psutil
+Requires-Dist: lief
+Requires-Dist: pypcode
+Requires-Dist: claripy
+Dynamic: license-file
+
+
+[![Test](https://github.com/johneiser/qemux/actions/workflows/test.yml/badge.svg?branch=main)](https://github.com/johneiser/qemux/actions/workflows/test.yml)
+
+# Qemux
+
+Qemux is a dynamic binary instrumentation platform, based on Qemu.
+
+```python
+from qemux import QxPopen, QxHarness
+with QxPopen(["qemu-x86_64", "/usr/bin/true"]) as qp:
+  qx = QxHarness(qp)
+  qx.step()
+```

qemux-1.0.0/README.md

@@ -0,0 +1,13 @@
+
+[![Test](https://github.com/johneiser/qemux/actions/workflows/test.yml/badge.svg?branch=main)](https://github.com/johneiser/qemux/actions/workflows/test.yml)
+
+# Qemux
+
+Qemux is a dynamic binary instrumentation platform, based on Qemu.
+
+```python
+from qemux import QxPopen, QxHarness
+with QxPopen(["qemu-x86_64", "/usr/bin/true"]) as qp:
+  qx = QxHarness(qp)
+  qx.step()
+```

qemux-1.0.0/pyproject.toml

@@ -0,0 +1,40 @@
+[build-system]
+requires = ["setuptools>=68"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "qemux"
+version = "1.0.0"
+description = "Dynamic binary instrumentation platform"
+readme = "README.md"
+requires-python = ">=3.9"
+license = "LicenseRef-Proprietary"
+license-files = ["LICENSE"]
+authors = [{ name = "Elseware", email = "contact@elseware.io" }]
+dependencies = [
+  "typing_extensions",
+  "psutil",
+  "lief",
+  "pypcode",
+  "claripy",
+]
+classifiers = [
+  "Development Status :: 3 - Alpha",
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3 :: Only",
+  "Programming Language :: Python :: 3.9",
+  "Programming Language :: Python :: 3.10",
+  "Programming Language :: Python :: 3.11",
+  "Programming Language :: Python :: 3.12",
+  "Programming Language :: Python :: 3.13",
+]
+
+[project.scripts]
+qxpy = "qemux.scripts.qxpy:main"
+
+[project.urls]
+homepage = "https://elseware.io/qemux/"
+documentation = "https://qemux.elseware.io/"
+
+[tool.setuptools.packages.find]
+where = ["src"]

qemux-1.0.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

qemux-1.0.0/src/qemux/__main__.py

@@ -0,0 +1,4 @@
+from .scripts.qxpy import main
+
+if __name__ == "__main__":
+    raise SystemExit(main())

qemux-1.0.0/src/qemux/scripts/qxpy.py

@@ -0,0 +1,24 @@
+"""A minimal python harness around a qemu process.
+
+```bash
+qxpy -- qemu-x86_64 /usr/bin/true
+```
+"""
+import argparse
+from ..utils.prompt import prompt
+
+def run(argv):
+    print(argv)
+    qx = None
+    prompt(qx=qx)
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="A minimal python harness around a qemu process.",
+        epilog="example: qxpy -- qemu-x86_64 /usr/bin/true")
+    parser.add_argument("argv", nargs="*", type=str, help="qemu process arguments (qemu-* ...)")
+    args = parser.parse_args()
+    run(args.argv)
+
+if __name__ == "__main__":
+    raise SystemExit(main())

qemux-1.0.0/src/qemux/targets/__init__.py

@@ -0,0 +1,20 @@
+"""Knowledge of target cpu registers."""
+
+import os, pkgutil
+from ctypes import Structure
+from typing import Type
+
+class QxRegisters(Structure):
+
+    @classmethod
+    def __class_getitem__(cls, arch: str) -> Type["QxRegisters"]:
+
+        # Find subclass matching target architecture
+        for c in cls.__subclasses__():
+            if c.__name__ == arch:
+                return c
+
+        raise NotImplementedError(cls, arch)
+
+# Automatically import residing architectures
+__all__ = [m.name for m in pkgutil.iter_modules([os.path.dirname(__file__)])]

qemux-1.0.0/src/qemux/targets/i386.py

@@ -0,0 +1,35 @@
+"""i386 processor specification.
+https://github.com/qemu/qemu/blob/master/target/i386/cpu.h
+"""
+__all__ = ["i386", "x86_64"]
+
+from . import QxRegisters
+from ctypes import Union, c_uint32, c_uint64
+
+class c_uint32_esp(Union):
+    _fields_ = [("esp", c_uint32), ("sp", c_uint32)]
+
+class i386(QxRegisters):
+    _anonymous_ = ("esp",)
+    _fields_ = [
+        ("eax", c_uint32), ("ecx", c_uint32),
+        ("edx", c_uint32), ("ebx", c_uint32),
+        ("esp", c_uint32_esp), ("ebp", c_uint32),
+        ("esi", c_uint32), ("edi", c_uint32),
+        ]
+
+class c_uint64_rsp(Union):
+    _fields_ = [("rsp", c_uint64), ("sp", c_uint64)]
+
+class x86_64(QxRegisters):
+    _anonymous_ = ("rsp",)
+    _fields_ = [
+        ("rax", c_uint64), ("rcx", c_uint64),
+        ("rdx", c_uint64), ("rbx", c_uint64),
+        ("rsp", c_uint64_rsp), ("rbp", c_uint64),
+        ("rsi", c_uint64), ("rdi", c_uint64),
+        ("r8", c_uint64), ("r9", c_uint64),
+        ("r10", c_uint64), ("r11", c_uint64),
+        ("r12", c_uint64), ("r13", c_uint64),
+        ("r14", c_uint64), ("r15", c_uint64),
+        ]

qemux-1.0.0/src/qemux/utils/callable.py

@@ -0,0 +1,36 @@
+__all__ = ["CallableType", "to_callable"]
+
+from functools import singledispatch, partial
+from collections.abc import Callable
+from typing import Union, Any
+
+CallableType = Union[None, bool, str, Callable]
+
+def none(*args: Any, **kwargs: Any) -> None:
+    return None
+
+def true(*args: Any, **kwargs: Any) -> bool:
+    return True
+
+def false(*args: Any, **kwargs: Any) -> bool:
+    return False
+
+@singledispatch
+def to_callable(x: CallableType) -> Callable:
+    raise TypeError(type(x))
+
+@to_callable.register
+def _(x: None) -> Callable:
+    return none
+
+@to_callable.register
+def _(x: bool) -> Callable:
+    return true if x else false
+
+@to_callable.register
+def _(x: str) -> Callable:
+    return partial(print, x)
+
+@to_callable.register
+def _(x: Callable) -> Callable:
+    return x

qemux-1.0.0/src/qemux/utils/pattern.py

@@ -0,0 +1,40 @@
+__all__ = ["PatternType", "to_pattern", "PatternDict"]
+
+import re, fnmatch
+from typing import Union, Any, TypeVar
+from functools import singledispatch
+from collections.abc import Iterator
+
+PatternType = Union[str, re.Pattern]
+
+@singledispatch
+def to_pattern(x: PatternType) -> re.Pattern:
+    raise TypeError(type(x))
+
+@to_pattern.register
+def _(x: str) -> re.Pattern:
+    return re.compile(fnmatch.translate(x), re.IGNORECASE)
+
+@to_pattern.register
+def _(x: re.Pattern) -> re.Pattern:
+    return x
+
+K = TypeVar("K", bound=str)
+V = TypeVar("V")
+
+class PatternDict(dict[K, V]):
+
+    def _find(self, item: PatternType) -> Iterator[tuple[K, V]]:
+        p = to_pattern(item)
+        for k, v in self.items():
+            if p.match(k):
+                yield k, v
+
+    def find(self, item: PatternType) -> list[tuple[K, V]]:
+        """Find items by pattern.
+
+        :param str item: item string or pattern
+        :return: items
+        :rtype: list[tuple[k, v]]
+        """
+        return list(self._find(item))

qemux-1.0.0/src/qemux/utils/pmmap.py

@@ -0,0 +1,7 @@
+__all__ = ["pmmap_ext"]
+
+import psutil
+
+# Fix breaking changes across psutil versions
+_ntp = getattr(psutil, "_ntp", getattr(psutil, "_psplatform"))
+pmmap_ext = _ntp.pmmap_ext

qemux-1.0.0/src/qemux/utils/prompt.py

@@ -0,0 +1,10 @@
+__all__ = ["prompt"]
+
+import code, readline, rlcompleter
+from pprint import pformat
+
+def prompt(**kwargs):
+    """Spawn an interactive python prompt with the given keyword arguments."""
+    readline.set_completer(rlcompleter.Completer(kwargs).complete)
+    readline.parse_and_bind("tab: complete")
+    code.interact(banner=pformat(kwargs), local=kwargs)

qemux-1.0.0/src/qemux/utils/range.py

@@ -0,0 +1,39 @@
+__all__ = ["RangeType", "to_range"]
+
+from functools import singledispatch
+from typing import Union
+from .pmmap import pmmap_ext
+
+RangeType = Union[int, slice, range, pmmap_ext]
+
+@singledispatch
+def to_range(x: RangeType, size: int = 1) -> range:
+    raise TypeError(type(x))
+
+@to_range.register
+def _(x: int, size: int = 1) -> range:
+    return range(x, x + size)
+
+@to_range.register
+def _(x: slice, size: int = 1) -> range:
+    if x.start is None or x.stop is None:
+        raise ValueError(x)
+    step = 1 if x.step is None else x.step
+    return range(x.start, x.stop, step)
+
+@to_range.register
+def _(x: range, size: int = 1) -> range:
+    return x
+
+# @to_range.register
+# def _(x: tuple[int, int]) -> range:
+#     if len(x) != 2:
+#         raise ValueError(x)
+#     return range(*x)
+
+@to_range.register
+def _(x: pmmap_ext) -> range:
+    a, b = x.addr.split("-")
+    start = int(a, 16)
+    end = int(b, 16)
+    return range(start, end)

qemux-1.0.0/src/qemux/utils/slice.py

@@ -0,0 +1,20 @@
+__all__ = ["SliceType", "to_slice"]
+
+from functools import singledispatch
+from typing import Union, Any
+
+SliceType = Union[int, slice]
+
+@singledispatch
+def to_slice(x: SliceType, size: int = 1, step: int = 1) -> slice:
+    raise TypeError(type(x))
+
+@to_slice.register
+def _(x: int, size: int = 1, step: int = 1) -> slice:
+    return slice(x, x + size, step)
+
+@to_slice.register
+def _(x: slice, size: int = 1, step: int = 1) -> slice:
+    if x.start is None or x.stop is None:
+        raise ValueError(x)
+    return x

qemux-1.0.0/src/qemux/utils/wait.py

@@ -0,0 +1,19 @@
+__all__ = ["WaitReadable"]
+
+import asyncio
+
+class WaitReadable:
+    """Convert a blocking file descriptor into an awaitable object."""
+
+    def __init__(self, fd):
+        self.fd = fd
+
+    def __enter__(self):
+        event = asyncio.Event()
+        loop = asyncio.get_running_loop()
+        loop.add_reader(self.fd, event.set)
+        return asyncio.create_task(event.wait())
+
+    def __exit__(self, exc_type, exc_value, traceback):
+        loop = asyncio.get_running_loop()
+        loop.remove_reader(self.fd)

qemux-1.0.0/src/qemux.egg-info/PKG-INFO

@@ -0,0 +1,39 @@
+Metadata-Version: 2.4
+Name: qemux
+Version: 1.0.0
+Summary: Dynamic binary instrumentation platform
+Author-email: Elseware <contact@elseware.io>
+License-Expression: LicenseRef-Proprietary
+Project-URL: homepage, https://elseware.io/qemux/
+Project-URL: documentation, https://qemux.elseware.io/
+Classifier: Development Status :: 3 - Alpha
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: typing_extensions
+Requires-Dist: psutil
+Requires-Dist: lief
+Requires-Dist: pypcode
+Requires-Dist: claripy
+Dynamic: license-file
+
+
+[![Test](https://github.com/johneiser/qemux/actions/workflows/test.yml/badge.svg?branch=main)](https://github.com/johneiser/qemux/actions/workflows/test.yml)
+
+# Qemux
+
+Qemux is a dynamic binary instrumentation platform, based on Qemu.
+
+```python
+from qemux import QxPopen, QxHarness
+with QxPopen(["qemu-x86_64", "/usr/bin/true"]) as qp:
+  qx = QxHarness(qp)
+  qx.step()
+```

qemux-1.0.0/src/qemux.egg-info/SOURCES.txt

@@ -0,0 +1,24 @@
+LICENSE
+README.md
+pyproject.toml
+src/qemux/__init__.py
+src/qemux/__main__.py
+src/qemux.egg-info/PKG-INFO
+src/qemux.egg-info/SOURCES.txt
+src/qemux.egg-info/dependency_links.txt
+src/qemux.egg-info/entry_points.txt
+src/qemux.egg-info/requires.txt
+src/qemux.egg-info/top_level.txt
+src/qemux/scripts/__init__.py
+src/qemux/scripts/qxpy.py
+src/qemux/targets/__init__.py
+src/qemux/targets/i386.py
+src/qemux/utils/__init__.py
+src/qemux/utils/callable.py
+src/qemux/utils/pattern.py
+src/qemux/utils/pmmap.py
+src/qemux/utils/prompt.py
+src/qemux/utils/range.py
+src/qemux/utils/slice.py
+src/qemux/utils/wait.py
+tests/test_cli.py

qemux-1.0.0/src/qemux.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

qemux-1.0.0/src/qemux.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+qxpy = qemux.scripts.qxpy:main

qemux-1.0.0/src/qemux.egg-info/requires.txt

@@ -0,0 +1,5 @@
+typing_extensions
+psutil
+lief
+pypcode
+claripy

qemux-1.0.0/src/qemux.egg-info/top_level.txt

@@ -0,0 +1 @@
+qemux

qemux-1.0.0/tests/test_cli.py

@@ -0,0 +1,10 @@
+import unittest
+
+import qemux
+
+class TestQemux(unittest.TestCase):
+    def test_nop(self) -> None:
+        self.assertEqual(True, True)
+
+if __name__ == "__main__":
+    unittest.main()