kami-armor 0.1.0__tar.gz

kami_armor-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 yuge666
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

kami_armor-0.1.0/PKG-INFO

@@ -0,0 +1,97 @@
+Metadata-Version: 2.4
+Name: kami-armor
+Version: 0.1.0
+Summary: 卡密 license-system client SDK + server-bound Python source protection (encrypt / obfuscate / Cython / one-command packaging)
+Author: yuge666
+License: MIT
+Project-URL: Homepage, https://pypi.org/project/kami-armor/
+Keywords: license,卡密,drm,obfuscation,source-protection,pyarmor-alternative,cython,activation
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Security
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: cryptography>=41.0
+Requires-Dist: py-machineid>=0.6
+Provides-Extra: harden
+Requires-Dist: cython>=3.0; extra == "harden"
+Requires-Dist: pyinstaller>=6.0; extra == "harden"
+Requires-Dist: tomli; python_version < "3.11" and extra == "harden"
+Dynamic: license-file
+
+# kami-armor
+
+**卡密（license）系统的 Python 客户端 SDK + 服务端绑定密钥的源码保护工具链。**
+
+- 🔑 **客户端 SDK**（`kami_client`）：在线激活 / 校验 / 心跳 / 解绑、价值闸门调用、按授权解锁加密资源、完整性自测量——只内嵌**公钥**，离线验签，永远拿不到可伪造卡密的私钥。
+- 🛡 **源码保护**（`kami_armor`）：把 Python 模块加密成密文随程序分发，**发布物里没有密钥**，运行时经服务器按授权下发密钥、内存解密导入。比 PyArmor 强在一个结构性维度——**密钥托管**（PyArmor 的密钥静态内嵌、可离线脱壳；这里密钥根本不在文件里，可吊销/溯源）。
+- 🧩 **混淆 + 原生编译 + 一键打包**：自建免费的改名/字符串加密（symtable 保证不改坏代码）、Cython 原生编译皇冠模块、`kami-armor harden` 一条命令 混淆→Cython→加密→PyInstaller/Nuitka 出 exe。
+
+> ⚠️ 这是**客户端库**，需要配合一个 **kami 授权服务器**（你自建/自部署的单文件 Go 服务）才能工作。SDK 只负责和你的服务器对话。
+
+## 安装
+
+```bash
+pip install kami-armor
+# 需要"一键打包/Cython"功能时（构建期工具）：
+pip install "kami-armor[harden]"
+```
+
+## 客户端 SDK 快速上手
+
+```python
+from kami_client import KamiClient, LicenseError
+
+client = KamiClient("https://license.example.com", "你的产品代号", "<服务器公钥HEX>")
+try:
+    lic = client.validate()              # 先用缓存/在线校验
+except LicenseError:
+    lic = client.activate(user_code)     # 首次激活（卡密）
+
+if lic.has_feature("premium"):
+    out, quota = client.gated("premium", {"k": "v"}, cost=1)   # 价值在服务端执行
+    key = client.unlock("model")                               # 按授权拿密钥
+    data = client.decrypt_resource(sealed_bytes, key)          # 仅内存解密
+    client.attest("build-1")                                   # 可选：完整性证明
+
+# 可选：后台心跳（实时在线 + 即时感知吊销/踢下线）
+stop = client.start_heartbeat  # 见文档
+```
+
+## 源码保护（kami_armor）
+
+```python
+import kami_armor
+# 构建期：加密模块 + 注册密钥（密钥不进发布物）
+kami_armor.build([{"src": "core/algo.py", "module": "core.algo",
+                   "resource": "algo_v1", "feature": "premium", "keep": ["compute"]}],
+                 admin_url="https://license.example.com", token="<后台JWT>")
+```
+```python
+# 运行期：装上加密导入
+from kami_client import KamiClient
+import kami_armor
+client = KamiClient(url, product, pubkey); client.validate()
+kami_armor.install(client, "dist_protected/manifest.json")
+import core.algo            # ← 经服务器按授权解密后才能导入
+```
+
+命令行：
+
+```bash
+# 只做混淆（改名+字符串加密，供 Cython/Nuitka 用）
+python -m kami_armor obfuscate core/algo.py -o core/algo_obf.py --keep run
+# 一键：混淆→Cython→加密→打包出 exe
+python -m kami_armor harden --config kami-harden.toml
+```
+
+## 诚实定位
+
+客户端的混淆/加密只能**抬高破解成本**，不是绝对保密——解密后的代码运行时仍可能被持有效授权的攻击者内存 dump（CPython 的硬限制，所有方案都一样）。真正耐久的保护是：**把价值与密钥留在服务端**（价值闸门 + 按授权发密钥），并用**比 crack 传播更快的吊销与更新**让破解迅速过期。本库正是围绕这一原则设计。
+
+## License
+
+MIT © yuge666

