nubwen-rust-shell 0.1.1__py3-none-win_amd64.whl

nubwen_rust_shell-0.1.1.data/purelib/rust_shell_tool/__init__.py

@@ -0,0 +1 @@
+"""Command-line distribution of the native Rust Shell protection tool."""

nubwen_rust_shell-0.1.1.data/purelib/rust_shell_tool/__main__.py

@@ -0,0 +1,3 @@
+from .cli import main
+
+raise SystemExit(main())

nubwen_rust_shell-0.1.1.data/purelib/rust_shell_tool/_build_info.py

@@ -0,0 +1,3 @@
+PACKAGE_VERSION = '0.1.1'
+MANIFEST_SHA256 = '26432a3f6f66edeecab31a90a0b6e7d3c96158edd0c0f1d2b331ab5b922fc349'
+PAYLOAD_FILES = ('bin/rust-shell.exe', 'bin/rsh-server.exe', 'lib/rsh_runtime.lib', 'sdk/c/rust_shell.h', 'cmake/RustShell.cmake', 'scripts/setup-toolchain.ps1', 'scripts/extract-llvm.py', 'docs/security.md', 'docs/acceptance.md', 'manifest.json')

nubwen_rust_shell-0.1.1.data/purelib/rust_shell_tool/cli.py

@@ -0,0 +1,116 @@
+"""No runtime dependencies, network downloads or shell command construction."""
+import argparse
+import hashlib
+import json
+import os
+from pathlib import Path, PurePosixPath
+import platform
+import shutil
+import struct
+import subprocess
+import sys
+
+from . import _build_info
+
+
+def _unique_object(pairs):
+    result = {}
+    for key, value in pairs:
+        if key in result:
+            raise ValueError("duplicate manifest field")
+        result[key] = value
+    return result
+
+
+def _verified_bundle(package, expected_hash, expected_files):
+    manifest = package / "payload-manifest.json"
+    if manifest.is_symlink() or manifest.stat().st_size > 1024 * 1024:
+        raise ValueError("invalid payload manifest")
+    content = manifest.read_bytes()
+    if hashlib.sha256(content).hexdigest() != expected_hash:
+        raise ValueError("payload manifest checksum mismatch")
+    data = json.loads(content, object_pairs_hook=_unique_object)
+    if data["schema_version"] != 1 or data["target"] != "x86_64-pc-windows-msvc":
+        raise ValueError("unsupported payload identity")
+    native = (package / "native").resolve(strict=True)
+    seen = set()
+    for entry in data["files"]:
+        name = entry["path"]
+        relative = PurePosixPath(name)
+        if name not in expected_files or name in seen or relative.is_absolute() or ".." in relative.parts:
+            raise ValueError("unexpected payload path")
+        seen.add(name)
+        path = native.joinpath(*relative.parts)
+        if path.is_symlink() or not path.resolve(strict=True).is_relative_to(native) or not path.is_file():
+            raise ValueError("linked or missing payload")
+        if path.stat().st_size != entry["bytes"]:
+            raise ValueError("payload size mismatch: " + name)
+        with path.open("rb") as stream:
+            digest = hashlib.file_digest(stream, "sha256").hexdigest()
+        if digest != entry["sha256"]:
+            raise ValueError("payload checksum mismatch: " + name)
+    if seen != set(expected_files):
+        raise ValueError("incomplete payload inventory")
+    return native, data
+
+
+def _installed_bundle():
+    if sys.platform != "win32" or struct.calcsize("P") != 8 or platform.machine().lower() not in ("amd64", "x86_64"):
+        raise ValueError("Rust Shell requires Windows x64 and a 64-bit Python interpreter")
+    if not _build_info.MANIFEST_SHA256:
+        raise ValueError("native payload is not staged; install a built wheel")
+    return _verified_bundle(Path(__file__).parent, _build_info.MANIFEST_SHA256, _build_info.PAYLOAD_FILES)
+
+
+def _error(error):
+    print("rust-shell package: " + str(error), file=sys.stderr)
+    return 2
+
+
+def main():
+    try:
+        native, _ = _installed_bundle()
+        return subprocess.run([str(native / "bin/rust-shell.exe"), *sys.argv[1:]], shell=False).returncode
+    except (OSError, ValueError, KeyError, TypeError) as error:
+        return _error(error)
+    except KeyboardInterrupt:
+        return 130
+
+
+def package_main():
+    parser = argparse.ArgumentParser(description="Inspect verified Rust Shell paths or explicitly set up its toolchain.")
+    mode = parser.add_mutually_exclusive_group()
+    mode.add_argument("--home", action="store_true")
+    mode.add_argument("--setup-toolchain", action="store_true")
+    parser.add_argument("--install-rust", action="store_true")
+    args = parser.parse_args()
+    if args.install_rust and not args.setup_toolchain:
+        parser.error("--install-rust requires --setup-toolchain")
+    try:
+        native, data = _installed_bundle()
+        if args.setup_toolchain:
+            powershell = shutil.which("pwsh.exe")
+            if not powershell:
+                raise ValueError("PowerShell 7 (pwsh.exe) is required for explicit toolchain setup")
+            command = [powershell, "-NoProfile", "-File", str(native / "scripts/setup-toolchain.ps1")]
+            if args.install_rust:
+                command.append("-InstallRust")
+            environment = dict(os.environ)
+            environment["PATH"] = str(Path(sys.executable).parent) + os.pathsep + environment.get("PATH", "")
+            return subprocess.run(command, shell=False, env=environment).returncode
+        if args.home:
+            print(native)
+        else:
+            print(json.dumps({
+                "package_version": data["package_version"], "native_version": data["native_version"],
+                "native_source_revision": data["native_source_revision"], "home": str(native),
+                "cli": str(native / "bin/rust-shell.exe"), "server": str(native / "bin/rsh-server.exe"),
+                "runtime_library": str(native / "lib/rsh_runtime.lib"),
+                "c_header": str(native / "sdk/c/rust_shell.h"), "cmake": str(native / "cmake/RustShell.cmake"),
+                "upstream_manifest": str(native / "manifest.json"), "rust_sdk_bundled": False,
+            }, indent=2))
+        return 0
+    except (OSError, ValueError, KeyError, TypeError) as error:
+        return _error(error)
+    except KeyboardInterrupt:
+        return 130

