PyProtect-v3 3.0.0__tar.gz

pyprotect_v3-3.0.0/MANIFEST.in

@@ -0,0 +1,3 @@
+include pyprotect/engine.c
+include pyprotect/_key.py
+include README.md

pyprotect_v3-3.0.0/PKG-INFO

@@ -0,0 +1,135 @@
+Metadata-Version: 2.4
+Name: PyProtect-v3
+Version: 3.0.0
+Summary: Python script obfuscation library with AES-256-GCM encryption and C extension acceleration
+Author-email: NguyenNgocNam <c.nam020213@gmail.com>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/PyProtect/PyProtect
+Project-URL: Repository, https://github.com/PyProtect/PyProtect
+Keywords: obfuscation,security,cryptography,anti-debug,protection
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Software Development :: Build Tools
+Classifier: Topic :: Security :: Cryptography
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: C
+Classifier: Operating System :: OS Independent
+Classifier: Environment :: Console
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: setuptools>=42.0.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Requires-Dist: pytest-cov>=4.0; extra == "dev"
+Provides-Extra: build
+Requires-Dist: wheel>=0.27.0; extra == "build"
+Requires-Dist: build>=0.7.0; extra == "build"
+
+# pyprotect-v3
+
+A production-ready Python script obfuscation library with AES-256-GCM encryption,
+multi-platform C extension acceleration, and graceful pure-Python fallback.
+
+## Features
+
+- **AES-256-GCM Encryption** — Industry-standard authenticated encryption
+- **C Extension Acceleration** — Native code for decryption, anti-debug, and execution
+- **Multi-Platform** — Windows, macOS, Linux with platform-specific anti-debug
+- **Pure Python Fallback** — Graceful degradation if C extension fails to build
+- **Import Hook Support** — Protect entire packages with transparent decryption
+- **CLI Tool** — Simple command-line interface for obfuscating scripts
+- **PyPI Ready** — Upload to PyPI with `pip install pyprotect-v3`
+
+## Quick Start
+
+### Install
+
+```bash
+pip install pyprotect-v3
+```
+
+### Obfuscate a Script
+
+```bash
+# Encrypt a single file
+python -m pyprotect encrypt my_script.py -o dist/
+
+# Encrypt an entire package
+python -m pyprotect encrypt-dir mypackage/ -o dist/
+
+# Build C extension only
+python -m pyprotect build-engine
+```
+
+### Programmatic Usage
+
+```python
+from pyprotect import Obfuscator
+
+obf = Obfuscator()
+obf.encrypt_file("my_script.py")
+```
+
+### Run an Obfuscated Script
+
+```bash
+python my_script_protected.py
+```
+
+The script will automatically:
+1. Try to load the C extension for native decryption
+2. Fall back to pure Python if C extension unavailable
+3. Decrypt and execute the original code
+
+### Protect a Package with Import Hook
+
+```python
+from pyprotect.hooks import install_hook
+
+hook = install_hook(key=b"your-32-byte-key-here!!!!!!")
+import my_protected_module
+```
+
+## Architecture
+
+```
+pyprotect-v3/
+├── pyprotect/
+│   ├── __init__.py        # Package init, version info
+│   ├── __main__.py        # CLI: python -m pyprotect
+│   ├── obfuscator.py      # Main obfuscation tool
+│   ├── engine.c           # Cross-platform C extension
+│   ├── engine.py          # Pure Python fallback engine
+│   ├── crypto.py          # AES-GCM encryption (ctypes + pure Python)
+│   ├── anti_debug.py      # Anti-debug checks (Python fallback)
+│   └── hooks.py           # Import hook for multi-module protection
+├── setup.py               # PyPI-ready setup
+├── pyproject.toml         # Build configuration
+└── README.md              # This file
+```
+
+## Anti-Debug Features
+
+| Platform | Techniques |
+|----------|------------|
+| **Linux** | `/proc/self/status` TracerPid, `ptrace(PTRACE_TRACEME)` |
+| **Windows** | `IsDebuggerPresent()`, `CheckRemoteDebuggerPresent()`, `NtQueryInformationProcess()` |
+| **macOS** | `ptrace(PT_DENY_ATTACH)`, `sysctl` `KERN_PROC` |
+
+## C Extension Fallback
+
+If the C extension fails to build (no C compiler, missing OpenSSL, etc.),
+pyprotect-v3 automatically uses a pure Python fallback that:
+
+- Uses `ctypes` to call OpenSSL for AES-GCM decryption if available
+- Falls back to a built-in pure Python AES-256-GCM implementation
+- Performs anti-debug checks via `os`, `sys`, and `ctypes`
+
+## License
+
+MIT