kami_armor-0.1.0/README.md

@@ -0,0 +1,73 @@
+# kami-armor
+
+**卡密（license）系统的 Python 客户端 SDK + 服务端绑定密钥的源码保护工具链。**
+
+- 🔑 **客户端 SDK**（`kami_client`）：在线激活 / 校验 / 心跳 / 解绑、价值闸门调用、按授权解锁加密资源、完整性自测量——只内嵌**公钥**，离线验签，永远拿不到可伪造卡密的私钥。
+- 🛡 **源码保护**（`kami_armor`）：把 Python 模块加密成密文随程序分发，**发布物里没有密钥**，运行时经服务器按授权下发密钥、内存解密导入。比 PyArmor 强在一个结构性维度——**密钥托管**（PyArmor 的密钥静态内嵌、可离线脱壳；这里密钥根本不在文件里，可吊销/溯源）。
+- 🧩 **混淆 + 原生编译 + 一键打包**：自建免费的改名/字符串加密（symtable 保证不改坏代码）、Cython 原生编译皇冠模块、`kami-armor harden` 一条命令 混淆→Cython→加密→PyInstaller/Nuitka 出 exe。
+
+> ⚠️ 这是**客户端库**，需要配合一个 **kami 授权服务器**（你自建/自部署的单文件 Go 服务）才能工作。SDK 只负责和你的服务器对话。
+
+## 安装
+
+```bash
+pip install kami-armor
+# 需要"一键打包/Cython"功能时（构建期工具）：
+pip install "kami-armor[harden]"
+```
+
+## 客户端 SDK 快速上手
+
+```python
+from kami_client import KamiClient, LicenseError
+
+client = KamiClient("https://license.example.com", "你的产品代号", "<服务器公钥HEX>")
+try:
+    lic = client.validate()              # 先用缓存/在线校验
+except LicenseError:
+    lic = client.activate(user_code)     # 首次激活（卡密）
+
+if lic.has_feature("premium"):
+    out, quota = client.gated("premium", {"k": "v"}, cost=1)   # 价值在服务端执行
+    key = client.unlock("model")                               # 按授权拿密钥
+    data = client.decrypt_resource(sealed_bytes, key)          # 仅内存解密
+    client.attest("build-1")                                   # 可选：完整性证明
+
+# 可选：后台心跳（实时在线 + 即时感知吊销/踢下线）
+stop = client.start_heartbeat  # 见文档
+```
+
+## 源码保护（kami_armor）
+
+```python
+import kami_armor
+# 构建期：加密模块 + 注册密钥（密钥不进发布物）
+kami_armor.build([{"src": "core/algo.py", "module": "core.algo",
+                   "resource": "algo_v1", "feature": "premium", "keep": ["compute"]}],
+                 admin_url="https://license.example.com", token="<后台JWT>")
+```
+```python
+# 运行期：装上加密导入
+from kami_client import KamiClient
+import kami_armor
+client = KamiClient(url, product, pubkey); client.validate()
+kami_armor.install(client, "dist_protected/manifest.json")
+import core.algo            # ← 经服务器按授权解密后才能导入
+```
+
+命令行：
+
+```bash
+# 只做混淆（改名+字符串加密，供 Cython/Nuitka 用）
+python -m kami_armor obfuscate core/algo.py -o core/algo_obf.py --keep run
+# 一键：混淆→Cython→加密→打包出 exe
+python -m kami_armor harden --config kami-harden.toml
+```
+
+## 诚实定位
+
+客户端的混淆/加密只能**抬高破解成本**，不是绝对保密——解密后的代码运行时仍可能被持有效授权的攻击者内存 dump（CPython 的硬限制，所有方案都一样）。真正耐久的保护是：**把价值与密钥留在服务端**（价值闸门 + 按授权发密钥），并用**比 crack 传播更快的吊销与更新**让破解迅速过期。本库正是围绕这一原则设计。
+
+## License
+
+MIT © yuge666