nubwen_rust_shell-0.1.1.data/purelib/rust_shell_tool/native/cmake/RustShell.cmake

@@ -0,0 +1,79 @@
+include_guard(GLOBAL)
+include(CMakeParseArguments)
+
+# rust_shell_add_protected_library(kernels
+#   CONFIG protection.toml CLI /path/to/rust-shell.exe
+#   LLVM_BIN /path/to/llvm-22.1.6/bin RUNTIME_LIBRARY /path/to/rsh_runtime.lib
+#   SOURCES kernels.c rules.cpp INCLUDE_DIRECTORIES /path/to/headers)
+#
+# All translation units are merged before the one sealing operation. Use one
+# config/build_id and a fresh build directory per protected release build.
+function(rust_shell_add_protected_library target_name)
+  cmake_parse_arguments(RSH "" "CONFIG;CLI;LLVM_BIN;RUNTIME_LIBRARY" "SOURCES;INCLUDE_DIRECTORIES" ${ARGN})
+  foreach(required CONFIG CLI LLVM_BIN RUNTIME_LIBRARY)
+    if(NOT RSH_${required})
+      message(FATAL_ERROR "rust_shell_add_protected_library requires ${required}")
+    endif()
+  endforeach()
+  if(NOT WIN32 OR NOT CMAKE_SIZEOF_VOID_P EQUAL 8)
+    message(FATAL_ERROR "rust-shell v1 supports Windows x64 native builds")
+  endif()
+  if(NOT RSH_SOURCES)
+    message(FATAL_ERROR "No protected sources supplied")
+  endif()
+  get_filename_component(config "${RSH_CONFIG}" ABSOLUTE BASE_DIR "${CMAKE_CURRENT_SOURCE_DIR}")
+  get_property(configs GLOBAL PROPERTY RSH_USED_CONFIGS)
+  if(config IN_LIST configs)
+    message(FATAL_ERROR "Each protection config/build_id can be sealed once; combine sources in one protected library")
+  endif()
+  set_property(GLOBAL APPEND PROPERTY RSH_USED_CONFIGS "${config}")
+  foreach(tool clang-cl.exe llvm-link.exe llc.exe LLVM-C.dll)
+    if(NOT EXISTS "${RSH_LLVM_BIN}/${tool}")
+      message(FATAL_ERROR "Pinned LLVM tool missing: ${RSH_LLVM_BIN}/${tool}")
+    endif()
+  endforeach()
+  get_filename_component(sdk "${CMAKE_CURRENT_FUNCTION_LIST_DIR}/../sdk/c" ABSOLUTE)
+  set(includes "/I${sdk}")
+  foreach(directory IN LISTS RSH_INCLUDE_DIRECTORIES)
+    get_filename_component(directory "${directory}" ABSOLUTE BASE_DIR "${CMAKE_CURRENT_SOURCE_DIR}")
+    list(APPEND includes "/I${directory}")
+  endforeach()
+  set(work "${CMAKE_CURRENT_BINARY_DIR}/${target_name}.rsh")
+  file(MAKE_DIRECTORY "${work}")
+  set(bitcode_inputs)
+  set(index 0)
+  foreach(source IN LISTS RSH_SOURCES)
+    get_filename_component(source "${source}" ABSOLUTE BASE_DIR "${CMAKE_CURRENT_SOURCE_DIR}")
+    set(bitcode "${work}/source-${index}.bc")
+    math(EXPR index "${index}+1")
+    add_custom_command(OUTPUT "${bitcode}"
+      COMMAND "${RSH_LLVM_BIN}/clang-cl.exe" /c /MD /O1 /guard:cf
+        /clang:-emit-llvm /clang:-fno-vectorize /clang:-fno-slp-vectorize
+        /clang:-ffp-contract=off /clang:-o "/clang:${bitcode}"
+        ${includes} "${source}"
+      DEPENDS "${source}" "${sdk}/rust_shell.h"
+      COMMAND_EXPAND_LISTS VERBATIM
+      COMMENT "Compile protected source to LLVM bitcode")
+    list(APPEND bitcode_inputs "${bitcode}")
+  endforeach()
+  set(combined "${work}/combined.bc")
+  add_custom_command(OUTPUT "${combined}"
+    COMMAND "${RSH_LLVM_BIN}/llvm-link.exe" ${bitcode_inputs} -o "${combined}"
+    DEPENDS ${bitcode_inputs}
+    COMMAND_EXPAND_LISTS VERBATIM
+    COMMENT "Merge protected modules before sealing")
+  set(protected_object "${work}/protected.obj")
+  add_custom_command(OUTPUT "${protected_object}"
+    COMMAND "${CMAKE_COMMAND}" -E env
+      "RSH_LLVM_BIN=${RSH_LLVM_BIN}" "RSH_LLVM_DLL=${RSH_LLVM_BIN}/LLVM-C.dll"
+      "${RSH_CLI}" build --config "${config}" --input "${combined}" --output "${protected_object}"
+    DEPENDS "${combined}" "${config}" "${RSH_CLI}"
+    VERBATIM COMMENT "Validate and seal protected functions")
+  set_source_files_properties("${protected_object}" PROPERTIES GENERATED TRUE EXTERNAL_OBJECT TRUE)
+  add_library(${target_name} STATIC "${protected_object}")
+  set_target_properties(${target_name} PROPERTIES LINKER_LANGUAGE C)
+  target_include_directories(${target_name} INTERFACE "${sdk}")
+  target_link_libraries(${target_name} PUBLIC "${RSH_RUNTIME_LIBRARY}"
+    bcrypt crypt32 advapi32 userenv ws2_32 ntdll secur32)
+  target_link_options(${target_name} INTERFACE /GUARD:CF /DYNAMICBASE /NXCOMPAT)
+endfunction()