pyprotect_v3-3.0.0/PyProtect_v3.egg-info/PKG-INFO

@@ -0,0 +1,135 @@
+Metadata-Version: 2.4
+Name: PyProtect-v3
+Version: 3.0.0
+Summary: Python script obfuscation library with AES-256-GCM encryption and C extension acceleration
+Author-email: NguyenNgocNam <c.nam020213@gmail.com>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/PyProtect/PyProtect
+Project-URL: Repository, https://github.com/PyProtect/PyProtect
+Keywords: obfuscation,security,cryptography,anti-debug,protection
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Software Development :: Build Tools
+Classifier: Topic :: Security :: Cryptography
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: C
+Classifier: Operating System :: OS Independent
+Classifier: Environment :: Console
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: setuptools>=42.0.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Requires-Dist: pytest-cov>=4.0; extra == "dev"
+Provides-Extra: build
+Requires-Dist: wheel>=0.27.0; extra == "build"
+Requires-Dist: build>=0.7.0; extra == "build"
+
+# pyprotect-v3
+
+A production-ready Python script obfuscation library with AES-256-GCM encryption,
+multi-platform C extension acceleration, and graceful pure-Python fallback.
+
+## Features
+
+- **AES-256-GCM Encryption** — Industry-standard authenticated encryption
+- **C Extension Acceleration** — Native code for decryption, anti-debug, and execution
+- **Multi-Platform** — Windows, macOS, Linux with platform-specific anti-debug
+- **Pure Python Fallback** — Graceful degradation if C extension fails to build
+- **Import Hook Support** — Protect entire packages with transparent decryption
+- **CLI Tool** — Simple command-line interface for obfuscating scripts
+- **PyPI Ready** — Upload to PyPI with `pip install pyprotect-v3`
+
+## Quick Start
+
+### Install
+
+```bash
+pip install pyprotect-v3
+```
+
+### Obfuscate a Script
+
+```bash
+# Encrypt a single file
+python -m pyprotect encrypt my_script.py -o dist/
+
+# Encrypt an entire package
+python -m pyprotect encrypt-dir mypackage/ -o dist/
+
+# Build C extension only
+python -m pyprotect build-engine
+```
+
+### Programmatic Usage
+
+```python
+from pyprotect import Obfuscator
+
+obf = Obfuscator()
+obf.encrypt_file("my_script.py")
+```
+
+### Run an Obfuscated Script
+
+```bash
+python my_script_protected.py
+```
+
+The script will automatically:
+1. Try to load the C extension for native decryption
+2. Fall back to pure Python if C extension unavailable
+3. Decrypt and execute the original code
+
+### Protect a Package with Import Hook
+
+```python
+from pyprotect.hooks import install_hook
+
+hook = install_hook(key=b"your-32-byte-key-here!!!!!!")
+import my_protected_module
+```
+
+## Architecture
+
+```
+pyprotect-v3/
+├── pyprotect/
+│   ├── __init__.py        # Package init, version info
+│   ├── __main__.py        # CLI: python -m pyprotect
+│   ├── obfuscator.py      # Main obfuscation tool
+│   ├── engine.c           # Cross-platform C extension
+│   ├── engine.py          # Pure Python fallback engine
+│   ├── crypto.py          # AES-GCM encryption (ctypes + pure Python)
+│   ├── anti_debug.py      # Anti-debug checks (Python fallback)
+│   └── hooks.py           # Import hook for multi-module protection
+├── setup.py               # PyPI-ready setup
+├── pyproject.toml         # Build configuration
+└── README.md              # This file
+```
+
+## Anti-Debug Features
+
+| Platform | Techniques |
+|----------|------------|
+| **Linux** | `/proc/self/status` TracerPid, `ptrace(PTRACE_TRACEME)` |
+| **Windows** | `IsDebuggerPresent()`, `CheckRemoteDebuggerPresent()`, `NtQueryInformationProcess()` |
+| **macOS** | `ptrace(PT_DENY_ATTACH)`, `sysctl` `KERN_PROC` |
+
+## C Extension Fallback
+
+If the C extension fails to build (no C compiler, missing OpenSSL, etc.),
+pyprotect-v3 automatically uses a pure Python fallback that:
+
+- Uses `ctypes` to call OpenSSL for AES-GCM decryption if available
+- Falls back to a built-in pure Python AES-256-GCM implementation
+- Performs anti-debug checks via `os`, `sys`, and `ctypes`
+
+## License
+
+MIT