kami_armor-0.1.0/kami_armor/README.md

@@ -0,0 +1,77 @@
+# kami-armor — 服务端绑定密钥的 Python 源码保护（自建 / 免费）
+
+比 PyArmor 强在**一个结构性维度：密钥托管**。PyArmor 的 AES 密钥是静态内嵌、可
+离线算出（2025 年被公开脚本 G DATA / Lil-House 1shot 静态脱壳 8.0–9.2.x）。
+kami-armor 把模块加密成密文(.kam)随程序分发，**发布物里没有密钥**；运行时由 kami
+服务器（`/v1/unlock`，需有效授权 + 设备绑定）按会话下发密钥，内存解密执行。
+于是：离线无法解密、密钥可吊销/轮换/限流、可按客户溯源。并且修正了 PyArmor 的
+GCM 不校验 tag 的缺陷（这里用标准 AES-256-GCM 且校验）。
+
+## 用法
+
+**1) 构建期：加密模块 + 注册密钥**
+```python
+import kami_armor
+kami_armor.build([
+    {"src": "core/algo.py",    "module": "core.algo",    "resource": "algo_v1",    "feature": "premium"},
+    {"src": "core/pricing.py", "module": "core.pricing", "resource": "pricing_v1"},
+], admin_url="https://license.example.com", token="<后台JWT>")  # 或 apikey="..."
+# 产出 dist_protected/{algo_v1.kam, pricing_v1.kam, manifest.json}
+```
+或命令行：`python -m kami_armor pack core/algo.py --module core.algo --resource algo_v1 --url ... --token ...`
+
+发布时**只带 .kam 密文 + manifest.json**，删掉源 .py。
+
+**2) 运行期：装上加密导入**
+```python
+from kami_client import KamiClient
+import kami_armor
+
+client = KamiClient("https://license.example.com", "你的产品代号", "<公钥HEX>")
+client.validate()                      # 先校验授权（否则下面 unlock 会失败）
+kami_armor.install(client, "dist_protected/manifest.json")
+
+import core.algo                       # ← 经服务器按授权取密钥，内存解密后才可导入
+core.algo.run(...)
+```
+授权无效/过期/吊销/被踢 → `unlock` 失败 → 导入失败。
+
+## AST 预处理：改名 + 字符串加密（自建免费 RFT / mix-str）
+
+`kami_armor.obfuscate` 在**编译/加密之前**对源码做一遍语法树改写，抹掉"白送给逆向者的地图"——可读的名字与字符串。补 Nuitka 泄露符号名、Cython 泄露属性串的洞。
+
+```python
+from kami_armor import obfuscate_source
+new_src = obfuscate_source(open("core/algo.py").read(), keep=["run", "PriceEngine"])
+# 或命令行：python -m kami_armor obfuscate core/algo.py -o core/algo_obf.py --keep run,PriceEngine
+# 打包时一步到位：kami_armor.build([...], obfuscate=True)  /  pack --obfuscate --keep run
+```
+
+- **改名**：只改模块级、全局唯一、无遮蔽、非公开 API（不在 `keep`/`__all__`）、非导入的私有名（用 CPython 的 `symtable` 做作用域分析，构造即正确）；参数名/属性名/builtins/dunder 一律不动。
+- **字符串加密**：字符串常量换成 `_kdec("…")`（XOR+base64，运行时同值）；严格跳过 docstring(直接删)、类型注解、f-string、`match` 模式、bytes。
+- **安全保证**：经行为等价测试（原版 vs 混淆版输出逐一比对，覆盖闭包/推导式/类/global/f-string/match）。`keep` 里务必列上对外公开、会被别的模块按名引用的 API。
+
+## 和 Cython 一起用（推荐）
+- **最值钱的 5–20 个函数** → 用 `scripts/cythonize-crown.py` 编译成原生 .pyd/.so（无字节码、连内存 dump 出来的也是机器码，不是代码对象）。
+- **其余受保护模块** → kami-armor 加密（拿到"无静态密钥 + 吊销 + 溯源"）。
+- **最值钱的逻辑** → 直接用价值闸门 `/v1/gated` 留服务端（唯一真·保密）。
+
+## 一键打包：`kami harden`（回到"配置→一条命令→出 exe"）
+
+像 PyArmor 那样一条龙，但底层是在线授权（密钥不在 exe 里）。配置见仓库根 `kami-harden.toml`：
+
+```bash
+set KAMI_ADMIN_TOKEN=<后台JWT>
+python -m kami_armor harden --config kami-harden.toml
+```
+它依次做：（Cython 皇冠模块）→ 混淆（改名+字符串加密）→ kami-armor 加密+注册密钥 →
+生成运行时引导（PyInstaller runtime-hook / Nuitka boot）→ 调打包器出 exe → 登记构建哈希给 attest。
+
+- **PyInstaller vs Nuitka**：纯论保护 Nuitka 更强（整 app 变原生，无 .pyc 可反编译）；论省事/兼容 PyInstaller 更好。在本系统里值钱模块已被 kami-armor/Cython 保护，PyInstaller 足够；要连胶水也变原生再上 Nuitka。`[project] packager=` 切换。Nuitka 需 C 编译器。
+- **终端用户授权**：生成的 exe 启动时先在线校验；未激活则读环境变量 `KAMI_CODE` 或同目录 `license.key` 激活。
+- 已实测：PyInstaller 路径产出真 exe，运行即在线激活 + 服务端绑定密钥加载受保护模块。
+
+## 诚实边界（务必读）
+- 模块解密后，代码对象仍在 CPython 内存里——**持有效授权的动态攻击者**仍能 dump（gc 遍历 / Frida 钩 marshal / 自建 CPython）。这是 CPython 的硬天花板，PyArmor 也一样，谁都过不去。
+- 所以 kami-armor 的真实价值是 **发行控制 / 反传播 / 吊销 / 溯源**，不是"反逆向"。要真正藏住逻辑，只有：① Cython 把它变机器码（抬到原生逆向）；② 干脆不下发，放服务端价值闸门。
+- 在线依赖：纯离线客户用不了（缓存密钥会把密钥放回设备，重蹈 PyArmor）。