nubwen_rust_shell-0.1.1.data/purelib/rust_shell_tool/native/docs/acceptance.md

@@ -0,0 +1,33 @@
+# Acceptance and strength claims
+
+The implementation is a development build until every required gate has recorded evidence.
+Passing compilation or differential tests is not evidence of VMProtect-equivalent resistance.
+
+| Gate | Required evidence |
+|---|---|
+| Toolchain | Pinned Rust 1.97.1, LLVM 22.1.6 C API, clang-cl, llc and lld-link |
+| Correctness | C and Rust corpus, at least 20 functions, unseen inputs, loops, PHI, exceptional floating values, concurrent calls |
+| Coverage | All selected functions transformed; source-owned dependency archive markers included; unsupported required functions fail |
+| Packaging | No original selected function body, source debug metadata or build secrets in distributable files |
+| Licensing | Invalid signatures/key/binding/purpose rejected; expiry, renewal, DPAPI corruption, restart and rollback |
+| Windows | EXE and DLL, load/unload, native exceptions/unwind, ASLR/DEP/CFG and applicable CET, normal and signed artifacts |
+| Fuzzing | Saved campaigns and crash triage for the provided fuzz targets; smoke tests alone do not satisfy this gate |
+| Performance | Record end-to-end latency/throughput, startup, memory and size for real product workloads |
+| Endurance | Long-running product stress, allocation/callback failures, repeated DLL lifecycle |
+| Signing | User-owned production certificate and verified timestamped Authenticode signature |
+| Comparative strength | `benchmarks/protocol.toml`, licensed VMProtect, frozen models/tools/prompts, held-out tests, independent review |
+
+The adversary may possess the binaries, a valid license, an administrator account,
+static/dynamic tools and AI assistance. Issuer private keys and original source are
+outside that boundary. License validation and DPAPI are not claims of confidentiality
+against that administrator. Full-machine snapshot restoration defeats a purely local
+clock high-water mark.
+
+The native test corpus is public and must not be reused as the secret challenge set
+for competitive reverse-engineering claims. Generate and freeze independent hidden
+inputs and cases before a comparative run. Require a working recovered implementation,
+not just pseudocode. Record failed attempts and censored time limits.
+
+`verify` checks the supplied report's hash against the artifact. The report itself
+is not a signature or a trusted assertion. `--require-release` refuses outputs with
+pending commercial gates; a report is never automatically promoted by unit tests.

