pyfernet-payload 0.2.4__py3-none-any.whl

pyfernet/__init__.py

@@ -0,0 +1,14 @@
+"""PyFernet: encrypt a source directory into one .enc file and run it from memory."""
+
+from __future__ import annotations
+
+__version__ = "0.2.4"
+
+from pyfernet.encryptor import encrypt_directory
+from pyfernet.loader import run_payload
+
+__all__ = [
+    "__version__",
+    "encrypt_directory",
+    "run_payload",
+]

pyfernet/__main__.py

@@ -0,0 +1,8 @@
+"""python -m pyfernet → CLI。"""
+
+from __future__ import annotations
+
+from pyfernet.cli import main
+
+if __name__ == "__main__":
+    raise SystemExit(main())

pyfernet/cli.py

@@ -0,0 +1,158 @@
+"""命令行入口：pyfernet encrypt | run"""
+
+from __future__ import annotations
+
+import argparse
+import os
+import sys
+from pathlib import Path
+
+from pyfernet import __version__
+from pyfernet.encryptor import main as encrypt_main
+from pyfernet.loader import list_payload, main as run_main
+
+
+DEFAULT_PASSWORD_ENV = "PYFERNET_PASSWORD"
+
+
+def _password_from_args(password: str | None, password_env: str | None) -> str | None:
+    """解析口令：-p > --password-env > 环境变量 PYFERNET_PASSWORD > None(交互)。"""
+    if password is not None:
+        return password
+    env_name = password_env or DEFAULT_PASSWORD_ENV
+    # 显式传了 --password-env，或默认名在环境里有值时，走环境变量
+    if password_env is not None or env_name in os.environ:
+        value = os.environ.get(env_name)
+        if not value:
+            raise SystemExit(
+                f"环境变量未设置或为空: {env_name}\n"
+                f"  --password-env 后面是「变量名」不是口令本身。\n"
+                f"  正确示例:\n"
+                f"    export {DEFAULT_PASSWORD_ENV}='你的口令'\n"
+                f"    nohup pyfernet run train.enc --password-env {DEFAULT_PASSWORD_ENV} > d.log 2>&1 &\n"
+                f"  或（会进进程列表，仅临时用）:\n"
+                f"    nohup pyfernet run train.enc -p '你的口令' > d.log 2>&1 &"
+            )
+        return value
+    return None
+
+
+def _split_script_args(argv: list[str]) -> tuple[list[str], list[str]]:
+    """将 `run ... -- script_args` 拆开，避免 REMAINDER 吞掉 -p/--password-env。"""
+    if argv and argv[0] == "run" and "--" in argv:
+        idx = argv.index("--")
+        return argv[:idx], argv[idx + 1 :]
+    return argv, []
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        prog="pyfernet",
+        description="将源码目录加密为单个 .enc，并在内存中解密运行（磁盘无明文源码）。",
+    )
+    parser.add_argument("--version", action="version", version=f"%(prog)s {__version__}")
+    sub = parser.add_subparsers(dest="command", required=True)
+
+    p_enc = sub.add_parser("encrypt", help="打包并加密源码目录")
+    p_enc.add_argument("source_dir", type=Path, help="要加密的源码目录")
+    p_enc.add_argument(
+        "-o",
+        "--output",
+        type=Path,
+        default=Path("train_payload.enc"),
+        help="输出密文路径（默认: train_payload.enc）",
+    )
+    p_enc.add_argument(
+        "-e",
+        "--entry",
+        default="train.py",
+        help="相对源目录的入口脚本（默认: train.py）",
+    )
+    p_enc.add_argument(
+        "-p",
+        "--password",
+        default=None,
+        help="口令（不推荐写在命令行；默认交互输入）。也可用 --password-env",
+    )
+    p_enc.add_argument(
+        "--password-env",
+        default=None,
+        metavar="VAR",
+        help="从环境变量读口令（填变量名，如 PYFERNET_PASSWORD；不是口令本身）",
+    )
+
+    p_run = sub.add_parser(
+        "run",
+        help="解密密文包并在内存中执行",
+        epilog="传给训练脚本的参数写在 -- 之后，例如: pyfernet run a.enc -- --epochs 10",
+    )
+    p_run.add_argument("payload", type=Path, help="密文包路径（.enc）")
+    p_run.add_argument(
+        "-p",
+        "--password",
+        default=None,
+        help="口令（不推荐写在命令行；默认交互输入）。也可用 --password-env",
+    )
+    p_run.add_argument(
+        "--password-env",
+        default=None,
+        metavar="VAR",
+        help="从环境变量读口令（填变量名，如 PYFERNET_PASSWORD；不是口令本身）",
+    )
+
+    p_list = sub.add_parser("list", help="列出密文包内文件（需口令）")
+    p_list.add_argument("payload", type=Path, help="密文包路径（.enc）")
+    p_list.add_argument("-p", "--password", default=None, help="口令（默认交互输入）")
+    p_list.add_argument(
+        "--password-env",
+        default=None,
+        metavar="VAR",
+        help="从环境变量读口令（填变量名；不是口令本身）",
+    )
+
+    return parser
+
+
+def main(argv: list[str] | None = None) -> int:
+    raw = list(sys.argv[1:] if argv is None else argv)
+    cli_argv, script_args = _split_script_args(raw)
+
+    parser = build_parser()
+    args = parser.parse_args(cli_argv)
+
+    if args.command == "encrypt":
+        password = _password_from_args(args.password, args.password_env)
+        encrypt_main(
+            source_dir=str(args.source_dir),
+            output_path=str(args.output),
+            entry_point=args.entry,
+            password=password,
+        )
+        return 0
+
+    if args.command == "run":
+        password = _password_from_args(args.password, args.password_env)
+        entry_name = Path(args.payload).name
+        train_argv = [entry_name, *script_args]
+        run_main(payload_path=str(args.payload), password=password, argv=train_argv)
+        return 0
+
+    if args.command == "list":
+        password = _password_from_args(args.password, args.password_env)
+        if password is None:
+            import getpass
+
+            password = getpass.getpass("解密口令: ")
+        entry, files = list_payload(args.payload, password)
+        print(f"entry: {entry}")
+        print(f"files: {len(files)}")
+        for name in files:
+            print(name)
+        return 0
+
+    parser.error(f"未知命令: {args.command}")
+    return 2
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