kami_armor-0.1.0/kami_armor/__init__.py

@@ -0,0 +1,14 @@
+"""kami-armor：服务端绑定密钥的 Python 源码保护（自建、免费）。
+
+- 构建期：pack/build 把模块加密成 .kam 密文 + 注册密钥到 kami（密钥不进发布物）。
+- 运行期：install(client, manifest) 安装加密导入；导入时经服务器按授权取密钥内存解密。
+
+详见本目录 README.md（含诚实边界与 Cython 联合使用建议）。
+"""
+from .loader import install, KamiArmorFinder
+from .pack import pack_module, build
+from .obfuscate import obfuscate_source, obfuscate_file
+from .harden import harden, load_config
+
+__all__ = ["install", "KamiArmorFinder", "pack_module", "build",
+           "obfuscate_source", "obfuscate_file", "harden", "load_config"]

kami_armor-0.1.0/kami_armor/__main__.py

@@ -0,0 +1,72 @@
+"""kami-armor CLI：
+  python -m kami_armor pack <src.py> --module mypkg.secret --resource res1 \
+      --url http://host:8787 --token <JWT>  [--apikey K] [--feature F] [--out dist_protected]
+多次 pack 会累积写入同一 out/manifest.json。
+"""
+import argparse
+import json
+import os
+
+from .pack import pack_module
+from .obfuscate import obfuscate_file
+from .harden import harden, load_config
+
+
+def _keeplist(s):
+    return tuple(x.strip() for x in s.split(",") if x.strip())
+
+
+def main():
+    ap = argparse.ArgumentParser(prog="kami_armor")
+    sub = ap.add_subparsers(dest="cmd")
+
+    p = sub.add_parser("pack", help="加密一个模块并注册密钥")
+    p.add_argument("src")
+    p.add_argument("--module", required=True, help="导入名，如 mypkg.secret")
+    p.add_argument("--resource", required=True, help="kami 资源名（唯一）")
+    p.add_argument("--url", required=True, help="后台地址，如 http://host:8787")
+    p.add_argument("--token", default="", help="后台登录 JWT")
+    p.add_argument("--apikey", default="", help="或用后台 API Key")
+    p.add_argument("--feature", default="", help="解锁需要的功能/授权")
+    p.add_argument("--out", default="dist_protected")
+    p.add_argument("--obfuscate", action="store_true", help="打包前先跑 AST 改名+字符串加密")
+    p.add_argument("--keep", default="", help="逗号分隔的公开 API 名（不可改名）")
+
+    o = sub.add_parser("obfuscate", help="只做 AST 预处理(改名+字符串加密)，产出源码")
+    o.add_argument("src")
+    o.add_argument("-o", "--out", required=True, help="输出 .py 路径")
+    o.add_argument("--keep", default="", help="逗号分隔的公开 API 名（不可改名）")
+    o.add_argument("--no-rename", action="store_true")
+    o.add_argument("--no-encrypt-strings", action="store_true")
+
+    h = sub.add_parser("harden", help="一键编排：混淆→Cython→加密→打包出 exe")
+    h.add_argument("--config", required=True, help="kami-harden.toml 或 .json")
+    h.add_argument("--no-build", action="store_true", help="只产出 .kam/manifest/命令，不真打包")
+
+    args = ap.parse_args()
+
+    if args.cmd == "pack":
+        e = pack_module(args.src, args.module, args.resource, args.url,
+                        args.token, args.apikey, args.feature, 0, args.out,
+                        obfuscate=args.obfuscate, keep=_keeplist(args.keep))
+        mpath = os.path.join(args.out, "manifest.json")
+        manifest = {"modules": {}}
+        if os.path.exists(mpath):
+            with open(mpath, encoding="utf-8") as f:
+                manifest = json.load(f)
+        manifest.setdefault("modules", {})[e["module"]] = {"resource": e["resource"], "blob": e["blob"]}
+        with open(mpath, "w", encoding="utf-8") as f:
+            json.dump(manifest, f, ensure_ascii=False, indent=2)
+        print("packed:", e)
+    elif args.cmd == "obfuscate":
+        obfuscate_file(args.src, args.out, keep=_keeplist(args.keep),
+                       rename=not args.no_rename, encrypt_strings=not args.no_encrypt_strings)
+        print("obfuscated:", args.src, "->", args.out)
+    elif args.cmd == "harden":
+        harden(load_config(args.config), run=not args.no_build)
+    else:
+        ap.print_help()
+
+
+if __name__ == "__main__":
+    main()