nubwen_rust_shell-0.1.1.data/purelib/rust_shell_tool/native/docs/security.md

@@ -0,0 +1,61 @@
+# Security and compatibility boundaries
+
+## Trust and key lifecycle
+
+The application embeds the issuer public key and expected product/build identity.
+Do not read that trust from the same replaceable file as a license. Activation codes,
+issuer private keys, content keys and build seeds belong outside distribution packages.
+Private files are created with an owner-only DACL before writing on Windows.
+
+Every build uses a fresh AES-256 key. Every sealing operation uses a CSPRNG nonce;
+callers cannot select one. Envelopes authenticate format, product, build and purpose.
+Function purpose is a digest of the function identity and source module identity,
+embedded independently by the wrapper. It is checked before decoding bytecode.
+Reproduction records retain the original ciphertext and verify the bytecode hash
+before replay, rather than reusing a nonce for different plaintext.
+
+The license signs the content-key digest and installation binding. A 30-day valid
+lease permits offline execution. Renewal can be refused server-side, but an existing
+offline lease remains valid until expiry. The local service is single-instance and
+binds only loopback; use a separately configured HTTPS reverse proxy for remote use.
+Reinitialize the runtime after renewal to adopt the new lease. The persisted clock
+high-water mark advances at cache initialization; calls check an in-memory mark.
+Passive calls never rewrite a cached lease, so they cannot overwrite a newer online
+renewal with an older session's bundle. Clock persistence is not a trusted clock.
+
+## Runtime and native ABI
+
+The interpreter has register/block/instruction/allocation and configurable fuel limits. Malformed
+or unsupported bytecode returns an error. Floating NaN payload equivalence is not
+promised across native platforms; numerical and ordered/unordered comparison semantics
+are tested. Generated wrappers use the embedded Trust.execution_fuel policy (default
+u64::MAX for native loop compatibility); fuzz and untrusted-input harnesses explicitly
+use small finite budgets. A product choosing a finite execution budget must include
+its longest valid workloads in acceptance. SIMD, atomics, volatile memory, indirect calls, inline assembly and unwinding
+through the VM require explicit rejection until implemented and independently tested.
+
+Native memory is an explicit per-thread capability. Register only live, valid ranges;
+do not concurrently mutate aliased writable storage. Clearing a registration revokes
+access for an already-running VM too. Registered external callbacks must implement
+the exact declared ABI and must not unwind. Callback/function registration is a trusted
+host operation, not a user-provided scripting facility.
+
+`rsh_vm_execute_bound` returns structured status codes without modifying the result
+on failure. A transparent replacement of an ordinary native function has no spare
+error channel in its original signature; its generated wrapper calls
+`rsh_protection_failure` and aborts on refusal. Hosts should preflight licensing and
+use the status-returning API when recoverable call errors are required. There is no
+unprotected native fallback. No initialization or network request is performed from
+DllMain.
+
+The basic layer currently provides limited integer-expression diversity and debug
+metadata removal; it is not a full control-flow flattening implementation. Reports
+distinguish transformed expressions from metadata-only functions. No anti-debugger,
+security-product interference, kernel driver or custom PE loader is required.
+
+## Reporting vulnerabilities
+
+Keep reproduction inputs, private keys and protected product code out of public
+issue trackers. Capture toolchain versions, the bounded failing input, and a minimal
+non-sensitive reproducer. Rotate affected build keys and issuer keys according to the
+incident's actual exposure; rotating a server key does not remotely erase offline copies.

