pylockware 2.2.0__tar.gz → 2.3.0__tar.gz

{pylockware-2.2.0 → pylockware-2.3.0}/PKG-INFO

@@ -1,8 +1,8 @@
 Metadata-Version: 2.4
 Name: pylockware
-Version: 2.2.0
+Version: 2.3.0
 Summary: Python Code Protection SDK with obfuscation and anti-debug features
-Home-page: https://github.com/yourusername/pylockware
+Home-page: https://github.com/amogusgggy/pylockware
 Author: PyLockWare Team
 License: AGPL-3.0-or-later
 Project-URL: Homepage, https://github.com/amogus-gggy/pylockware
@@ -62,12 +62,30 @@ Dynamic: requires-python
 [![Python Version](https://img.shields.io/badge/python-3.8+-blue.svg)](https://www.python.org/downloads/)
 [![License](https://img.shields.io/badge/license-MIT-green.svg)](LICENSE)
 
-## Changelog v2.2.0
-- stability improvements
--  bug fixes
--  improvements in crypt, call_obf modules.
--   Added builtin antitamper(has some bugs, dont use it please)
-
+## Changelog v2.3.0
+**Added**
+- `--expr-virtualize` — compiles expressions to custom VM bytecode with XOR-encrypted dispatch table
+- Anti-dump string poisoning — 500 random garbage strings injected into junk code to pollute static analysis
+- Poison variable chains — self-referential dead variables that raise `NameError` if stripped by deobfuscators
+- Deeply nested dead code — fake `if` chains, `try/except`, `with` blocks for maximum visual noise
+- `l-i` name generator — visually ambiguous identifiers (`I`/`l`/`i`/`L`)
+- Per-module embedded builtin dispatcher — no external files, each module carries its own obfuscated dispatcher
+
+**Changed**
+- Builtin dispatcher: scope-aware shadowing detection, no longer renames locally overridden builtins
+- String protection: inline decode calls instead of global variables per string
+- Number obfuscation: auto-injects `os`/`sys` imports when needed(bug fix)
+- Remap: skips imported module attributes (fixes `datetime.datetime.hour`-style breaks)
+- Call obfuscation: full frame stack walk for `_call`/`_resolve`
+- Default name length: 32 → 128 chars; junk density: 0.5 → 0.8
+
+**Fixed**
+- `ExprVirtualizeModule` now runs after all AST transforms
+- String protection no longer leaks undeclared globals
+- Removed stale `_builtin_dispatcher.py` references
+
+**Removed**
+- Central `_builtin_dispatcher.py` — fully inlined
 
 ## 🚀 Features
 

{pylockware-2.2.0 → pylockware-2.3.0}/README.md

@@ -5,12 +5,30 @@
 [![Python Version](https://img.shields.io/badge/python-3.8+-blue.svg)](https://www.python.org/downloads/)
 [![License](https://img.shields.io/badge/license-MIT-green.svg)](LICENSE)
 
-## Changelog v2.2.0
-- stability improvements
--  bug fixes
--  improvements in crypt, call_obf modules.
--   Added builtin antitamper(has some bugs, dont use it please)
-
+## Changelog v2.3.0
+**Added**
+- `--expr-virtualize` — compiles expressions to custom VM bytecode with XOR-encrypted dispatch table
+- Anti-dump string poisoning — 500 random garbage strings injected into junk code to pollute static analysis
+- Poison variable chains — self-referential dead variables that raise `NameError` if stripped by deobfuscators
+- Deeply nested dead code — fake `if` chains, `try/except`, `with` blocks for maximum visual noise
+- `l-i` name generator — visually ambiguous identifiers (`I`/`l`/`i`/`L`)
+- Per-module embedded builtin dispatcher — no external files, each module carries its own obfuscated dispatcher
+
+**Changed**
+- Builtin dispatcher: scope-aware shadowing detection, no longer renames locally overridden builtins
+- String protection: inline decode calls instead of global variables per string
+- Number obfuscation: auto-injects `os`/`sys` imports when needed(bug fix)
+- Remap: skips imported module attributes (fixes `datetime.datetime.hour`-style breaks)
+- Call obfuscation: full frame stack walk for `_call`/`_resolve`
+- Default name length: 32 → 128 chars; junk density: 0.5 → 0.8
+
+**Fixed**
+- `ExprVirtualizeModule` now runs after all AST transforms
+- String protection no longer leaks undeclared globals
+- Removed stale `_builtin_dispatcher.py` references
+
+**Removed**
+- Central `_builtin_dispatcher.py` — fully inlined
 
 ## 🚀 Features
 

{pylockware-2.2.0 → pylockware-2.3.0}/pylockware/cli/main.py

@@ -38,6 +38,7 @@ def main_cli():
     parser.add_argument("--decorator-obf", action="store_true", help="Enable decorator obfuscation (converts @decorator to func = decorator(func))")
     parser.add_argument("--call-obf", action="store_true", help="Enable chained-table call obfuscation (_call/_resolve)")
     parser.add_argument("--crypt", action="store_true", help="Enable function encryption using machine fingerprinting and XOR encryption")
+    parser.add_argument("--expr-virtualize", action="store_true", help="Enable expression virtualization (compiles expressions to custom bytecode)")
     parser.add_argument("--anti-tamper-builtins", action=argparse.BooleanOptionalAction, default=True,
                         help="Enable runtime anti-tamper guard that crashes on patched Python builtins (default: enabled)")
     parser.add_argument("--all", action="store_true", help="Enable all obfuscation options (except Nuitka)")
@@ -66,6 +67,8 @@ def main_cli():
         print("       Please use only one of these options at a time.")
         sys.exit(1)
 
+
+
     # If --all is specified, enable all obfuscation options (except Nuitka)
     if args.all:
         args.remap = False
@@ -78,6 +81,7 @@ def main_cli():
         args.disable_traceback = True
         args.decorator_obf = True
         args.call_obf = False
+        args.expr_virtualize = True
 
     # Determine anti_debug mode
     anti_debug_value = None
@@ -113,6 +117,7 @@ def main_cli():
         call_obf=args.call_obf,
         crypt=args.crypt,
         anti_tamper_builtins=args.anti_tamper_builtins,
+        expr_virtualize=args.expr_virtualize,
         enable_nuitka=args.nuitka,
         nuitka_onefile=args.nuitka_onefile,
         nuitka_standalone=args.nuitka_standalone,

{pylockware-2.2.0 → pylockware-2.3.0}/pylockware/core/name_generator.py

@@ -20,7 +20,8 @@ class NameGenerator:
             'mixed': string.ascii_letters + string.digits + ''.join(chr(i) for i in range(0x4E00, 0x9FFF)),
             'numbers': string.digits,
             'hex': string.hexdigits,
-            'ascii': string.printable.strip()  # All printable ASCII except whitespace
+            'ascii': string.printable.strip(), # All printable ASCII except whitespace
+            'l-i': "IliL"
         }
         
         self.char_set = self.char_sets.get(char_set, self.char_sets['english'])
@@ -36,7 +37,7 @@ class NameGenerator:
         Returns:
             Randomly generated name
         """
-        length = 32  # Default length
+        length = 128  # Default length
         
         # If prefix is empty or doesn't start with letter/underscore, add underscore
         if not prefix or (prefix[0] not in string.ascii_letters + '_'):

{pylockware-2.2.0 → pylockware-2.3.0}/pylockware/core/obfuscator.py

@@ -28,6 +28,7 @@ from pylockware.modules.call_obf_module import CallObfModule
 from pylockware.modules.remove_annotations_module import RemoveAnnotationsModule
 from pylockware.modules.crypt_module import CryptModule
 from pylockware.modules.anti_tamper_builtins_module import AntiTamperBuiltinsModule
+from pylockware.modules.expr_virtualize_module import ExprVirtualizeModule
 
 
 class PyObfuscator:
@@ -48,7 +49,8 @@ class PyObfuscator:
                  nuitka_admin: bool = False, nuitka_plugins: List[str] = None, nuitka_extra_imports: List[str] = None,
                  nuitka_options: List[str] = None, disable_traceback: bool = False,
                  decorator_obf: bool = False, type_annotation_obf: bool = False, call_obf: bool = False,
-                 crypt: bool = False, anti_tamper_builtins: bool = True):
+                 crypt: bool = False, anti_tamper_builtins: bool = True,
+                 expr_virtualize: bool = False):
         self.project_path = Path(project_path)
         self.entry_point = Path(entry_point)
         self.entry_function = entry_function
@@ -71,6 +73,7 @@ class PyObfuscator:
         self.call_obf = call_obf  # Enable call obfuscation using getattr pattern
         self.crypt = crypt  # Enable function encryption using machine fingerprinting
         self.anti_tamper_builtins = anti_tamper_builtins  # Enable runtime anti-tamper guard for builtins
+        self.expr_virtualize = expr_virtualize  # Enable expression virtualization
 
         # Nuitka options
         self.enable_nuitka = enable_nuitka
@@ -90,7 +93,6 @@ class PyObfuscator:
 
         # Validate and adjust incompatible options
         self._validate_nuitka_compatibility()
-
         self.setup_modules()
 
     def _validate_nuitka_compatibility(self):
@@ -107,7 +109,7 @@ class PyObfuscator:
         if self.enable_nuitka:
             if self.anti_debug:
                 self.anti_debug = None
-            
+
             if self.import_obf:
                 self.import_obf = False
 
@@ -160,10 +162,7 @@ class PyObfuscator:
             call_obf_config = {'name_gen': self.name_gen}
             self.module_manager.add_module(CallObfModule(call_obf_config))
 
-        # Add modules based on configuration
-        if self.string_prot:
-            string_prot_config = {'name_gen': self.name_gen}
-            self.module_manager.add_module(StringProtectModule(string_prot_config))
+
 
         if self.anti_debug:
             anti_debug_config = {
@@ -200,6 +199,10 @@ class PyObfuscator:
             num_obf_config = {'name_gen': self.name_gen}
             self.module_manager.add_module(NumberObfModule(num_obf_config))
 
+        # Add modules based on configuration
+        if self.string_prot:
+            string_prot_config = {'name_gen': self.name_gen}
+            self.module_manager.add_module(StringProtectModule(string_prot_config))
         # Decorator obfuscation - converts @decorator to explicit assignments
         # Module disabled due to conflict with annotations
         # if self.decorator_obf:
@@ -223,6 +226,10 @@ class PyObfuscator:
         
         # Add RemoveAnnotations module to clean up decorators
         self.module_manager.add_module(RemoveAnnotationsModule({}))
+
+        # ExprVirtualize runs AFTER all AST transforms so its output isn't corrupted
+        if self.expr_virtualize:
+            self.module_manager.add_module(ExprVirtualizeModule({}))
         
         # Add crypt module if enabled - runs after all other obfuscation
         if self.crypt:
@@ -288,7 +295,6 @@ class PyObfuscator:
             import python_minifier
             
             obfuscator_files = [
-                "_builtin_dispatcher.py",
                 "anti_tamper_builtins.py",
                 "antidebug_crossplatform.py",
                 "antidebug_llvm.py",

{pylockware-2.2.0 → pylockware-2.3.0}/pylockware/modules/__init__.py

@@ -9,6 +9,7 @@ from .anti_debug_module import AntiDebugModule
 from .import_obf_module import ImportObfuscateModule
 from .state_machine_module import StateMachineModule
 from .crypt_module import CryptModule
+from .expr_virtualize_module import ExprVirtualizeModule
 
 __all__ = [
     'RemapModule',
@@ -18,4 +19,5 @@ __all__ = [
     'ImportObfuscateModule',
     'StateMachineModule',
     'CryptModule',
+    'ExprVirtualizeModule',
 ]

{pylockware-2.2.0 → pylockware-2.3.0}/pylockware/modules/anti_tamper_builtins_module.py

@@ -9,7 +9,6 @@ _GUARD_MARKER = "# __pylockware_anti_tamper_builtins__"
 _MODULE_NAME = "anti_tamper_builtins"
 _SKIP_FILES = {
     f"{_MODULE_NAME}.py",
-    "_builtin_dispatcher.py",
     "antidebug_crossplatform.py",
     "antidebug_llvm.py",
 }

pylockware-2.3.0/pylockware/modules/builtin_dispatcher_module.py

@@ -0,0 +1,98 @@
+"""
+Builtin Dispatcher Module for PyLockWare
+Replaces all built-in function calls with calls via a dispatcher
+Встраивает dispatcher прямо в каждый модуль — без внешних файлов
+"""
+import ast
+from pathlib import Path
+from typing import Dict, Any
+from pylockware.core.module_base import ModuleBase
+from pylockware.transforms.builtin_dispatcher import BuiltinDispatcherTransformer, BUILTIN_FUNCTIONS
+
+
+class BuiltinDispatcherModule(ModuleBase):
+    """
+    Module that replaces built-in function calls with dispatcher calls
+    e.g., print() -> _dispatcher.ghjfkd()
+    Dispatcher code is embedded directly into each module - no external files needed
+    """
+
+    def __init__(self, config: Dict[str, Any] = None):
+        super().__init__(config)
+        self.name_gen_settings = self.config.get('name_gen', 'english')
+
+    def process(self, project_path: Path, output_path: Path) -> bool:
+        """
+        Process the project by replacing built-in calls with dispatcher calls
+        Dispatcher code is embedded directly into each module
+
+        Args:
+            project_path: Path to the original project
+            output_path: Path to the output directory
+
+        Returns:
+            True if processing was successful, False otherwise
+        """
+        try:
+            print("Applying builtin dispatcher obfuscation...")
+
+            # Find all Python files in the output directory
+            py_files = list(output_path.rglob("*.py"))
+
+            # Files that should NOT be transformed (they contain critical runtime checks)
+            protected_files = {
+                "antidebug_llvm.py",
+                "antidebug_crossplatform.py",
+                "anti_tamper_builtins.py",
+            }
+
+            files_modified = 0
+
+            for py_file in py_files:
+                if py_file.name in protected_files:
+                    continue
+                try:
+                    with open(py_file, 'r', encoding='utf-8') as f:
+                        original_code = f.read()
+
+                    tree = ast.parse(original_code)
+
+                    # Create a fresh transformer for each file (unique obfuscated names)
+                    transformer = BuiltinDispatcherTransformer(name_gen_settings=self.name_gen_settings)
+
+                    # Use transform_module which embeds dispatcher directly
+                    transformed_tree = transformer.transform_module(tree)
+
+                    # Only write if changes were made
+                    if transformer.builtins_map:
+                        new_content = ast.unparse(transformed_tree)
+
+                        with open(py_file, 'w', encoding='utf-8') as f:
+                            f.write(new_content)
+                        files_modified += 1
+                        print(f"  Obfuscated builtins in {py_file}")
+
+                except Exception as e:
+                    print(f"Error processing {py_file}: {e}")
+                    continue
+
+            if files_modified == 0:
+                print("No built-in functions found, skipping builtin dispatcher obfuscation.")
+            else:
+                print(f"Builtin dispatcher obfuscation complete. Modified {files_modified} files.")
+            return True
+
+        except Exception as e:
+            print(f"Error during builtin dispatcher obfuscation: {e}")
+            import traceback
+            traceback.print_exc()
+            return False
+
+    def validate_config(self) -> bool:
+        """
+        Validate the module's configuration
+
+        Returns:
+            True if configuration is valid, False otherwise
+        """
+        return True

pylockware-2.3.0/pylockware/modules/expr_virtualize_module.py

@@ -0,0 +1,57 @@
+"""
+Expression Virtualization Module for PyLockWare
+Replaces expressions with VM-interpreted bytecode
+"""
+import ast
+from pathlib import Path
+from typing import Dict, Any
+from pylockware.core.module_base import ModuleBase
+from pylockware.transforms.expr_virtualize import virtualize_code, VM_RUNTIME_CODE
+
+
+class ExprVirtualizeModule(ModuleBase):
+    """
+    Module that virtualizes expressions by compiling them to custom bytecode
+    and replacing them with calls to a VM interpreter
+    """
+
+    def __init__(self, config: Dict[str, Any] = None):
+        super().__init__(config)
+
+    def process(self, project_path: Path, output_path: Path) -> bool:
+        try:
+            print("Applying expression virtualization to all Python files...")
+
+            runtime_file = output_path / "_vmentry_rt.py"
+            runtime_file.write_text(VM_RUNTIME_CODE, encoding='utf-8')
+
+            for py_file in output_path.rglob("*.py"):
+                if py_file.name in ["anti_debug_injector.py", "anti_debug_injector_normal.py",
+                                    "obfuscator.py", "num_obf.py", "antidebug_llvm.py",
+                                    "_vmentry_rt.py"]:
+                    continue
+                try:
+                    with open(py_file, 'r', encoding='utf-8') as f:
+                        original_code = f.read()
+
+                    if '_vmentry' in original_code:
+                        continue
+
+                    virtualized_code = virtualize_code(original_code)
+
+                    if virtualized_code != original_code:
+                        final_code = "from _vmentry_rt import _vmentry\n" + virtualized_code
+                        with open(py_file, 'w', encoding='utf-8') as f:
+                            f.write(final_code)
+                        print(f"Virtualized expressions in {py_file}")
+
+                except Exception as e:
+                    print(f"Error applying expression virtualization to {py_file}: {e}")
+
+            return True
+        except Exception as e:
+            print(f"Error during expression virtualization: {e}")
+            return False
+
+    def validate_config(self) -> bool:
+        return True

{pylockware-2.2.0 → pylockware-2.3.0}/pylockware/sdk/builder.py

@@ -148,6 +148,7 @@ class Builder:
             call_obf=self.config.call_obf,
             crypt=self.config.crypt,
             anti_tamper_builtins=self.config.anti_tamper_builtins,
+            expr_virtualize=self.config.expr_virtualize,
             enable_nuitka=self.config.enable_nuitka,
             nuitka_onefile=self.config.nuitka_onefile,
             nuitka_standalone=self.config.nuitka_standalone,

{pylockware-2.2.0 → pylockware-2.3.0}/pylockware/sdk/config.py

@@ -33,6 +33,7 @@ class BuildConfig:
     crypt: bool = False
     disable_traceback: bool = True
     anti_tamper_builtins: bool = True
+    expr_virtualize: bool = False
     
     # Параметры обфускации
     junk_density: float = 0.5
@@ -179,6 +180,7 @@ def _save_pretty_toml(data: dict, path: Path, config: BuildConfig) -> None:
     lines.append(f"crypt = {str(config.crypt).lower()}")
     lines.append(f"disable_traceback = {str(config.disable_traceback).lower()}")
     lines.append(f"anti_tamper_builtins = {str(config.anti_tamper_builtins).lower()}")
+    lines.append(f"expr_virtualize = {str(config.expr_virtualize).lower()}")
     lines.append(f"anti_debug = {str(bool(config.anti_debug)).lower()}")
     lines.append("")
 

{pylockware-2.2.0 → pylockware-2.3.0}/pylockware/transforms/__init__.py

@@ -14,6 +14,7 @@ from .crypter import (
     derive_key,
     generate_seed,
 )
+from .expr_virtualize import virtualize_code, VM_RUNTIME_CODE
 
 __all__ = [
     'NumberObfuscator',
@@ -27,4 +28,6 @@ __all__ = [
     'xor_encrypt',
     'derive_key',
     'generate_seed',
+    'virtualize_code',
+    'VM_RUNTIME_CODE',
 ]