pyfernet/constants.py

@@ -0,0 +1,31 @@
+"""Shared payload format constants."""
+
+from __future__ import annotations
+
+MAGIC = b"PYFE1\0"
+SALT_LEN = 16
+KDF_ITERATIONS = 390_000
+MANIFEST_NAME = "_pyfernet_manifest.json"
+
+SKIP_DIRS = {
+    ".git",
+    "__pycache__",
+    ".venv",
+    "venv",
+    ".mypy_cache",
+    ".pytest_cache",
+    "node_modules",
+}
+SKIP_SUFFIXES = {".pyc", ".pyo", ".enc"}
+ALLOW_SUFFIXES = {
+    ".py",
+    ".yaml",
+    ".yml",
+    ".json",
+    ".toml",
+    ".cfg",
+    ".ini",
+    ".txt",
+    ".md",
+}
+ALLOW_NAMES = {"LICENSE", "NOTICE"}

pyfernet/encryptor.py

@@ -0,0 +1,143 @@
+"""将指定目录的训练代码打包并 Fernet 加密为单个 .enc 文件。"""
+
+from __future__ import annotations
+
+import getpass
+import io
+import json
+import os
+import zipfile
+from pathlib import Path
+
+from pyfernet.constants import (
+    ALLOW_NAMES,
+    ALLOW_SUFFIXES,
+    KDF_ITERATIONS,
+    MAGIC,
+    MANIFEST_NAME,
+    SALT_LEN,
+    SKIP_DIRS,
+    SKIP_SUFFIXES,
+)
+from pyfernet.fernet_lite import FernetLite, derive_fernet_key
+
+
+def should_include(path: Path, root: Path) -> bool:
+    rel_parts = path.relative_to(root).parts
+    if any(p in SKIP_DIRS for p in rel_parts):
+        return False
+    if path.suffix.lower() in SKIP_SUFFIXES:
+        return False
+    return path.suffix.lower() in ALLOW_SUFFIXES or path.name in ALLOW_NAMES
+
+
+def build_zip_bytes(source_dir: Path, entry_point: str) -> bytes:
+    source_dir = source_dir.resolve()
+    if not source_dir.is_dir():
+        raise FileNotFoundError(f"源目录不存在: {source_dir}")
+
+    entry = Path(entry_point)
+    entry_rel = str(entry).replace("\\", "/")
+    entry_abs = (source_dir / entry).resolve()
+    try:
+        entry_abs.relative_to(source_dir)
+    except ValueError as e:
+        raise FileNotFoundError(f"入口文件不在源目录内: {entry_point}") from e
+    if not entry_abs.is_file():
+        raise FileNotFoundError(f"入口文件不存在: {entry_point}")
+
+    buf = io.BytesIO()
+    files: list[str] = []
+    with zipfile.ZipFile(buf, "w", compression=zipfile.ZIP_DEFLATED) as zf:
+        for path in sorted(source_dir.rglob("*")):
+            if not path.is_file():
+                continue
+            if not should_include(path, source_dir):
+                continue
+            arcname = path.relative_to(source_dir).as_posix()
+            zf.write(path, arcname)
+            files.append(arcname)
+
+        if entry_rel not in files:
+            raise RuntimeError(f"入口 {entry_rel} 未被打包（后缀可能被过滤）")
+
+        manifest = {
+            "version": 1,
+            "entry_point": entry_rel,
+            "files": files,
+        }
+        zf.writestr(MANIFEST_NAME, json.dumps(manifest, ensure_ascii=False, indent=2))
+
+    return buf.getvalue()
+
+
+def encrypt_bytes(plain: bytes, password: str) -> bytes:
+    salt = os.urandom(SALT_LEN)
+    key = derive_fernet_key(password, salt, KDF_ITERATIONS)
+    token = FernetLite(key).encrypt(plain)
+    return MAGIC + salt + token
+
+
+def encrypt_directory(
+    source_dir: str | Path,
+    output_path: str | Path,
+    entry_point: str,
+    password: str,
+) -> Path:
+    zip_bytes = build_zip_bytes(Path(source_dir), entry_point)
+    enc = encrypt_bytes(zip_bytes, password)
+    out = Path(output_path)
+    out.parent.mkdir(parents=True, exist_ok=True)
+    out.write_bytes(enc)
+    return out
+
+
+def prompt_password_confirm() -> str:
+    password = getpass.getpass("加密口令: ")
+    confirm = getpass.getpass("再输入一次: ")
+    if password != confirm:
+        raise SystemExit("两次口令不一致")
+    if not password:
+        raise SystemExit("口令不能为空")
+    return password
+
+
+def main(
+    source_dir: str,
+    output_path: str,
+    entry_point: str,
+    password: str | None = None,
+) -> None:
+    if password is None:
+        password = prompt_password_confirm()
+
+    out = encrypt_directory(source_dir, output_path, entry_point, password)
+    size = out.stat().st_size
+    print(f"已生成: {out.resolve()} ({size} bytes)")
+    print(f"入口: {entry_point}")
+    print("请妥善保存口令；口令不会写入密文文件。")
+
+
+def _ide_main() -> None:
+    # —— IDE 调试：改变量后直接运行本模块 ——
+    SOURCE_DIR = "examples/demo_train"
+    OUTPUT_PATH = "dist/train_payload.enc"
+    ENTRY_POINT = "train.py"
+    PASSWORD = None
+
+    main(
+        source_dir=SOURCE_DIR,
+        output_path=OUTPUT_PATH,
+        entry_point=ENTRY_POINT,
+        password=PASSWORD,
+    )
+
+
+if __name__ == "__main__":
+    import sys
+
+    if len(sys.argv) > 1:
+        from pyfernet.cli import main as cli_main
+
+        raise SystemExit(cli_main(["encrypt", *sys.argv[1:]]))
+    _ide_main()

pyfernet/fernet_lite.py

