vardoger-vm 0.3.1__tar.gz

vardoger_vm-0.3.1/.clang-format

@@ -0,0 +1 @@
+BasedOnStyle: Google

vardoger_vm-0.3.1/.github/workflows/ci.yml

@@ -0,0 +1,38 @@
+name: ci
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+
+jobs:
+  build:
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu-latest, macos-latest]
+    runs-on: ${{ matrix.os }}
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Install native dependencies (Linux)
+        if: runner.os == 'Linux'
+        run: sudo apt-get update && sudo apt-get install -y libunicorn-dev libcapstone-dev zlib1g-dev ninja-build
+
+      - name: Install native dependencies (macOS)
+        if: runner.os == 'macOS'
+        run: brew install unicorn capstone zlib ninja
+
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.11"
+
+      - name: Build the C library
+        run: |
+          cmake -S . -B build -G Ninja -DCMAKE_BUILD_TYPE=Release
+          cmake --build build
+
+      - name: Import smoke test
+        run: |
+          pip install .
+          python -c "import vardoger; print('vardoger OK:', vardoger.VM)"

vardoger_vm-0.3.1/.github/workflows/publish.yml

@@ -0,0 +1,70 @@
+name: publish
+
+# Tag a release (git tag v0.1.0 && git push --tags) to build wheels and publish them to PyPI.
+on:
+  push:
+    tags: ["v*"]
+  workflow_dispatch:
+
+jobs:
+  wheels:
+    name: wheels ${{ matrix.archs }} on ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      # Build every wheel on a runner NATIVE to its arch — no emulation, no
+      # cross-compile. before-all installs Unicorn/Capstone via each platform's
+      # package manager (brew / build-from-source), which only provides the
+      # runner's own arch, so cross-building can't link.
+      # macos_target must match the OS the runner's brew bottles are built for:
+      # delocate rejects bundling a lib whose min-target exceeds the wheel's tag,
+      # and brew's unicorn/capstone on macos-14 require 14.0 (macos-13 -> 13.0).
+      matrix:
+        include:
+          - { os: ubuntu-latest, archs: x86_64 }     # manylinux x86_64
+          - { os: ubuntu-24.04-arm, archs: aarch64 } # manylinux aarch64 (native ARM runner)
+          - { os: macos-14, archs: arm64, macos_target: "14.0" }  # Apple Silicon
+        #  - { os: macos-13, archs: x86_64, macos_target: "13.0" } # Intel
+    runs-on: ${{ matrix.os }}
+    steps:
+      - uses: actions/checkout@v4
+
+      # cibuildwheel builds one wheel per Python version inside a manylinux (or macOS) environment.
+      # before-all there installs Unicorn/Capstone/zlib (see pyproject.toml), and auditwheel/delocate
+      # bundle them into the wheel so it needs nothing at install time.
+      - uses: pypa/cibuildwheel@v2.21
+        env:
+          CIBW_ARCHS: ${{ matrix.archs }}
+          # Ignored by the Linux builds; on macOS it sets the wheel's min-target
+          # to match the bundled brew libs so delocate accepts them.
+          MACOSX_DEPLOYMENT_TARGET: ${{ matrix.macos_target }}
+
+      - uses: actions/upload-artifact@v4
+        with:
+          name: wheels-${{ matrix.os }}-${{ matrix.archs }}
+          path: wheelhouse/*.whl
+
+  sdist:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.11"
+      - run: pipx run build --sdist
+      - uses: actions/upload-artifact@v4
+        with:
+          name: sdist
+          path: dist/*.tar.gz
+
+  publish:
+    needs: [wheels, sdist]
+    runs-on: ubuntu-latest
+    environment: pypi
+    permissions:
+      id-token: write        # PyPI Trusted Publishing (OIDC); no API token to store.
+    steps:
+      - uses: actions/download-artifact@v4
+        with:
+          path: dist
+          merge-multiple: true
+      - uses: pypa/gh-action-pypi-publish@release/v1

vardoger_vm-0.3.1/.gitignore

@@ -0,0 +1,25 @@
+# Build output
+build/
+cmake-build-*/
+dist/
+wheelhouse/
+_skbuild/
+*.egg-info/
+
+# Native artifacts
+*.so
+*.dylib
+*.dll
+*.o
+*.a
+
+# Python
+__pycache__/
+*.pyc
+.venv/
+.pytest_cache/
+
+# Editor / OS
+.idea/
+.vscode/
+.DS_Store

vardoger_vm-0.3.1/CMakeLists.txt

@@ -0,0 +1,58 @@
+cmake_minimum_required(VERSION 3.24)
+project(vardoger LANGUAGES CXX VERSION 0.3.1)
+
+set(CMAKE_CXX_STANDARD 20)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+
+find_package(PkgConfig REQUIRED)
+pkg_check_modules(UNICORN REQUIRED IMPORTED_TARGET unicorn)
+pkg_check_modules(CAPSTONE REQUIRED IMPORTED_TARGET capstone)
+pkg_check_modules(ZLIB REQUIRED IMPORTED_TARGET zlib)
+
+# The engine, grouped by subsystem. See include/vardoger/ for the public headers.
+add_library(vardoger_core
+        # engine: CPU, memory, scheduling
+        core/engine/engine.cpp
+        core/engine/disassembler.cpp
+        core/engine/tracer.cpp
+        core/engine/memory.cpp
+        core/engine/trampoline.cpp
+        core/engine/scheduler.cpp
+        core/engine/gdb_stub.cpp
+        # elf: the loader
+        core/elf/elf_loader.cpp
+        # android: the guest OS surface (libc stubs, syscalls, vfs, context)
+        core/android/stubs.cpp
+        core/android/android_env.cpp
+        core/android/system.cpp
+        core/android/vfs.cpp
+        core/android/syscalls.cpp
+        # jni: the Java bridge and runtime
+        core/jni/java_runtime.cpp
+        core/jni/jni.cpp
+        # dex: parser, mini-Dalvik, lifecycle
+        core/dex/dex_file.cpp
+        core/dex/dalvik.cpp
+        core/dex/lifecycle.cpp
+        # art: the class-resolution runtime and ART bring-up
+        core/art/art_runtime.cpp
+        core/art/art_bringup.cpp
+        # extract: payload capture and debug hooks
+        core/extract/extractor.cpp
+        core/extract/debug_hooks.cpp
+)
+target_include_directories(vardoger_core PUBLIC include third_party)
+target_link_libraries(vardoger_core PUBLIC PkgConfig::UNICORN PkgConfig::CAPSTONE PkgConfig::ZLIB)
+set_property(TARGET vardoger_core PROPERTY POSITION_INDEPENDENT_CODE ON)
+
+# vardoger_capi: the flat C ABI that the Python package drives through ctypes. It is a shared
+# library so ctypes can dlopen it, and it pulls in the whole engine.
+add_library(vardoger_capi SHARED core/py/vardoger_capi.cpp)
+target_link_libraries(vardoger_capi PRIVATE vardoger_core PkgConfig::UNICORN PkgConfig::CAPSTONE PkgConfig::ZLIB)
+set_target_properties(vardoger_capi PROPERTIES POSITION_INDEPENDENT_CODE ON)
+
+# When scikit-build-core drives the build for a wheel, drop the shared library straight into the
+# installed package so the ctypes loader finds it next to __init__.py.
+if(DEFINED SKBUILD)
+    install(TARGETS vardoger_capi LIBRARY DESTINATION vardoger RUNTIME DESTINATION vardoger)
+endif()