nubwen_rust_shell-0.1.1.data/purelib/rust_shell_tool/native/manifest.json

@@ -0,0 +1,191 @@
+{
+  "schema_version": 1,
+  "name": "rust-shell",
+  "version": "0.1.1",
+  "release_tag": "v0.1.1",
+  "target": "x86_64-pc-windows-msvc",
+  "source_revision": "da11d588a1b484c8fc5d5af54764f8388d9407b6",
+  "source_tree_state": "clean",
+  "source_date_epoch": 315532800,
+  "toolchain": {
+    "rust": "1.97.1",
+    "llvm": "22.1.6",
+    "source": "repository_pins_not_binary_attestation",
+    "packager": "PowerShell 7.4.21 / .NET 8.0.32"
+  },
+  "package_signing": "unsigned",
+  "binary_signing": {
+    "bin/rust-shell.exe": {
+      "state": "unsigned",
+      "authenticode_status": "NotSigned"
+    },
+    "bin/rsh-server.exe": {
+      "state": "unsigned",
+      "authenticode_status": "NotSigned"
+    }
+  },
+  "validation_evidence": {
+    "status": "provided_passed",
+    "sha256": "61e170bace44207fc9b2c3be59e851f471ff4fb791fa71df045b45ae7e28bec6"
+  },
+  "commercial_acceptance": "pending",
+  "vmprotect_comparison": "not_run",
+  "ai_resistance": "unproven",
+  "files": [
+    {
+      "path": "README.md",
+      "bytes": 1453,
+      "sha256": "09050ae3137a2487abc13ec4288564a0f6e2298a2f7bbe4e90ce523cbb525f3e"
+    },
+    {
+      "path": "bin/rsh-server.exe",
+      "bytes": 2063360,
+      "sha256": "e5682ee6945af3fe32e0bea365a57f0ce2d5676410891425839fac704fc2bd1f"
+    },
+    {
+      "path": "bin/rust-shell.exe",
+      "bytes": 5137408,
+      "sha256": "9d9aff85fda3d77a93902de375050fc82809e627a77b3740cbed591b330da815"
+    },
+    {
+      "path": "cmake/RustShell.cmake",
+      "bytes": 4000,
+      "sha256": "b482febb2bd96976e0dc5a0c81d45816a6ac52c4c4940fb63d28cbc49c155731"
+    },
+    {
+      "path": "docs/acceptance.md",
+      "bytes": 2472,
+      "sha256": "5952f8fc61e9d4093532f3b243195a039e68528c916773edda609b99f29af41a"
+    },
+    {
+      "path": "docs/ci-cd.md",
+      "bytes": 3413,
+      "sha256": "00cf17755581d902253d7a9e9ed444d4d595acdab5efd195a1dfb813fb1423ad"
+    },
+    {
+      "path": "docs/security.md",
+      "bytes": 3903,
+      "sha256": "71d1f3e75951af4316c251c837f1d48f31cd10efec6087883ff09e063deeaaef"
+    },
+    {
+      "path": "lib/rsh_runtime.lib",
+      "bytes": 17575002,
+      "sha256": "70b253bd192876377cefdcdda70006e9d2bcc17cdfb73bd71ec2e90d2815a2a9"
+    },
+    {
+      "path": "scripts/extract-llvm.py",
+      "bytes": 1885,
+      "sha256": "b35268e5eca9bc92e490622574e85bb867d93c4108a717f17f6307bef6844856"
+    },
+    {
+      "path": "scripts/setup-toolchain.ps1",
+      "bytes": 1540,
+      "sha256": "8e44e65980febd52fd324f216c60c2ca8572bd85b90af94db1d66fba4c36d106"
+    },
+    {
+      "path": "sdk/c/README.md",
+      "bytes": 2863,
+      "sha256": "0749c7b1f141262ad26108fec1126ba4bbe885502aead3e97520de071b5043cd"
+    },
+    {
+      "path": "sdk/c/rust_shell.h",
+      "bytes": 3038,
+      "sha256": "f4f4d6eff30e41356b6a0282da841b4ae0c6fbfa521af595c5de0caf71c14b08"
+    },
+    {
+      "path": "sdk/rust/Cargo.toml",
+      "bytes": 522,
+      "sha256": "c610821bc39d29005d7364e79d2744115b780e4167f894224d99be20ea970f24"
+    },
+    {
+      "path": "sdk/rust/crates/rsh-license/Cargo.toml",
+      "bytes": 652,
+      "sha256": "f4d340588ba179b83f0547ec7f6d2d9c0b7653b28da32a9907b25a8e29ccf2ca"
+    },
+    {
+      "path": "sdk/rust/crates/rsh-license/src/cache.rs",
+      "bytes": 6361,
+      "sha256": "36b05a6755ff928f5febfe40c52e9d6c4afa26f3e09914dff24f3a85b676d6e3"
+    },
+    {
+      "path": "sdk/rust/crates/rsh-license/src/lib.rs",
+      "bytes": 24725,
+      "sha256": "5f22bd8c68ce2c587af335b04dd5b5a17f17282ac325a96a0feab6feb8a72c5b"
+    },
+    {
+      "path": "sdk/rust/crates/rsh-license/src/private_file.rs",
+      "bytes": 9144,
+      "sha256": "be82af2ba49fc380bba23a1958e8523851ab4f47bc5012284a5f71b5ccda28a4"
+    },
+    {
+      "path": "sdk/rust/crates/rsh-macros/Cargo.toml",
+      "bytes": 212,
+      "sha256": "91a8e3291b4a1ad0b985b4a2606f58c20878e5fcdf29996330248377190e8e58"
+    },
+    {
+      "path": "sdk/rust/crates/rsh-macros/src/lib.rs",
+      "bytes": 1417,
+      "sha256": "b21f0e55515519a4cab6b66f829c8e2427a167823d3b9bc9d994c36de8c7ab81"
+    },
+    {
+      "path": "sdk/rust/crates/rsh-runtime/Cargo.toml",
+      "bytes": 354,
+      "sha256": "4e3efd8f9b3e326ad1148a63bd547114521b63841887b06ebc5ee881f4b8fd58"
+    },
+    {
+      "path": "sdk/rust/crates/rsh-runtime/src/lib.rs",
+      "bytes": 25729,
+      "sha256": "7a122d2fdc55f97f78b1169dd62a5e105ff7cb51fb9edb087c51b5e62008aada"
+    },
+    {
+      "path": "sdk/rust/crates/rsh-sdk/Cargo.toml",
+      "bytes": 191,
+      "sha256": "be7cb38eee67263225f289a7dc523dd3000d6c46108ee09fe5d281af2ce4b1ad"
+    },
+    {
+      "path": "sdk/rust/crates/rsh-sdk/src/lib.rs",
+      "bytes": 278,
+      "sha256": "69d2a798df6caa80518693822fbae2e16bf62e93642c8bd2cdf841b44f954d3d"
+    },
+    {
+      "path": "sdk/rust/crates/rsh-vm/Cargo.toml",
+      "bytes": 179,
+      "sha256": "f5dfcd5811a60a5257a1ab9d7e5371bc0a4c4a5ed6762772228cb9ca52dc63c3"
+    },
+    {
+      "path": "sdk/rust/crates/rsh-vm/README.md",
+      "bytes": 2984,
+      "sha256": "826ea14f728421db1108e36847f3e2eb3edc90765c01d41a37bb476b742b7550"
+    },
+    {
+      "path": "sdk/rust/crates/rsh-vm/src/codec.rs",
+      "bytes": 21917,
+      "sha256": "cccf1f8e21f5d3cb58bc751f0841e394b3cec834301cbac73b40e911fe86b9d2"
+    },
+    {
+      "path": "sdk/rust/crates/rsh-vm/src/diversify.rs",
+      "bytes": 12522,
+      "sha256": "d26b65cec178dc3e3f6a4820b60aa005ed755753cef62ab7e46e9ecdf690dd87"
+    },
+    {
+      "path": "sdk/rust/crates/rsh-vm/src/execute.rs",
+      "bytes": 18984,
+      "sha256": "0ad145a0b35bcbc149a7f48bb1fd821306d375173115c509a04b478c00b90754"
+    },
+    {
+      "path": "sdk/rust/crates/rsh-vm/src/lib.rs",
+      "bytes": 8120,
+      "sha256": "ed06f56872a527cb906bef6589bb08069cdde66848fc36c57592312a24559d30"
+    },
+    {
+      "path": "sdk/rust/crates/rsh-vm/src/validate.rs",
+      "bytes": 16701,
+      "sha256": "277dbdbc916702ad5ee4e00fc2c68fdc72b31952948c70d0a43230ad94ad1e02"
+    },
+    {
+      "path": "sdk/rust/rust-toolchain.toml",
+      "bytes": 145,
+      "sha256": "7dbe0e914284b765040c4f8094bca38dafab815b44494e654c303cb0b7ec0c2d"
+    }
+  ]
+}