pyprotect_v3-3.0.0/PyProtect_v3.egg-info/SOURCES.txt

@@ -0,0 +1,19 @@
+MANIFEST.in
+README.md
+pyproject.toml
+setup.py
+PyProtect_v3.egg-info/PKG-INFO
+PyProtect_v3.egg-info/SOURCES.txt
+PyProtect_v3.egg-info/dependency_links.txt
+PyProtect_v3.egg-info/entry_points.txt
+PyProtect_v3.egg-info/requires.txt
+PyProtect_v3.egg-info/top_level.txt
+pyprotect/__init__.py
+pyprotect/__main__.py
+pyprotect/_key.py
+pyprotect/anti_debug.py
+pyprotect/crypto.py
+pyprotect/engine.c
+pyprotect/engine.py
+pyprotect/hooks.py
+pyprotect/obfuscator.py

pyprotect_v3-3.0.0/PyProtect_v3.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

pyprotect_v3-3.0.0/PyProtect_v3.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+pyprotect = pyprotect.__main__:main

pyprotect_v3-3.0.0/PyProtect_v3.egg-info/requires.txt

@@ -0,0 +1,9 @@
+setuptools>=42.0.0
+
+[build]
+wheel>=0.27.0
+build>=0.7.0
+
+[dev]
+pytest>=7.0
+pytest-cov>=4.0

pyprotect_v3-3.0.0/PyProtect_v3.egg-info/top_level.txt

@@ -0,0 +1 @@
+pyprotect

pyprotect_v3-3.0.0/README.md

@@ -0,0 +1,103 @@
+# pyprotect-v3
+
+A production-ready Python script obfuscation library with AES-256-GCM encryption,
+multi-platform C extension acceleration, and graceful pure-Python fallback.
+
+## Features
+
+- **AES-256-GCM Encryption** — Industry-standard authenticated encryption
+- **C Extension Acceleration** — Native code for decryption, anti-debug, and execution
+- **Multi-Platform** — Windows, macOS, Linux with platform-specific anti-debug
+- **Pure Python Fallback** — Graceful degradation if C extension fails to build
+- **Import Hook Support** — Protect entire packages with transparent decryption
+- **CLI Tool** — Simple command-line interface for obfuscating scripts
+- **PyPI Ready** — Upload to PyPI with `pip install pyprotect-v3`
+
+## Quick Start
+
+### Install
+
+```bash
+pip install pyprotect-v3
+```
+
+### Obfuscate a Script
+
+```bash
+# Encrypt a single file
+python -m pyprotect encrypt my_script.py -o dist/
+
+# Encrypt an entire package
+python -m pyprotect encrypt-dir mypackage/ -o dist/
+
+# Build C extension only
+python -m pyprotect build-engine
+```
+
+### Programmatic Usage
+
+```python
+from pyprotect import Obfuscator
+
+obf = Obfuscator()
+obf.encrypt_file("my_script.py")
+```
+
+### Run an Obfuscated Script
+
+```bash
+python my_script_protected.py
+```
+
+The script will automatically:
+1. Try to load the C extension for native decryption
+2. Fall back to pure Python if C extension unavailable
+3. Decrypt and execute the original code
+
+### Protect a Package with Import Hook
+
+```python
+from pyprotect.hooks import install_hook
+
+hook = install_hook(key=b"your-32-byte-key-here!!!!!!")
+import my_protected_module
+```
+
+## Architecture
+
+```
+pyprotect-v3/
+├── pyprotect/
+│   ├── __init__.py        # Package init, version info
+│   ├── __main__.py        # CLI: python -m pyprotect
+│   ├── obfuscator.py      # Main obfuscation tool
+│   ├── engine.c           # Cross-platform C extension
+│   ├── engine.py          # Pure Python fallback engine
+│   ├── crypto.py          # AES-GCM encryption (ctypes + pure Python)
+│   ├── anti_debug.py      # Anti-debug checks (Python fallback)
+│   └── hooks.py           # Import hook for multi-module protection
+├── setup.py               # PyPI-ready setup
+├── pyproject.toml         # Build configuration
+└── README.md              # This file
+```
+
+## Anti-Debug Features
+
+| Platform | Techniques |
+|----------|------------|
+| **Linux** | `/proc/self/status` TracerPid, `ptrace(PTRACE_TRACEME)` |
+| **Windows** | `IsDebuggerPresent()`, `CheckRemoteDebuggerPresent()`, `NtQueryInformationProcess()` |
+| **macOS** | `ptrace(PT_DENY_ATTACH)`, `sysctl` `KERN_PROC` |
+
+## C Extension Fallback
+
+If the C extension fails to build (no C compiler, missing OpenSSL, etc.),
+pyprotect-v3 automatically uses a pure Python fallback that:
+
+- Uses `ctypes` to call OpenSSL for AES-GCM decryption if available
+- Falls back to a built-in pure Python AES-256-GCM implementation
+- Performs anti-debug checks via `os`, `sys`, and `ctypes`
+
+## License
+
+MIT