kami_armor-0.1.0/kami_armor/harden.py

@@ -0,0 +1,235 @@
+"""kami harden 一键编排：读配置 → (Cython) → 混淆 → kami-armor 加密+注册密钥 →
+生成运行时引导 → 调 PyInstaller/Nuitka 打包 → (可选)登记构建哈希给 attest。
+
+把"配置一下 → 一条命令 → 出 exe"的体验做回来，但底层是在线授权（密钥不在 exe 里）。
+
+配置（kami-harden.toml 或 .json）：
+  [project] entry="app/main.py" name="myapp" product="myapp" packager="pyinstaller"|"nuitka" onefile=true
+  [server]  url="http://host:8787"  (token/apikey 可用环境变量 KAMI_ADMIN_TOKEN/KAMI_ADMIN_APIKEY)
+  [obfuscate] enabled=true keep=["main"]
+  [[modules]] src="app/core/algo.py" module="app.core.algo" resource="algo_v1" feature="premium" keep=["compute"]
+  [[cython]]  src="app/core/secret.py"
+  [attest]  register=true  build_id="myapp-1.0"
+"""
+import glob
+import hashlib
+import json
+import os
+import shutil
+import subprocess
+import sys
+import tempfile
+import urllib.request
+
+from .pack import pack_module
+from .obfuscate import obfuscate_source
+
+
+def load_config(path):
+    if path.endswith(".json"):
+        with open(path, "r", encoding="utf-8") as f:
+            return json.load(f)
+    try:
+        import tomllib as toml
+    except ImportError:
+        import tomli as toml
+    with open(path, "rb") as f:
+        return toml.load(f)
+
+
+def _auth(srv):
+    return (srv.get("token") or os.environ.get("KAMI_ADMIN_TOKEN", ""),
+            srv.get("apikey") or os.environ.get("KAMI_ADMIN_APIKEY", ""))
+
+
+def _get_pubkey(url, token, apikey):
+    req = urllib.request.Request(url.rstrip("/") + "/admin/api/pubkey")
+    if token:
+        req.add_header("Authorization", "Bearer " + token)
+    if apikey:
+        req.add_header("X-API-Key", apikey)
+    with urllib.request.urlopen(req, timeout=15) as r:
+        return json.loads(r.read().decode())["hex"]
+
+
+def _register_measure(url, token, apikey, build_id, exe):
+    h = hashlib.sha256(open(exe, "rb").read()).hexdigest()
+    body = json.dumps({"build_id": build_id, "expected_hash": h, "note": os.path.basename(exe)}).encode()
+    req = urllib.request.Request(url.rstrip("/") + "/admin/api/measurements", data=body, method="POST")
+    req.add_header("Content-Type", "application/json")
+    if token:
+        req.add_header("Authorization", "Bearer " + token)
+    if apikey:
+        req.add_header("X-API-Key", apikey)
+    try:
+        urllib.request.urlopen(req, timeout=15)
+        print("已登记构建哈希 build_id=%s sha256=%s" % (build_id, h[:16] + "..."))
+    except Exception as e:
+        print("登记构建哈希失败:", e)
+
+
+def _cythonize(specs, obfuscate=False, default_keep=()):
+    """把皇冠模块(可选先混淆)编译成原生 .pyd/.so，放到源文件旁边；源 .py 不改动。
+    Cython 会泄露 Python 名字/字符串，故强烈建议 obfuscate=True。"""
+    try:
+        import Cython  # noqa
+    except ImportError:
+        print("[warn] 未装 Cython 或缺 C 编译器，跳过 Cython:", [s["src"] for s in specs])
+        return
+    for spec in specs:
+        src = os.path.abspath(spec["src"])
+        name = os.path.splitext(os.path.basename(src))[0]
+        with open(src, "r", encoding="utf-8") as f:
+            code = f.read()
+        if obfuscate:
+            code = obfuscate_source(code, keep=tuple(spec.get("keep", default_keep)))
+        tmp = tempfile.mkdtemp(prefix="kamicy_")
+        try:
+            with open(os.path.join(tmp, name + ".py"), "w", encoding="utf-8") as f:
+                f.write(code)
+            with open(os.path.join(tmp, "setup.py"), "w", encoding="utf-8") as f:
+                f.write("from setuptools import setup\nfrom Cython.Build import cythonize\n"
+                        "setup(ext_modules=cythonize(['%s.py'], compiler_directives={'language_level':'3'}))\n" % name)
+            rc = subprocess.call([sys.executable, "setup.py", "build_ext", "--inplace"], cwd=tmp)
+            built = glob.glob(os.path.join(tmp, name + "*.pyd")) + glob.glob(os.path.join(tmp, name + "*.so"))
+            if rc == 0 and built:
+                shutil.copy(built[0], os.path.join(os.path.dirname(src), os.path.basename(built[0])))
+                print("Cython 原生编译:", spec["src"], "->", os.path.basename(built[0]))
+            else:
+                print("[warn] Cython 编译失败:", spec["src"])
+        finally:
+            shutil.rmtree(tmp, ignore_errors=True)
+
+
+_RTHOOK = '''# 由 kami harden 生成的运行时引导（在主程序之前运行）
+import os, sys
+def _kami_boot():
+    base = getattr(sys, "_MEIPASS", os.path.dirname(os.path.abspath(__file__)))
+    from kami_client import KamiClient, LicenseError
+    import kami_armor
+    client = KamiClient({url!r}, {product!r}, {pubkey!r})
+    try:
+        client.validate()
+    except LicenseError:
+        code = os.environ.get("KAMI_CODE", "")
+        if not code:
+            p = os.path.join(os.path.dirname(sys.executable), "license.key")
+            if os.path.exists(p):
+                code = open(p).read().strip()
+        if not code:
+            sys.stderr.write("需要授权：设置环境变量 KAMI_CODE 或同目录放 license.key\\n")
+            sys.exit(1)
+        try:
+            client.activate(code)
+        except LicenseError as e:
+            sys.stderr.write("激活失败: " + str(e) + "\\n")
+            sys.exit(1)
+    kami_armor.install(client, os.path.join(base, {manifest!r}))
+_kami_boot()
+'''
+
+
+def _gen_rthook(build_dir, url, product, pubkey, manifest_name):
+    path = os.path.join(build_dir, "kami_rthook.py")
+    with open(path, "w", encoding="utf-8") as f:
+        f.write(_RTHOOK.format(url=url, product=product, pubkey=pubkey, manifest=manifest_name))
+    return path
+
+
+def harden(cfg, run=True, sdk_path=None):
+    proj, srv = cfg["project"], cfg["server"]
+    url = srv["url"]
+    token, apikey = _auth(srv)
+    product = proj["product"]
+    build_dir = cfg.get("build_dir", "build_kami")
+    os.makedirs(build_dir, exist_ok=True)
+    sdk_path = sdk_path or os.path.dirname(os.path.dirname(os.path.abspath(__file__)))  # .../sdk/python
+
+    obf = cfg.get("obfuscate", {})
+    obf_on, obf_keep = obf.get("enabled", False), tuple(obf.get("keep", []))
+
+    if cfg.get("cython"):
+        _cythonize(cfg["cython"], obfuscate=obf_on, default_keep=obf_keep)
+
+    modules, excludes = {}, []
+    for m in cfg.get("modules", []):
+        e = pack_module(m["src"], m["module"], m["resource"], url, token, apikey,
+                        m.get("feature", ""), 0, build_dir,
+                        obfuscate=obf_on, keep=tuple(m.get("keep", obf_keep)))
+        modules[e["module"]] = {"resource": e["resource"], "blob": e["blob"]}
+        excludes.append(m["module"])
+    mpath = os.path.join(build_dir, "manifest.json")
+    with open(mpath, "w", encoding="utf-8") as f:
+        json.dump({"modules": modules}, f, ensure_ascii=False, indent=2)
+    print("已加密 %d 个模块 + 注册密钥 -> %s" % (len(modules), mpath))
+
+    pubkey = _get_pubkey(url, token, apikey)
+    hook = _gen_rthook(build_dir, url, product, pubkey, "manifest.json")
+
+    packager = proj.get("packager", "nuitka")
+    if packager == "pyinstaller":
+        cmd, exe = _pyinstaller_cmd(proj, build_dir, modules, excludes, hook, sdk_path)
+    else:
+        cmd, exe = _nuitka_cmd(proj, build_dir, modules, excludes, hook, sdk_path)
+
+    print("打包器: %s\n命令:\n  %s" % (packager, " ".join(cmd)))
+    result = {"manifest": mpath, "hook": hook, "command": cmd, "exe": exe, "build_dir": build_dir}
+    if run:
+        rc = subprocess.call(cmd)
+        if rc == 0 and os.path.exists(exe):
+            print("产物:", exe)
+            if cfg.get("attest", {}).get("register"):
+                _register_measure(url, token, apikey, cfg["attest"].get("build_id", product + "-1"), exe)
+        else:
+            print("打包失败 rc=%d（或缺打包器/编译器）" % rc)
+            result["failed"] = True
+    return result
+
+
+def _datas(build_dir, modules):
+    out = [(os.path.join(build_dir, "manifest.json"), ".")]
+    for info in modules.values():
+        out.append((os.path.join(build_dir, info["blob"]), "."))
+    return out
+
+
+def _pyinstaller_cmd(proj, build_dir, modules, excludes, hook, sdk_path):
+    name = proj["name"]
+    cmd = ["pyinstaller", "--noconfirm", "--clean", "--noupx", "--name", name,
+           "--distpath", os.path.join(build_dir, "dist"),
+           "--workpath", os.path.join(build_dir, "work"),
+           "--specpath", build_dir,
+           "--runtime-hook", hook,
+           "--paths", sdk_path,
+           "--hidden-import", "kami_client",
+           "--collect-submodules", "kami_armor"]
+    if proj.get("onefile", True):
+        cmd.append("--onefile")
+    if not proj.get("console", True):
+        cmd.append("--windowed")
+    for src, dst in _datas(build_dir, modules):
+        cmd += ["--add-data", "%s%s%s" % (os.path.abspath(src), os.pathsep, dst)]
+    for ex in excludes:
+        cmd += ["--exclude-module", ex]
+    cmd.append(os.path.abspath(proj["entry"]))
+    exe = os.path.join(build_dir, "dist", name + (".exe" if os.name == "nt" else ""))
+    return cmd, exe
+
+
+def _nuitka_cmd(proj, build_dir, modules, excludes, hook, sdk_path):
+    name = proj["name"]
+    cmd = [sys.executable, "-m", "nuitka", "--assume-yes-for-downloads",
+           "--output-dir=" + build_dir, "--output-filename=" + name,
+           "--include-module=kami_client", "--include-package=kami_armor"]
+    if proj.get("onefile", True):
+        cmd.append("--onefile")
+    if not proj.get("console", True):
+        cmd.append("--windows-console-mode=disable")
+    for ex in excludes:
+        cmd.append("--nofollow-import-to=" + ex)
+    for src, _ in _datas(build_dir, modules):
+        cmd.append("--include-data-files=%s=%s" % (os.path.abspath(src), os.path.basename(src)))
+    cmd.append("--include-data-dir=%s=." % sdk_path)
+    cmd.append(os.path.abspath(proj["entry"]))
+    exe = os.path.join(build_dir, name + (".exe" if os.name == "nt" else ".bin"))
+    return cmd, exe