nubwen_rust_shell-0.1.1.data/purelib/rust_shell_tool/native/scripts/extract-llvm.py

@@ -0,0 +1,42 @@
+"""Extract the verified LLVM archive without relying on Windows tar's XZ support."""
+import pathlib
+import sys
+import tarfile
+
+ARCHIVE_ROOT = "clang+llvm-22.1.6-x86_64-pc-windows-msvc"
+TOOLS = {
+    "clang-cl.exe", "llc.exe", "lld-link.exe", "LLVM-C.dll", "llvm-as.exe",
+    "llvm-ar.exe", "llvm-lib.exe", "llvm-link.exe", "llvm-dis.exe",
+    "llvm-nm.exe", "llvm-readobj.exe", "llvm-objdump.exe", "opt.exe",
+}
+
+
+def extract(archive, destination):
+    destination = pathlib.Path(destination).resolve()
+    destination.mkdir(parents=True, exist_ok=True)
+    with tarfile.open(archive, "r|xz") as source:
+        for member in source:
+            parts = pathlib.PurePosixPath(member.name).parts
+            if not parts or parts[0] != ARCHIVE_ROOT or ".." in parts:
+                raise ValueError("Unexpected archive path")
+            if len(parts) == 1:
+                continue
+            if not (member.isfile() or member.isdir()):
+                raise ValueError("LLVM archive links and special files are not supported")
+            member.name = str(pathlib.PurePosixPath(*parts[1:]))
+            target = (destination / member.name).resolve()
+            if not target.is_relative_to(destination):
+                raise ValueError("Archive member escapes destination")
+            # Keep only this project's tools and Clang's builtin headers/runtime.
+            if not ((len(parts) == 3 and parts[1] == "bin" and parts[2] in TOOLS)
+                    or member.name.startswith("lib/clang/")):
+                continue
+            source.extract(member, destination, filter="data")
+
+
+if __name__ == "__main__":
+    extract(*sys.argv[1:])
+    destination = pathlib.Path(sys.argv[2])
+    missing = sorted(name for name in TOOLS if not (destination / "bin" / name).is_file())
+    if missing:
+        raise ValueError("Incomplete LLVM tool installation: " + ", ".join(missing))