pyprotect_v3-3.0.0/pyproject.toml

@@ -0,0 +1,47 @@
+[build-system]
+requires = ["setuptools>=42.0.0", "wheel>=0.37.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "PyProtect-v3"
+version = "3.0.0"
+description = "Python script obfuscation library with AES-256-GCM encryption and C extension acceleration"
+readme = "README.md"
+requires-python = ">=3.8"
+license = "MIT"
+keywords = ["obfuscation", "security", "cryptography", "anti-debug", "protection"]
+authors = [
+    {name = "NguyenNgocNam", email = "c.nam020213@gmail.com"},
+]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "Topic :: Software Development :: Build Tools",
+    "Topic :: Security :: Cryptography",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.8",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: C",
+    "Operating System :: OS Independent",
+    "Environment :: Console",
+]
+dependencies = ["setuptools>=42.0.0"]
+
+[project.urls]
+Homepage = "https://github.com/PyProtect/PyProtect"
+Repository = "https://github.com/PyProtect/PyProtect"
+
+[project.scripts]
+pyprotect = "pyprotect.__main__:main"
+
+[project.optional-dependencies]
+dev = ["pytest>=7.0", "pytest-cov>=4.0"]
+build = ["wheel>=0.27.0", "build>=0.7.0"]
+
+[tool.setuptools.packages.find]
+include = ["pyprotect*"]
+
+

pyprotect_v3-3.0.0/pyprotect/__init__.py

@@ -0,0 +1,16 @@
+"""pyprotect-v3: Python script obfuscation library with C extension acceleration."""
+
+__version__ = "3.0.0"
+__author__ = "pyprotect"
+
+from . import anti_debug, crypto
+
+try:
+    from . import engine_c as _engine
+    HAS_C_EXTENSION = True
+except (ImportError, ModuleNotFoundError):
+    from . import engine as _engine
+    HAS_C_EXTENSION = False
+
+from .obfuscator import Obfuscator
+from .hooks import ProtectedImportHook

pyprotect_v3-3.0.0/pyprotect/__main__.py