kami_armor-0.1.0/kami_armor/loader.py

@@ -0,0 +1,70 @@
+"""kami-armor 运行时：服务端绑定密钥的加密导入加载器。
+
+受保护模块以密文(.kam)随程序分发，**二进制里没有密钥**。导入时由自定义
+importlib Loader 经 kami 服务器(/v1/unlock，需有效授权+设备绑定)取得密钥，
+在内存解密 → exec。授权无效/吊销/被踢 → unlock 失败 → 导入失败。
+
+这正是相对 PyArmor 的结构性优势：PyArmor 的 AES 密钥是静态内嵌、可离线算出
+(已被公开脚本静态脱壳)；这里密钥根本不在文件里，离线无法解密、可吊销、可溯源。
+诚实边界：模块解密后代码对象仍在 CPython 内存中，持有效授权的动态攻击者仍可
+dump——这条 CPython 天花板谁都过不去；最值钱的逻辑请用价值闸门留服务端。
+"""
+import importlib.abc
+import importlib.util
+import json
+import marshal
+import os
+import sys
+
+
+class _ProtectedLoader(importlib.abc.Loader):
+    def __init__(self, fullname, blob_path, resource, client):
+        self.fullname = fullname
+        self.blob_path = blob_path
+        self.resource = resource
+        self.client = client
+
+    def create_module(self, spec):
+        return None  # 默认模块对象
+
+    def exec_module(self, module):
+        with open(self.blob_path, "rb") as f:
+            blob = f.read()
+        key = self.client.unlock(self.resource)          # 服务端按授权下发密钥
+        data = None
+        try:
+            data = self.client.decrypt_resource(blob, key)  # AES-256-GCM，仅内存
+            code = marshal.loads(data)
+            module.__dict__["__file__"] = self.blob_path
+            exec(code, module.__dict__)
+        finally:
+            # 尽力丢弃引用（Python 无法真正抹零，但缩短驻留）
+            del key, data
+
+
+class KamiArmorFinder(importlib.abc.MetaPathFinder):
+    """拦截受保护模块的导入，交给 _ProtectedLoader。"""
+
+    def __init__(self, client, modules, base_dir):
+        self.client = client
+        self.modules = modules        # {fullname: {"resource":..., "blob":...}}
+        self.base_dir = base_dir
+
+    def find_spec(self, fullname, path=None, target=None):
+        info = self.modules.get(fullname)
+        if not info:
+            return None
+        blob_path = os.path.join(self.base_dir, info["blob"])
+        loader = _ProtectedLoader(fullname, blob_path, info["resource"], self.client)
+        return importlib.util.spec_from_loader(fullname, loader)
+
+
+def install(client, manifest_path):
+    """安装加密导入。client 需实现 unlock(resource)->key 和
+    decrypt_resource(blob,key)->bytes（kami 的 KamiClient 已满足）。"""
+    with open(manifest_path, "r", encoding="utf-8") as f:
+        manifest = json.load(f)
+    base = os.path.dirname(os.path.abspath(manifest_path))
+    finder = KamiArmorFinder(client, manifest.get("modules", {}), base)
+    sys.meta_path.insert(0, finder)
+    return finder