nubwen_rust_shell-0.1.1.data/purelib/rust_shell_tool/native/scripts/setup-toolchain.ps1

@@ -0,0 +1,24 @@
+param([switch]$InstallRust)
+$ErrorActionPreference = 'Stop'
+$root = Split-Path -Parent $PSScriptRoot
+$tools = Join-Path $root '.tools'
+$archive = Join-Path $tools 'clang+llvm-22.1.6-x86_64-pc-windows-msvc.tar.xz'
+$destination = Join-Path $tools 'llvm-22.1.6'
+$expected = '657343edf361ca463bd642e39c74b251c6338b96cdbd55ff277555298b027696'
+$url = 'https://github.com/llvm/llvm-project/releases/download/llvmorg-22.1.6/clang%2Bllvm-22.1.6-x86_64-pc-windows-msvc.tar.xz'
+New-Item -ItemType Directory -Force -Path $tools | Out-Null
+if (-not (Test-Path -LiteralPath $archive)) { Invoke-WebRequest -Uri $url -OutFile $archive }
+if ((Get-FileHash -LiteralPath $archive -Algorithm SHA256).Hash.ToLowerInvariant() -ne $expected) {
+    throw 'LLVM archive hash mismatch. Nothing will be extracted.'
+}
+$python = (Get-Command python.exe -ErrorAction Stop).Source
+& $python -c 'import lzma, tarfile; assert hasattr(tarfile, "data_filter")'
+if ($LASTEXITCODE -ne 0) { throw 'Python 3.11.9+ with lzma and tarfile.data_filter is required' }
+& $python (Join-Path $PSScriptRoot 'extract-llvm.py') $archive $destination
+if ($LASTEXITCODE -ne 0) { throw 'LLVM extraction failed' }
+if ($InstallRust) {
+    & rustup toolchain install 1.97.1 --profile minimal --component rustfmt,clippy,llvm-tools-preview --target x86_64-pc-windows-msvc
+    if ($LASTEXITCODE -ne 0) { throw 'Rust toolchain setup failed' }
+}
+Write-Output "Verified LLVM 22.1.6 is available at $destination"
+Write-Output 'Use an x64 Visual Studio developer environment with Windows SDK installed.'