@@ -0,0 +1,117 @@
+"""CLI entry point for pyprotect-v3."""
+
+import sys
+import os
+import argparse
+import subprocess
+import shutil
+
+
+def cmd_encrypt(args):
+    from pyprotect.obfuscator import Obfuscator
+    obf = Obfuscator(
+        compress=not args.no_compress,
+        output_dir=args.output_dir,
+    )
+    out_path = obf.encrypt_file(args.input)
+    print(f"[+] Encrypted: {args.input} -> {out_path}")
+    _copy_engine(args.output_dir)
+
+
+def cmd_encrypt_dir(args):
+    from pyprotect.obfuscator import Obfuscator
+    obf = Obfuscator(
+        compress=not args.no_compress,
+        multi=True,
+        output_dir=args.output_dir,
+    )
+    out_files = obf.encrypt_directory(args.input)
+    print(f"[+] Encrypted {len(out_files)} files from {args.input}")
+    for f in out_files:
+        print(f"    -> {f}")
+    _copy_engine(args.output_dir)
+
+
+def cmd_build_engine(args):
+    _do_build_engine()
+
+
+def _do_build_engine():
+    src_dir = os.path.dirname(os.path.abspath(__file__))
+    engine_c = os.path.join(src_dir, "engine.c")
+    if not os.path.exists(engine_c):
+        print("[-] engine.c not found in pyprotect package directory")
+        sys.exit(1)
+    build_dir = os.path.join(src_dir, "..", "build_engine")
+    os.makedirs(build_dir, exist_ok=True)
+    try:
+        subprocess.check_call([
+            sys.executable, "-c", f"""
+import sys
+sys.path.insert(0, {os.path.dirname(src_dir)!r})
+from setuptools import setup, Extension
+import sysconfig
+ext = Extension(
+    'pyprotect.engine_c',
+    sources=[{engine_c!r}],
+    libraries=['crypto', 'z'],
+    extra_compile_args=['-std=c99', '-Wall', '-O2'],
+)
+setup(
+    name='pyprotect-engine',
+    ext_modules=[ext],
+    script_args=['build_ext', '--build-temp={build_dir!r}', '--build-lib={src_dir!r}'],
+)
+""",
+        ])
+        print(f"[+] C extension built successfully")
+    except subprocess.CalledProcessError as e:
+        print(f"[-] Failed to build C extension: {e}")
+        print("[*] Pure Python fallback will be used")
+        sys.exit(1)
+
+
+def _copy_engine(output_dir):
+    if output_dir is None:
+        return
+    os.makedirs(output_dir, exist_ok=True)
+    engine_dir = os.path.dirname(os.path.abspath(__file__))
+    for fname in os.listdir(engine_dir):
+        if fname.startswith("engine_c") and (fname.endswith(".so") or fname.endswith(".pyd") or fname.endswith(".dll")):
+            shutil.copy2(os.path.join(engine_dir, fname), os.path.join(output_dir, fname))
+            print(f"[+] Copied engine: {fname}")
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="pyprotect-v3: Python script obfuscation tool",
+    )
+    sub = parser.add_subparsers(dest="command")
+
+    p_encrypt = sub.add_parser("encrypt", help="Encrypt a single .py file")
+    p_encrypt.add_argument("input", help="Input .py file")
+    p_encrypt.add_argument("-o", "--output-dir", default=None, help="Output directory")
+    p_encrypt.add_argument("--no-compress", action="store_true", help="Skip zlib compression")
+
+    p_encdir = sub.add_parser("encrypt-dir", help="Encrypt all .py files in a directory")
+    p_encdir.add_argument("input", help="Input directory")
+    p_encdir.add_argument("-o", "--output-dir", default=None, help="Output directory")
+    p_encdir.add_argument("--no-compress", action="store_true", help="Skip zlib compression")
+
+    p_build = sub.add_parser("build-engine", help="Build C extension only")
+
+    args = parser.parse_args()
+    if not args.command:
+        parser.print_help()
+        sys.exit(1)
+
+    if args.command == "encrypt":
+        cmd_encrypt(args)
+    elif args.command == "encrypt-dir":
+        cmd_encrypt_dir(args)
+    elif args.command == "build-engine":
+        cmd_build_engine(args)
+
+
+if __name__ == "__main__":
+    main()

pyprotect_v3-3.0.0/pyprotect/_key.py

@@ -0,0 +1,2 @@
+"""Auto-generated. Must match EMBEDDED_KEY in engine.c."""
+EMBEDDED_KEY = b'\xa1\xb2\xc3\xd4\xe5\xf6\x07\x18\x29\x3a\x4b\x5c\x6d\x7e\x8f\x90\x01\x23\x45\x67\x89\xab\xcd\xef\xfe\xdc\xba\x98\x76\x54\x32\x10'