@@ -0,0 +1,231 @@
+#!/usr/bin/env python3
+"""纯标准库 AES-128-CBC + Fernet 兼容加解密（无第三方依赖）。
+
+口令 → PBKDF2-HMAC-SHA256 → 32 字节密钥 → urlsafe-b64 作为 Fernet key。
+算法与 cryptography.fernet.Fernet 互通（同一 key / token）。
+"""
+
+from __future__ import annotations
+
+import base64
+import hashlib
+import hmac
+import os
+import struct
+import time
+
+# --- AES-128（最小实现，仅 ECB 单块 + CBC 包装）---
+
+_SBOX = (
+    0x63, 0x7C, 0x77, 0x7B, 0xF2, 0x6B, 0x6F, 0xC5, 0x30, 0x01, 0x67, 0x2B, 0xFE, 0xD7, 0xAB, 0x76,
+    0xCA, 0x82, 0xC9, 0x7D, 0xFA, 0x59, 0x47, 0xF0, 0xAD, 0xD4, 0xA2, 0xAF, 0x9C, 0xA4, 0x72, 0xC0,
+    0xB7, 0xFD, 0x93, 0x26, 0x36, 0x3F, 0xF7, 0xCC, 0x34, 0xA5, 0xE5, 0xF1, 0x71, 0xD8, 0x31, 0x15,
+    0x04, 0xC7, 0x23, 0xC3, 0x18, 0x96, 0x05, 0x9A, 0x07, 0x12, 0x80, 0xE2, 0xEB, 0x27, 0xB2, 0x75,
+    0x09, 0x83, 0x2C, 0x1A, 0x1B, 0x6E, 0x5A, 0xA0, 0x52, 0x3B, 0xD6, 0xB3, 0x29, 0xE3, 0x2F, 0x84,
+    0x53, 0xD1, 0x00, 0xED, 0x20, 0xFC, 0xB1, 0x5B, 0x6A, 0xCB, 0xBE, 0x39, 0x4A, 0x4C, 0x58, 0xCF,
+    0xD0, 0xEF, 0xAA, 0xFB, 0x43, 0x4D, 0x33, 0x85, 0x45, 0xF9, 0x02, 0x7F, 0x50, 0x3C, 0x9F, 0xA8,
+    0x51, 0xA3, 0x40, 0x8F, 0x92, 0x9D, 0x38, 0xF5, 0xBC, 0xB6, 0xDA, 0x21, 0x10, 0xFF, 0xF3, 0xD2,
+    0xCD, 0x0C, 0x13, 0xEC, 0x5F, 0x97, 0x44, 0x17, 0xC4, 0xA7, 0x7E, 0x3D, 0x64, 0x5D, 0x19, 0x73,
+    0x60, 0x81, 0x4F, 0xDC, 0x22, 0x2A, 0x90, 0x88, 0x46, 0xEE, 0xB8, 0x14, 0xDE, 0x5E, 0x0B, 0xDB,
+    0xE0, 0x32, 0x3A, 0x0A, 0x49, 0x06, 0x24, 0x5C, 0xC2, 0xD3, 0xAC, 0x62, 0x91, 0x95, 0xE4, 0x79,
+    0xE7, 0xC8, 0x37, 0x6D, 0x8D, 0xD5, 0x4E, 0xA9, 0x6C, 0x56, 0xF4, 0xEA, 0x65, 0x7A, 0xAE, 0x08,
+    0xBA, 0x78, 0x25, 0x2E, 0x1C, 0xA6, 0xB4, 0xC6, 0xE8, 0xDD, 0x74, 0x1F, 0x4B, 0xBD, 0x8B, 0x8A,
+    0x70, 0x3E, 0xB5, 0x66, 0x48, 0x03, 0xF6, 0x0E, 0x61, 0x35, 0x57, 0xB9, 0x86, 0xC1, 0x1D, 0x9E,
+    0xE1, 0xF8, 0x98, 0x11, 0x69, 0xD9, 0x8E, 0x94, 0x9B, 0x1E, 0x87, 0xE9, 0xCE, 0x55, 0x28, 0xDF,
+    0x8C, 0xA1, 0x89, 0x0D, 0xBF, 0xE6, 0x42, 0x68, 0x41, 0x99, 0x2D, 0x0F, 0xB0, 0x54, 0xBB, 0x16,
+)
+_INV_SBOX = tuple(_SBOX.index(i) for i in range(256))
+_RCON = (0x00, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x1B, 0x36)
+
+
+def _xtime(a: int) -> int:
+    return ((a << 1) ^ 0x1B) & 0xFF if a & 0x80 else (a << 1) & 0xFF
+
+
+def _mul(a: int, b: int) -> int:
+    r = 0
+    for _ in range(8):
+        if b & 1:
+            r ^= a
+        a = _xtime(a)
+        b >>= 1
+    return r
+
+
+def _expand_key(key: bytes) -> list[list[int]]:
+    if len(key) != 16:
+        raise ValueError("AES-128 key must be 16 bytes")
+    w = list(key)
+    for i in range(4, 44):
+        t = w[(i - 1) * 4 : i * 4]
+        if i % 4 == 0:
+            t = [_SBOX[t[1]] ^ _RCON[i // 4], _SBOX[t[2]], _SBOX[t[3]], _SBOX[t[0]]]
+        w.extend(w[(i - 4) * 4 + j] ^ t[j] for j in range(4))
+    return [w[i : i + 16] for i in range(0, 176, 16)]
+
+
+def _add_round_key(s: list[int], rk: list[int]) -> None:
+    for i in range(16):
+        s[i] ^= rk[i]
+
+
+def _sub_bytes(s: list[int], box: tuple[int, ...]) -> None:
+    for i in range(16):
+        s[i] = box[s[i]]
+
+
+def _shift_rows(s: list[int]) -> None:
+    s[1], s[5], s[9], s[13] = s[5], s[9], s[13], s[1]
+    s[2], s[6], s[10], s[14] = s[10], s[14], s[2], s[6]
+    s[3], s[7], s[11], s[15] = s[15], s[3], s[7], s[11]
+
+
+def _inv_shift_rows(s: list[int]) -> None:
+    s[1], s[5], s[9], s[13] = s[13], s[1], s[5], s[9]
+    s[2], s[6], s[10], s[14] = s[10], s[14], s[2], s[6]
+    s[3], s[7], s[11], s[15] = s[7], s[11], s[15], s[3]
+
+
+def _mix_columns(s: list[int]) -> None:
+    for c in range(4):
+        i = c * 4
+        a, b, d, e = s[i], s[i + 1], s[i + 2], s[i + 3]
+        s[i] = _mul(a, 2) ^ _mul(b, 3) ^ d ^ e
+        s[i + 1] = a ^ _mul(b, 2) ^ _mul(d, 3) ^ e
+        s[i + 2] = a ^ b ^ _mul(d, 2) ^ _mul(e, 3)
+        s[i + 3] = _mul(a, 3) ^ b ^ d ^ _mul(e, 2)
+
+
+def _inv_mix_columns(s: list[int]) -> None:
+    for c in range(4):
+        i = c * 4
+        a, b, d, e = s[i], s[i + 1], s[i + 2], s[i + 3]
+        s[i] = _mul(a, 14) ^ _mul(b, 11) ^ _mul(d, 13) ^ _mul(e, 9)
+        s[i + 1] = _mul(a, 9) ^ _mul(b, 14) ^ _mul(d, 11) ^ _mul(e, 13)
+        s[i + 2] = _mul(a, 13) ^ _mul(b, 9) ^ _mul(d, 14) ^ _mul(e, 11)
+        s[i + 3] = _mul(a, 11) ^ _mul(b, 13) ^ _mul(d, 9) ^ _mul(e, 14)
+
+
+def _encrypt_block(block: bytes, round_keys: list[list[int]]) -> bytes:
+    s = list(block)
+    _add_round_key(s, round_keys[0])
+    for r in range(1, 10):
+        _sub_bytes(s, _SBOX)
+        _shift_rows(s)
+        _mix_columns(s)
+        _add_round_key(s, round_keys[r])
+    _sub_bytes(s, _SBOX)
+    _shift_rows(s)
+    _add_round_key(s, round_keys[10])
+    return bytes(s)
+
+
+def _decrypt_block(block: bytes, round_keys: list[list[int]]) -> bytes:
+    s = list(block)
+    _add_round_key(s, round_keys[10])
+    for r in range(9, 0, -1):
+        _inv_shift_rows(s)
+        _sub_bytes(s, _INV_SBOX)
+        _add_round_key(s, round_keys[r])
+        _inv_mix_columns(s)
+    _inv_shift_rows(s)
+    _sub_bytes(s, _INV_SBOX)
+    _add_round_key(s, round_keys[0])
+    return bytes(s)
+
+
+def _pkcs7_pad(data: bytes) -> bytes:
+    n = 16 - (len(data) % 16)
+    return data + bytes([n] * n)
+
+
+def _pkcs7_unpad(data: bytes) -> bytes:
+    if not data or len(data) % 16:
+        raise ValueError("invalid padding")
+    n = data[-1]
+    if n < 1 or n > 16 or data[-n:] != bytes([n] * n):
+        raise ValueError("invalid padding")
+    return data[:-n]
+
+
+def aes_cbc_encrypt(key16: bytes, iv: bytes, plain: bytes) -> bytes:
+    if len(iv) != 16:
+        raise ValueError("IV must be 16 bytes")
+    round_keys = _expand_key(key16)
+    data = _pkcs7_pad(plain)
+    out = bytearray()
+    prev = iv
+    for i in range(0, len(data), 16):
+        block = bytes(a ^ b for a, b in zip(data[i : i + 16], prev))
+        enc = _encrypt_block(block, round_keys)
+        out.extend(enc)
+        prev = enc
+    return bytes(out)
+
+
+def aes_cbc_decrypt(key16: bytes, iv: bytes, cipher: bytes) -> bytes:
+    if len(iv) != 16 or len(cipher) % 16:
+        raise ValueError("invalid ciphertext")
+    round_keys = _expand_key(key16)
+    out = bytearray()
+    prev = iv
+    for i in range(0, len(cipher), 16):
+        block = cipher[i : i + 16]
+        dec = _decrypt_block(block, round_keys)
+        out.extend(a ^ b for a, b in zip(dec, prev))
+        prev = block
+    return _pkcs7_unpad(bytes(out))
+
+
+# --- Fernet（与 cryptography.fernet 兼容）---
+
+
+class InvalidToken(Exception):
+    pass
+
+
+class FernetLite:
+    """urlsafe-b64 32 字节 key：前 16 签名，后 16 加密。"""
+
+    def __init__(self, key: bytes | str):
+        if isinstance(key, str):
+            key = key.encode("ascii")
+        raw = base64.urlsafe_b64decode(key)
+        if len(raw) != 32:
+            raise ValueError("Fernet key must be 32 url-safe base64-encoded bytes")
+        self._signing_key = raw[:16]
+        self._encryption_key = raw[16:]
+
+    def encrypt(self, data: bytes) -> bytes:
+        iv = os.urandom(16)
+        ts = int(time.time())
+        ciphertext = aes_cbc_encrypt(self._encryption_key, iv, data)
+        basic = b"\x80" + struct.pack(">Q", ts) + iv + ciphertext
+        digest = hmac.new(self._signing_key, basic, hashlib.sha256).digest()
+        return base64.urlsafe_b64encode(basic + digest)
+
+    def decrypt(self, token: bytes, ttl: int | None = None) -> bytes:
+        try:
+            data = base64.urlsafe_b64decode(token)
+        except Exception as e:
+            raise InvalidToken("invalid token") from e
+        if len(data) < 1 + 8 + 16 + 16 + 32 or data[0] != 0x80:
+            raise InvalidToken("invalid token")
+        basic, digest = data[:-32], data[-32:]
+        expect = hmac.new(self._signing_key, basic, hashlib.sha256).digest()
+        if not hmac.compare_digest(digest, expect):
+            raise InvalidToken("invalid token")
+        ts = struct.unpack(">Q", basic[1:9])[0]
+        if ttl is not None and int(time.time()) - ts > ttl:
+            raise InvalidToken("token expired")
+        iv = basic[9:25]
+        ciphertext = basic[25:]
+        try:
+            return aes_cbc_decrypt(self._encryption_key, iv, ciphertext)
+        except ValueError as e:
+            raise InvalidToken("invalid token") from e
+
+
+def derive_fernet_key(password: str, salt: bytes, iterations: int = 390_000) -> bytes:
+    raw = hashlib.pbkdf2_hmac("sha256", password.encode("utf-8"), salt, iterations, dklen=32)
+    return base64.urlsafe_b64encode(raw)

pyfernet/loader.py

@@ -0,0 +1,195 @@
+"""解密 .enc 到内存 VFS 并执行；源码文件不落盘。
+
+磁盘上只建空目录树（供 Path(__file__)/chdir）；内容经 open/Path/import hook 从内存读。
+进程结束删除空目录。
+"""
+
+from __future__ import annotations
+
+import getpass
+import io
+import json
+import os
+import shutil
+import sys
+import tempfile
+import types
+import zipfile
+from pathlib import Path
+
+from pyfernet.constants import KDF_ITERATIONS, MAGIC, MANIFEST_NAME, SALT_LEN
+from pyfernet.fernet_lite import FernetLite, InvalidToken, derive_fernet_key
+from pyfernet.vfs import PayloadVFS
+
+
+def _configure_stdio() -> None:
+    """避免非 TTY / nohup / 管道下 stdout 块缓冲导致日志不实时。"""
+    os.environ.setdefault("PYTHONUNBUFFERED", "1")
+    for stream in (sys.stdout, sys.stderr):
+        try:
+            stream.reconfigure(line_buffering=True)  # type: ignore[attr-defined]
+        except Exception:
+            try:
+                stream.reconfigure(write_through=True)  # type: ignore[attr-defined]
+            except Exception:
+                pass
+
+
+def decrypt_payload(enc_path: Path, password: str) -> bytes:
+    raw = enc_path.read_bytes()
+    if not raw.startswith(MAGIC):
+        raise ValueError(f"不是 PyFernet 密文包（magic 不匹配）: {enc_path}")
+    salt = raw[len(MAGIC) : len(MAGIC) + SALT_LEN]
+    token = raw[len(MAGIC) + SALT_LEN :]
+    key = derive_fernet_key(password, salt, KDF_ITERATIONS)
+    try:
+        return FernetLite(key).decrypt(token)
+    except InvalidToken as e:
+        raise ValueError("口令错误或密文损坏") from e
+
+
+def _empty_root() -> Path:
+    """仅作路径锚点的空目录（Linux 优先 /dev/shm）。"""
+    base: str | None = None
+    if sys.platform.startswith("linux"):
+        shm = Path("/dev/shm")
+        if shm.is_dir():
+            base = str(shm)
+    return Path(tempfile.mkdtemp(prefix="pyfernet_", dir=base))
+
+
+def _zip_to_mapping(zip_bytes: bytes) -> tuple[dict[str, bytes], str]:
+    mapping: dict[str, bytes] = {}
+    with zipfile.ZipFile(io.BytesIO(zip_bytes), "r") as zf:
+        if MANIFEST_NAME not in zf.namelist():
+            raise ValueError("密文包缺少 manifest")
+        manifest = json.loads(zf.read(MANIFEST_NAME).decode("utf-8"))
+        entry = str(manifest["entry_point"]).replace("\\", "/")
+        for info in zf.infolist():
+            name = info.filename.replace("\\", "/")
+            if name.endswith("/") or name == MANIFEST_NAME:
+                continue
+            mapping[name] = zf.read(info)
+    return mapping, entry
+
+
+def list_payload(payload_path: str | Path, password: str) -> tuple[str, list[str]]:
+    """解密并返回 (entry_point, 相对路径列表)。"""
+    zip_bytes = decrypt_payload(Path(payload_path), password)
+    mapping, entry = _zip_to_mapping(zip_bytes)
+    return entry, sorted(mapping.keys())
+
+
+def run_entry(zip_bytes: bytes, argv: list[str] | None = None) -> None:
+    _configure_stdio()
+    mapping, entry_rel = _zip_to_mapping(zip_bytes)
+    if entry_rel not in mapping:
+        raise RuntimeError(f"入口不在密文包内: {entry_rel}")
+
+    root = _empty_root()
+    vfs = PayloadVFS(root, mapping)
+    vfs.ensure_dir_tree()
+    vfs.install()
+    try:
+        entry = (root / entry_rel).resolve()
+        if argv is not None:
+            sys.argv = list(argv)
+
+        root_s = str(root)
+        entry_dir = str(entry.parent)
+        for p in (entry_dir, root_s):
+            if p in sys.path:
+                sys.path.remove(p)
+            sys.path.insert(0, p)
+
+        source = vfs.read_bytes(entry)
+        main_mod = types.ModuleType("__main__")
+        main_mod.__file__ = str(entry)
+        parent_pkg = entry_rel.replace("\\", "/").rsplit("/", 1)
+        if len(parent_pkg) == 2:
+            main_mod.__package__ = parent_pkg[0].replace("/", ".")
+        else:
+            main_mod.__package__ = ""
+        sys.modules["__main__"] = main_mod
+        code = compile(source, str(entry), "exec")
+        try:
+            exec(code, main_mod.__dict__)
+        except FileNotFoundError as e:
+            missing = str(e)
+            hint = _missing_pack_hint(missing, root, mapping)
+            if hint:
+                raise FileNotFoundError(f"{e}\n{hint}") from e
+            raise
+    finally:
+        vfs.uninstall()
+        shutil.rmtree(root, ignore_errors=True)
+
+
+def _missing_pack_hint(err: str, root: Path, mapping: dict[str, bytes]) -> str:
+    """若缺失路径落在 VFS 根下，提示密文包未打包该相对路径。"""
+    root_s = str(root.resolve())
+    # FileNotFoundError 可能是 "缺少脚本: /path" 或纯路径
+    path_str = err
+    for prefix in ("缺少脚本: ", "配置不存在: ", "[Errno 2] No such file or directory: "):
+        if prefix in err:
+            path_str = err.split(prefix, 1)[-1].strip().strip("'\"")
+            break
+    try:
+        rel = Path(path_str).resolve().relative_to(Path(root_s))
+    except Exception:
+        return ""
+    rel_s = rel.as_posix()
+    if rel_s in mapping:
+        return ""
+    top = rel_s.split("/", 1)[0]
+    siblings = sorted({p.split("/", 1)[0] for p in mapping})
+    return (
+        f"pyfernet: 密文包内没有 `{rel_s}`。\n"
+        f"  当前包内顶层目录/文件: {siblings}\n"
+        f"  请把入口依赖的兄弟目录一起打进加密源目录后重新 encrypt"
+        + (f"（例如补上 `{top}/`）。" if top else "。")
+    )
+
+
+def run_payload(
+    payload_path: str | Path,
+    password: str,
+    argv: list[str] | None = None,
+) -> None:
+    """解密并执行密文包（库接口）。"""
+    path = Path(payload_path)
+    if not path.is_file():
+        raise FileNotFoundError(f"找不到密文包: {path}")
+    zip_bytes = decrypt_payload(path, password)
+    run_entry(zip_bytes, argv=argv)
+
+
+def main(
+    payload_path: str,
+    password: str | None = None,
+    argv: list[str] | None = None,
+) -> None:
+    path = Path(payload_path)
+    if not path.is_file():
+        raise SystemExit(f"找不到密文包: {path}")
+
+    if password is None:
+        password = getpass.getpass("解密口令: ")
+
+    run_payload(path, password, argv=argv)
+
+
+def _ide_main() -> None:
+    PAYLOAD_PATH = "dist/train_payload.enc"
+    PASSWORD = None
+    TRAIN_ARGV = ["train.py"]
+
+    main(payload_path=PAYLOAD_PATH, password=PASSWORD, argv=TRAIN_ARGV)
+
+
+if __name__ == "__main__":
+    if len(sys.argv) > 1:
+        from pyfernet.cli import main as cli_main
+
+        raise SystemExit(cli_main(["run", *sys.argv[1:]]))
+    _ide_main()

pyfernet/py.typed

@@ -0,0 +1 @@
+# 标记本包支持类型检查（无单独 stub）

pyfernet/vfs.py

@@ -0,0 +1,251 @@
+"""内存 VFS：包内文件不落盘，Path/open/import 从内存读。"""
+
+from __future__ import annotations
+
+import builtins
+import importlib.abc
+import importlib.machinery
+import importlib.util
+import io
+import os
+import sys
+from pathlib import Path
+from typing import Callable
+
+
+class PayloadVFS:
+    """root 下仅有空目录；文件内容在 mapping（相对 posix 路径 → bytes）。"""
+
+    def __init__(self, root: Path, mapping: dict[str, bytes]):
+        self.root = root.resolve()
+        self.rel_files = {k.replace("\\", "/"): v for k, v in mapping.items()}
+        self.abs_files: dict[str, bytes] = {}
+        for rel, data in self.rel_files.items():
+            abs_p = (self.root / rel).resolve()
+            self.abs_files[str(abs_p)] = data
+            self.abs_files[abs_p.as_posix()] = data
+
+        self._orig_open = builtins.open
+        self._orig_path_open = Path.open
+        self._orig_read_text = Path.read_text
+        self._orig_read_bytes = Path.read_bytes
+        self._orig_is_file = Path.is_file
+        self._orig_exists = Path.exists
+        self._orig_os_path_isfile = os.path.isfile
+        self._orig_os_path_exists = os.path.exists
+        self._orig_spec_from_file_location = importlib.util.spec_from_file_location
+        self._path_hook: Callable | None = None
+        self._installed = False
+
+    def _norm_key(self, path: str | Path) -> str | None:
+        try:
+            p = Path(path)
+            if not p.is_absolute():
+                p = Path.cwd() / p
+            key = str(p.resolve())
+        except Exception:
+            key = str(path)
+        if key in self.abs_files:
+            return key
+        try:
+            alt = Path(path)
+            key2 = str((self.root / alt).resolve()) if not alt.is_absolute() else str(alt.resolve())
+            if key2 in self.abs_files:
+                return key2
+        except Exception:
+            pass
+        return None
+
+    def has(self, path: str | Path) -> bool:
+        return self._norm_key(path) is not None
+
+    def read_bytes(self, path: str | Path) -> bytes:
+        key = self._norm_key(path)
+        if key is None:
+            raise FileNotFoundError(path)
+        return self.abs_files[key]
+
+    def managed_dir(self, path: str | Path) -> bool:
+        try:
+            Path(path).resolve().relative_to(self.root)
+            return True
+        except Exception:
+            return False
+
+    def ensure_dir_tree(self) -> None:
+        """只创建空目录，不写任何文件内容。"""
+        self.root.mkdir(parents=True, exist_ok=True)
+        for rel in self.rel_files:
+            (self.root / rel).parent.mkdir(parents=True, exist_ok=True)
+
+    def install(self) -> None:
+        if self._installed:
+            return
+        vfs = self
+
+        def open_hook(file, mode="r", *args, **kwargs):
+            if isinstance(file, (str, os.PathLike)) and vfs.has(file):
+                data = vfs.read_bytes(file)
+                if "b" in mode:
+                    return io.BytesIO(data)
+                enc = kwargs.get("encoding") or "utf-8"
+                return io.StringIO(data.decode(enc))
+            return vfs._orig_open(file, mode, *args, **kwargs)
+
+        def path_open(self: Path, mode="r", *args, **kwargs):
+            if vfs.has(self):
+                return open_hook(self, mode, *args, **kwargs)
+            return vfs._orig_path_open(self, mode, *args, **kwargs)
+
+        def path_read_text(self: Path, encoding="utf-8", errors="strict"):
+            if vfs.has(self):
+                return vfs.read_bytes(self).decode(encoding, errors)
+            return vfs._orig_read_text(self, encoding=encoding, errors=errors)
+
+        def path_read_bytes(self: Path):
+            if vfs.has(self):
+                return vfs.read_bytes(self)
+            return vfs._orig_read_bytes(self)
+
+        def path_is_file(self: Path):
+            if vfs.has(self):
+                return True
+            return vfs._orig_is_file(self)
+
+        def path_exists(self: Path):
+            if vfs.has(self):
+                return True
+            return vfs._orig_exists(self)
+
+        def os_isfile(path):
+            if vfs.has(path):
+                return True
+            return vfs._orig_os_path_isfile(path)
+
+        def os_exists(path):
+            if vfs.has(path):
+                return True
+            return vfs._orig_os_path_exists(path)
+
+        def spec_from_file_location(name, location, *args, **kwargs):
+            if location is not None and vfs.has(location):
+                loc = str(Path(location).resolve())
+                source = vfs.read_bytes(location)
+                is_pkg = loc.endswith(f"{os.sep}__init__.py") or loc.endswith("/__init__.py")
+                loader = _VfsSourceLoader(name, loc, source, is_package=is_pkg)
+                spec = importlib.machinery.ModuleSpec(
+                    name, loader, origin=loc, is_package=is_pkg
+                )
+                if is_pkg:
+                    spec.submodule_search_locations = [str(Path(loc).parent)]
+                return spec
+            return vfs._orig_spec_from_file_location(name, location, *args, **kwargs)
+
+        def path_hook(entry):
+            if vfs.managed_dir(entry):
+                return _VfsPathFinder(vfs, str(Path(entry).resolve()))
+            raise ImportError("not a pyfernet vfs path")
+
+        builtins.open = open_hook  # type: ignore[assignment]
+        Path.open = path_open  # type: ignore[method-assign, assignment]
+        Path.read_text = path_read_text  # type: ignore[method-assign, assignment]
+        Path.read_bytes = path_read_bytes  # type: ignore[method-assign, assignment]
+        Path.is_file = path_is_file  # type: ignore[method-assign, assignment]
+        Path.exists = path_exists  # type: ignore[method-assign, assignment]
+        os.path.isfile = os_isfile  # type: ignore[assignment]
+        os.path.exists = os_exists  # type: ignore[assignment]
+        importlib.util.spec_from_file_location = spec_from_file_location  # type: ignore[assignment]
+
+        self._path_hook = path_hook
+        sys.path_hooks.insert(0, path_hook)
+        sys.path_importer_cache.clear()
+        importlib.invalidate_caches()
+        self._installed = True
+
+    def uninstall(self) -> None:
+        if not self._installed:
+            return
+        builtins.open = self._orig_open  # type: ignore[assignment]
+        Path.open = self._orig_path_open  # type: ignore[method-assign, assignment]
+        Path.read_text = self._orig_read_text  # type: ignore[method-assign, assignment]
+        Path.read_bytes = self._orig_read_bytes  # type: ignore[method-assign, assignment]
+        Path.is_file = self._orig_is_file  # type: ignore[method-assign, assignment]
+        Path.exists = self._orig_exists  # type: ignore[method-assign, assignment]
+        os.path.isfile = self._orig_os_path_isfile  # type: ignore[assignment]
+        os.path.exists = self._orig_os_path_exists  # type: ignore[assignment]
+        importlib.util.spec_from_file_location = self._orig_spec_from_file_location  # type: ignore[assignment]
+        if self._path_hook is not None:
+            try:
+                sys.path_hooks.remove(self._path_hook)
+            except ValueError:
+                pass
+        sys.path_importer_cache.clear()
+        importlib.invalidate_caches()
+        self._installed = False
+
+
+class _VfsSourceLoader(importlib.abc.Loader):
+    def __init__(self, name: str, path: str, source: bytes, is_package: bool = False):
+        self.name = name
+        self.path = path
+        self.source = source
+        self.is_package = is_package
+
+    def create_module(self, spec):
+        return None
+
+    def exec_module(self, module):
+        module.__file__ = self.path
+        if self.is_package:
+            module.__path__ = [str(Path(self.path).parent)]
+            module.__package__ = self.name
+        else:
+            parent, _, _ = self.name.rpartition(".")
+            module.__package__ = parent
+        code = compile(self.source, self.path, "exec")
+        exec(code, module.__dict__)
+
+    def get_filename(self, fullname):
+        return self.path
+
+    def is_package(self, fullname):
+        return self.is_package
+
+    def get_data(self, path):
+        with open(path, "rb") as f:
+            return f.read()
+
+
+class _VfsPathFinder(importlib.abc.PathEntryFinder):
+    """行为对齐 importlib.machinery.FileFinder：只用 fullname 最后一段。"""
+
+    def __init__(self, vfs: PayloadVFS, path_entry: str):
+        self.vfs = vfs
+        self.path_entry = path_entry
+
+    def find_spec(self, fullname, target=None):
+        base = Path(self.path_entry)
+        # 与 FileFinder 一致：path 已是包目录或 sys.path 项时，只找 tail
+        tail = fullname.rpartition(".")[2]
+        file_cand = base / f"{tail}.py"
+        pkg_cand = base / tail / "__init__.py"
+
+        if self.vfs.has(pkg_cand):
+            origin = str(pkg_cand.resolve())
+            source = self.vfs.read_bytes(pkg_cand)
+            loader = _VfsSourceLoader(fullname, origin, source, is_package=True)
+            spec = importlib.machinery.ModuleSpec(
+                fullname, loader, origin=origin, is_package=True
+            )
+            spec.submodule_search_locations = [str(pkg_cand.parent.resolve())]
+            return spec
+
+        if self.vfs.has(file_cand):
+            origin = str(file_cand.resolve())
+            source = self.vfs.read_bytes(file_cand)
+            loader = _VfsSourceLoader(fullname, origin, source, is_package=False)
+            return importlib.machinery.ModuleSpec(
+                fullname, loader, origin=origin, is_package=False
+            )
+
+        return None

pyfernet_payload-0.2.4.dist-info/METADATA

@@ -0,0 +1,151 @@
+Metadata-Version: 2.4
+Name: pyfernet-payload
+Version: 0.2.4
+Summary: Encrypt a Python source directory into one .enc file and run it from memory (Fernet AES, stdlib-only).
+Home-page: https://github.com/yinshunyao/PyFernet
+Author: shunyaoyin
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/yinshunyao/PyFernet
+Project-URL: Issues, https://github.com/yinshunyao/PyFernet/issues
+Project-URL: Documentation, https://github.com/yinshunyao/PyFernet#readme
+Keywords: fernet,aes,encrypt,source-protection,in-memory,training
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Security :: Cryptography
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: requires-python
+
+# PyFernet (`pyfernet-payload`)
+
+[中文说明](README.zh-CN.md)
+
+Pack a training source directory into a single `.enc` blob; on the client, decrypt and run from an **in-memory VFS**. Only an **empty directory tree** is created on disk (for `Path(__file__)` / `chdir`); `.py` / config **contents are never written**. Removed on exit.
+
+- **Zero third-party runtime deps** (stdlib AES-128-CBC + Fernet-compatible format)
+- **PyPI name**: `pyfernet-payload` (`pyfernet` is already taken)
+- **CLI / import**: `pyfernet` / `import pyfernet`
+- **Relative paths work**: `Path(__file__).parent / "train_config.json"`, `open`, `spec_from_file_location` via VFS hooks
+
+## Install
+
+```bash
+pip install pyfernet-payload
+```
+
+From a local clone:
+
+```bash
+# preferred on older pip / mirrors (no editable hook needed)
+python3 -m pip install .
+
+# or editable (dev); if this fails, upgrade pip first:
+python3 -m pip install -U pip setuptools wheel
+python3 -m pip install -e .
+```
+## CLI
+
+### Encrypt
+
+```bash
+pyfernet encrypt ./my_train -o train_payload.enc -e train.py
+# passphrase via prompt; or:
+export PYFERNET_PASSWORD='your-secret'
+pyfernet encrypt ./my_train -o train_payload.enc -e train.py --password-env PYFERNET_PASSWORD
+```
+
+### Run
+
+```bash
+pyfernet run train_payload.enc
+# forward args to the training entry (after --):
+pyfernet run train_payload.enc -- --epochs 50 --batch 8
+```
+
+Equivalent:
+
+```bash
+python -m pyfernet encrypt ./my_train -o train_payload.enc -e train.py
+python -m pyfernet run train_payload.enc
+```
+
+## Workflow
+
+1. **Local**: write training code → `pyfernet encrypt` → `train_payload.enc`
+2. **SFTP**: upload the ciphertext only (client already has `pip install pyfernet-payload`)
+3. **SSH**: `pyfernet run train_payload.enc`, enter passphrase
+4. Decrypt into memory → empty dir anchors + VFS hooks → start training; write weights to a normal disk path
+5. On exit, remove empty dirs; durable disk still has only ciphertext
+
+If the entry uses sibling dirs (e.g. `train_detect_rtdetrv2/` + `train_detect_cfg/` + `train_detect_yolo/`), **encrypt the parent folder** and set `-e train_detect_rtdetrv2/train_insect.py`.
+
+Inference code, datasets, and weights can stay plaintext on the client.
+
+## IDE variable mode (optional)
+
+With no CLI args, modules use the variables at the bottom of the file:
+
+```bash
+python -m pyfernet.encryptor   # no args → SOURCE_DIR / OUTPUT_PATH / ENTRY_POINT
+python -m pyfernet.loader      # no args → PAYLOAD_PATH / TRAIN_ARGV
+```
+
+With args, they use the CLI, e.g. `python -m pyfernet.encryptor ./src -o out.enc -e train.py`.
+
+## Library API
+
+```python
+from pyfernet import encrypt_directory, run_payload
+
+encrypt_directory("examples/demo_train", "dist/train_payload.enc", "train.py", "secret")
+run_payload("dist/train_payload.enc", "secret", argv=["train.py", "--epochs", "1"])
+```
+
+## Payload format
+
+```text
+PYFE1\0  +  16B salt  +  Fernet(token)
+```
+
+Fernet plaintext is a zip (sources + `_pyfernet_manifest.json`). The passphrase is stretched with PBKDF2-HMAC-SHA256 (390000 iterations).
+
+## Notes
+
+- Source file **bytes never hit disk**; only empty directories exist briefly (often under `/dev/shm` on Linux)
+- Process memory / debuggers can still see plaintext; a leaked passphrase decrypts the blob
+- By default only `.py` and a few config suffixes are packed—do not put datasets or weights in the blob
+- The client still needs training deps installed (torch, ultralytics, etc.)
+
+## Publish to PyPI
+
+See [docs/PUBLISH.md](docs/PUBLISH.md) ([中文](docs/PUBLISH.zh-CN.md)).
+
+## Layout
+
+```text
+PyFernet/
+  pyproject.toml
+  README.md              # English (PyPI)
+  README.zh-CN.md        # Chinese
+  src/pyfernet/
+    cli.py
+    encryptor.py
+    loader.py
+    fernet_lite.py
+  examples/demo_train/
+  docs/PUBLISH.md
+  docs/PUBLISH.zh-CN.md
+```

pyfernet_payload-0.2.4.dist-info/RECORD

@@ -0,0 +1,15 @@
+pyfernet/__init__.py,sha256=GrJ4DeIiGby-l6p9cB2HS68wH6z1z5brbtSNvAKzMt4,313
+pyfernet/__main__.py,sha256=CganAFN0J0O8bAwcENySBGUQ4XqDSqbp5cvltMxYtN0,160
+pyfernet/cli.py,sha256=ciUE71bjbVCqr4nor9YGobuS0sud2KsByMY29aynxKE,5555
+pyfernet/constants.py,sha256=CXW0GkMAs-9saRRn57UhS8oOCl4Qal1s6q6yXdvDOXU,516
+pyfernet/encryptor.py,sha256=TRQwfQqcaeSkwZWl6sHInHctaDSyzhIg9p2cJd-AFPo,4091
+pyfernet/fernet_lite.py,sha256=iN3WxA_JTbz_LS7xXG7gOliGv3DL7Txxviy-9177y1E,8414
+pyfernet/loader.py,sha256=V3XzFRFyvbpwHhmIl7YSVaZXY2OHG0FLuI_cppT1K9Y,6501
+pyfernet/py.typed,sha256=gTk4rCnF8L8nqyz-gwOZm96JOkosxmWl8kJbPk6PzPU,53
+pyfernet/vfs.py,sha256=K5fujSgQExqNttpvpFVk3YrwEhuMluBQyWmXQ19brxQ,9670
+pyfernet_payload-0.2.4.dist-info/licenses/LICENSE,sha256=lVKlwS2wB5VI_fWciEFSLQ3BtH_rytZxueolGL69Kpk,1067
+pyfernet_payload-0.2.4.dist-info/METADATA,sha256=WUbjQj9FPqFcpNtEE0KkLWGSpFDM_ZS-bZYuuQURTKo,5121
+pyfernet_payload-0.2.4.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+pyfernet_payload-0.2.4.dist-info/entry_points.txt,sha256=nluXpMn3K9qt0Cx-DpEkp3lQ9Kd0s3PgirpQkVUIl7Q,47
+pyfernet_payload-0.2.4.dist-info/top_level.txt,sha256=u17EFBp7_dRhGP3rVq7kr2gEj6U1DJenrpRcdJZQqpU,9
+pyfernet_payload-0.2.4.dist-info/RECORD,,

pyfernet_payload-0.2.4.dist-info/WHEEL

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

pyfernet_payload-0.2.4.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+pyfernet = pyfernet.cli:main

pyfernet_payload-0.2.4.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 shunyaoyin
+
+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.

pyfernet_payload-0.2.4.dist-info/top_level.txt

@@ -0,0 +1 @@
+pyfernet