nubwen_rust_shell-0.1.1.data/purelib/rust_shell_tool/native/sdk/c/rust_shell.h

@@ -0,0 +1,73 @@
+#ifndef RUST_SHELL_H
+#define RUST_SHELL_H
+
+#include <stdint.h>
+#include <stdbool.h>
+
+/* Compile protected translation units with the pinned clang-cl toolchain.
+ * Whole functions are selected; optimized IR unsupported by the backend makes
+ * the protection build fail. This marker is not protection by itself. */
+#if defined(__clang__)
+#define RSH_PROTECT __attribute__((section("rsh.protect"), noinline))
+#elif defined(_MSC_VER)
+#define RSH_PROTECT __declspec(code_seg("rsh.protect")) __declspec(noinline)
+#else
+#error "rust-shell v1 requires the Windows x64 LLVM toolchain"
+#endif
+
+#if defined(__cplusplus)
+#define RSH_NORETURN [[noreturn]]
+extern "C" {
+#else
+#define RSH_NORETURN _Noreturn
+#endif
+
+enum rsh_status {
+    RSH_OK = 0,
+    RSH_INVALID_INPUT = 1,
+    RSH_LICENSE_ERROR = 2,
+    RSH_EXECUTION_ERROR = 3,
+    RSH_NOT_INITIALIZED = 4,
+    RSH_INTERNAL_ERROR = 5
+};
+
+/* Trust JSON is application-owned. Do not obtain the trusted issuer public key
+ * from an unverified activation response. Buffers need not be NUL terminated. */
+int32_t rsh_initialize(const uint8_t *trust_json, uint64_t trust_len,
+                       const uint8_t *activation_json, uint64_t activation_len);
+int32_t rsh_initialize_cached(const uint8_t *trust_json, uint64_t trust_len,
+                              const uint8_t *utf8_path, uint64_t path_len);
+int32_t rsh_license_status(void);
+/* Call after joining all callers, before unloading a DLL containing the runtime. */
+int32_t rsh_shutdown(void);
+uint64_t rsh_last_error(uint8_t *buffer, uint64_t capacity);
+
+/* Regions are thread-local and must remain live until cleared. Writable
+ * regions require exclusive access during protected calls. */
+int32_t rsh_register_memory(uint8_t *pointer, uint64_t length, bool writable);
+void rsh_clear_memory_regions(void);
+
+/* A null output with zero capacity queries the decrypted size. The host owns
+ * clearing copied plaintext. The resource name is trusted application policy. */
+int32_t rsh_decrypt_resource(const uint8_t *payload, uint64_t payload_len,
+                             const uint8_t *name, uint64_t name_len,
+                             uint8_t *output, uint64_t capacity, uint64_t *written);
+
+typedef int32_t (*rsh_host_callback)(const uint64_t *arguments, uint64_t count,
+                                    uint64_t *result);
+int32_t rsh_register_host(const uint8_t *signature_json, uint64_t signature_len,
+                          rsh_host_callback callback);
+
+/* Generated wrappers use the bound entrypoint. Payloads must come from the
+ * authenticated build pipeline. A failed protected call terminates instead of
+ * fabricating an algorithm result. */
+int32_t rsh_vm_execute_bound(const uint8_t *payload, uint64_t payload_len,
+                            const uint8_t *purpose, uint64_t purpose_len,
+                            const uint64_t *arguments, uint64_t argument_count,
+                            uint64_t *result);
+RSH_NORETURN void rsh_protection_failure(int32_t status);
+
+#if defined(__cplusplus)
+}
+#endif
+#endif