python-obfuscation-framework 1.9.3__tar.gz → 1.9.4__tar.gz

{python_obfuscation_framework-1.9.3/python_obfuscation_framework.egg-info → python_obfuscation_framework-1.9.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-obfuscation-framework
-Version: 1.9.3
+Version: 1.9.4
 Summary: Python Obfuscation Framework
 Author-email: deoktr <35725720+deoktr@users.noreply.github.com>
 Maintainer-email: deoktr <35725720+deoktr@users.noreply.github.com>
@@ -1268,9 +1268,12 @@ interesting strings in Python source code. To check rules against source files
 and/or obfuscated files run:
 
 ```bash
-yara --no-warnings yara/python.yar file.py
+yara --no-warnings yara/python.yar examples/out/custom_complete_format.py
 ```
 
+> [!NOTE]
+> The rules are far from perfect, but they are a starting point.
+
 ## Development
 
 Project directory structure:
@@ -1363,8 +1366,7 @@ Other Python obfuscation projects:
 
 ## TODO
 
-- Add control flow obfuscation, add dead code, opaque predicates, control flow
-  flattening.
+- Add dead code, opaque predicates.
 - Fix `NamesObfuscator`.
 - Add option to prepend a shebang, and add ability to customize it.
 

{python_obfuscation_framework-1.9.3 → python_obfuscation_framework-1.9.4}/README.md

@@ -1223,9 +1223,12 @@ interesting strings in Python source code. To check rules against source files
 and/or obfuscated files run:
 
 ```bash
-yara --no-warnings yara/python.yar file.py
+yara --no-warnings yara/python.yar examples/out/custom_complete_format.py
 ```
 
+> [!NOTE]
+> The rules are far from perfect, but they are a starting point.
+
 ## Development
 
 Project directory structure:
@@ -1318,8 +1321,7 @@ Other Python obfuscation projects:
 
 ## TODO
 
-- Add control flow obfuscation, add dead code, opaque predicates, control flow
-  flattening.
+- Add dead code, opaque predicates.
 - Fix `NamesObfuscator`.
 - Add option to prepend a shebang, and add ability to customize it.
 

{python_obfuscation_framework-1.9.3 → python_obfuscation_framework-1.9.4}/pof/obfuscator/__init__.py

@@ -43,6 +43,7 @@ from .esoteric.imports import ImportsObfuscator
 from .extract_variables import ExtractVariablesObfuscator
 from .junk.add_comments import AddCommentsObfuscator
 from .junk.add_newlines import AddNewlinesObfuscator
+from .junk.dead_code import DeadCodeObfuscator
 from .names import NamesObfuscator
 from .names_rope import NamesRopeObfuscator
 from .numbers import NumberObfuscator
@@ -78,6 +79,7 @@ __all__ = [
     "CommentsObfuscator",
     "ConstantsObfuscator",
     "ControlFlowFlattenObfuscator",
+    "DeadCodeObfuscator",
     "DeepEncryptionObfuscator",
     "DefinitionsObfuscator",
     "DocstringObfuscator",

{python_obfuscation_framework-1.9.3 → python_obfuscation_framework-1.9.4}/pof/obfuscator/controlflow/control_flow_flatten.py

@@ -67,7 +67,7 @@ class ControlFlowFlattenObfuscator:
 
         dispatcher_cases: list[ast.If | None] = []
 
-        for idx, (state_num, stmt) in enumerate(zip(block_states, body)):
+        for idx, (state_num, stmt) in enumerate(zip(block_states, body, strict=True)):
             next_state = block_states[idx + 1] if idx + 1 < num_blocks else exit_state
 
             case_body: list[ast.stmt] = []

python_obfuscation_framework-1.9.4/pof/obfuscator/junk/dead_code.py

@@ -0,0 +1,332 @@
+# POF, a free and open source Python obfuscation framework.
+# Copyright (C) 2022 - 2026  Deoktr
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+import random
+from collections.abc import Generator
+from tokenize import (
+    COMMENT,
+    DEDENT,
+    INDENT,
+    NAME,
+    NEWLINE,
+    NL,
+    NUMBER,
+    OP,
+    STRING,
+)
+
+from pof.utils.generator import BasicGenerator
+
+
+class DeadCodeObfuscator:
+    """Insert dead (unreachable/unused) code blocks into the source."""
+
+    VALID_STATEMENT_TYPES = (
+        "function",
+        "if",
+        "for",
+        "while",
+        "assignment",
+    )
+
+    def __init__(  # noqa: PLR0913
+        self,
+        frequency: float = 0.3,
+        max_function_depth: int = 2,
+        max_branches: int = 3,
+        statement_types: list[str] | None = None,
+        generate_classes: bool = False,  # noqa: FBT001, FBT002
+        generator: Generator[str] | None = None,
+    ) -> None:
+        self.frequency: float = frequency
+        self.max_function_depth: int = max_function_depth
+        self.max_branches: int = max_branches
+        self.generate_classes: bool = generate_classes
+
+        if statement_types is not None:
+            self.statement_types: list[str] = [
+                s for s in statement_types if s in self.VALID_STATEMENT_TYPES
+            ]
+        else:
+            self.statement_types = list(self.VALID_STATEMENT_TYPES)
+
+        if generator is None:
+            generator = BasicGenerator.function_generator()
+        self.generator: Generator[str] = generator
+        self._var_generator: Generator[str] = BasicGenerator.alphabet_generator()
+
+    def _next_name(self) -> str:
+        return next(self.generator)
+
+    def _next_var(self) -> str:
+        return next(self._var_generator)
+
+    @staticmethod
+    def _collect_existing_names(tokens) -> set[str]:
+        names: set[str] = set()
+        for toknum, tokval, *_ in tokens:
+            if toknum == NAME:
+                names.add(tokval)
+        return names
+
+    def _random_expr_tokens(self):
+        choice = random.randint(0, 3)
+        if choice == 0:
+            a, b = random.randint(1, 999), random.randint(1, 999)
+            op = random.choice(["+", "-", "*", "%"])
+            return [(NUMBER, str(a)), (OP, op), (NUMBER, str(b))]
+        if choice == 1:
+            words = ["data", "info", "temp", "cache", "buf", "msg", "tag"]
+            return [(STRING, repr(random.choice(words)))]
+        if choice == 2:  # noqa: PLR2004
+            items = [random.randint(0, 100) for _ in range(random.randint(1, 4))]
+            tokens = [(OP, "[")]
+            for i, item in enumerate(items):
+                if i > 0:
+                    tokens.append((OP, ","))
+                tokens.append((NUMBER, str(item)))
+            tokens.append((OP, "]"))
+            return tokens
+        return [(NUMBER, str(random.randint(0, 9999)))]
+
+    def _body_tokens(self, count: int = 0):
+        """Generate body tokens for a block (assignments)."""
+        if count == 0:
+            count = random.randint(1, 3)
+        tokens = []
+        for _ in range(count):
+            var = self._next_var()
+            tokens.append((NAME, var))
+            tokens.append((OP, "="))
+            tokens.extend(self._random_expr_tokens())
+            tokens.append((NEWLINE, "\n"))
+        return tokens
+
+    def _generate_dead_function_tokens(self, indent_level: int, depth: int):
+        fname = self._next_name()
+        params = [self._next_var() for _ in range(random.randint(0, 3))]
+        inner_indent = "    " * (indent_level + 1)
+
+        tokens = [
+            (NAME, "def"),
+            (NAME, fname),
+            (OP, "("),
+        ]
+        for i, p in enumerate(params):
+            if i > 0:
+                tokens.append((OP, ","))
+            tokens.append((NAME, p))
+        tokens.extend(
+            [
+                (OP, ")"),
+                (OP, ":"),
+                (NEWLINE, "\n"),
+                (INDENT, inner_indent),
+            ],
+        )
+        tokens.extend(self._body_tokens())
+
+        if depth < self.max_function_depth and random.random() < 0.3:  # noqa: PLR2004
+            tokens.extend(
+                self._generate_dead_function_tokens(indent_level + 1, depth + 1),
+            )
+
+        tokens.append((DEDENT, ""))
+        return tokens
+
+    def _generate_dead_if_tokens(self, indent_level: int):
+        false_conds = [
+            [(NAME, "False")],
+            [(NUMBER, "0")],
+            [(STRING, '""')],
+            [(NAME, "None")],
+        ]
+        inner_indent = "    " * (indent_level + 1)
+
+        tokens = [(NAME, "if")]
+        tokens.extend(random.choice(false_conds))
+        tokens.extend(
+            [
+                (OP, ":"),
+                (NEWLINE, "\n"),
+                (INDENT, inner_indent),
+            ],
+        )
+        tokens.extend(self._body_tokens())
+        tokens.append((DEDENT, ""))
+
+        num_elif = random.randint(0, max(0, self.max_branches - 1))
+        for _ in range(num_elif):
+            tokens.append((NAME, "elif"))
+            tokens.extend(random.choice(false_conds))
+            tokens.extend(
+                [
+                    (OP, ":"),
+                    (NEWLINE, "\n"),
+                    (INDENT, inner_indent),
+                ],
+            )
+            tokens.extend(self._body_tokens())
+            tokens.append((DEDENT, ""))
+
+        return tokens
+
+    def _generate_dead_for_tokens(self, indent_level: int):
+        var = self._next_var()
+        inner_indent = "    " * (indent_level + 1)
+
+        empty_choices = [
+            [(OP, "["), (OP, "]")],
+            [(NAME, "range"), (OP, "("), (NUMBER, "0"), (OP, ")")],
+        ]
+
+        tokens = [
+            (NAME, "for"),
+            (NAME, var),
+            (NAME, "in"),
+        ]
+        tokens.extend(random.choice(empty_choices))
+        tokens.extend(
+            [
+                (OP, ":"),
+                (NEWLINE, "\n"),
+                (INDENT, inner_indent),
+            ],
+        )
+        tokens.extend(self._body_tokens())
+        tokens.append((DEDENT, ""))
+        return tokens
+
+    def _generate_dead_while_tokens(self, indent_level: int):
+        inner_indent = "    " * (indent_level + 1)
+        tokens = [
+            (NAME, "while"),
+            (NAME, "False"),
+            (OP, ":"),
+            (NEWLINE, "\n"),
+            (INDENT, inner_indent),
+        ]
+        tokens.extend(self._body_tokens())
+        tokens.append((DEDENT, ""))
+        return tokens
+
+    def _generate_dead_class_tokens(self, indent_level: int):
+        cname = self._next_name().capitalize()
+        inner_indent = "    " * (indent_level + 1)
+        tokens = [
+            (NAME, "class"),
+            (NAME, cname),
+            (OP, ":"),
+            (NEWLINE, "\n"),
+            (INDENT, inner_indent),
+        ]
+        tokens.extend(self._generate_dead_function_tokens(indent_level + 1, 0))
+        tokens.append((DEDENT, ""))
+        return tokens
+
+    def _generate_dead_assignment_tokens(self):
+        var = self._next_var()
+        tokens = [
+            (NAME, var),
+            (OP, "="),
+        ]
+        tokens.extend(self._random_expr_tokens())
+        tokens.append((NEWLINE, "\n"))
+        return tokens
+
+    def _generate_dead_code(self, indent_level: int):
+        """Generate a dead code block and return its tokens."""
+        available = list(self.statement_types)
+        if self.generate_classes:
+            available.append("class")
+
+        if indent_level > 0:
+            weights = []
+            for t in available:
+                if t in ("function", "class"):
+                    weights.append(1)
+                else:
+                    weights.append(3)
+        else:
+            weights = [1] * len(available)
+
+        choice = random.choices(available, weights=weights, k=1)[0]
+
+        match choice:
+            case "function":
+                return self._generate_dead_function_tokens(indent_level, 0)
+            case "if":
+                return self._generate_dead_if_tokens(indent_level)
+            case "for":
+                return self._generate_dead_for_tokens(indent_level)
+            case "while":
+                return self._generate_dead_while_tokens(indent_level)
+            case "class":
+                return self._generate_dead_class_tokens(indent_level)
+            case _:
+                return self._generate_dead_assignment_tokens()
+
+    def obfuscate_tokens(self, tokens):  # noqa: C901
+        existing: set[str] = self._collect_existing_names(tokens)
+        BasicGenerator.extend_reserved(list(existing))
+
+        result = []
+        indent_level: int = 0
+        paren_depth: int = 0
+        in_decorator: bool = False
+
+        for idx, (toknum, tokval, *_) in enumerate(tokens):
+            if toknum == INDENT:
+                indent_level += 1
+            elif toknum == DEDENT:
+                indent_level = max(0, indent_level - 1)
+
+            if toknum == OP and tokval in ("(", "[", "{"):
+                paren_depth += 1
+            elif toknum == OP and tokval in (")", "]", "}"):
+                paren_depth = max(0, paren_depth - 1)
+
+            if toknum == OP and tokval == "@":
+                in_decorator = True
+            if in_decorator and toknum == NEWLINE:
+                in_decorator = False
+
+            result.append((toknum, tokval))
+
+            # insert dead code after NEWLINE tokens
+            # do NOT insert if an INDENT is upcoming (possibly after NL/COMMENT
+            # tokens), that would break the block header (def/if/for/while/
+            # class/try) by placing code between the header's NEWLINE and the
+            # body's INDENT
+            if (
+                toknum == NEWLINE
+                and paren_depth == 0
+                and not in_decorator
+                and random.random() < self.frequency
+            ):
+                has_upcoming_indent = False
+                for j in range(idx + 1, len(tokens)):
+                    upcoming = tokens[j][0]
+                    if upcoming in (NL, COMMENT):
+                        continue
+                    if upcoming == INDENT:
+                        has_upcoming_indent = True
+                    break
+                if not has_upcoming_indent:
+                    dead_tokens = self._generate_dead_code(indent_level)
+                    result.extend(dead_tokens)
+
+        return result

{python_obfuscation_framework-1.9.3 → python_obfuscation_framework-1.9.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "python-obfuscation-framework"
-version = "1.9.3"
+version = "1.9.4"
 description = "Python Obfuscation Framework"
 readme = "README.md"
 requires-python = ">=3.10"

{python_obfuscation_framework-1.9.3 → python_obfuscation_framework-1.9.4/python_obfuscation_framework.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-obfuscation-framework
-Version: 1.9.3
+Version: 1.9.4
 Summary: Python Obfuscation Framework
 Author-email: deoktr <35725720+deoktr@users.noreply.github.com>
 Maintainer-email: deoktr <35725720+deoktr@users.noreply.github.com>
@@ -1268,9 +1268,12 @@ interesting strings in Python source code. To check rules against source files
 and/or obfuscated files run:
 
 ```bash
-yara --no-warnings yara/python.yar file.py
+yara --no-warnings yara/python.yar examples/out/custom_complete_format.py
 ```
 
+> [!NOTE]
+> The rules are far from perfect, but they are a starting point.
+
 ## Development
 
 Project directory structure:
@@ -1363,8 +1366,7 @@ Other Python obfuscation projects:
 
 ## TODO
 
-- Add control flow obfuscation, add dead code, opaque predicates, control flow
-  flattening.
+- Add dead code, opaque predicates.
 - Fix `NamesObfuscator`.
 - Add option to prepend a shebang, and add ability to customize it.
 

{python_obfuscation_framework-1.9.3 → python_obfuscation_framework-1.9.4}/python_obfuscation_framework.egg-info/SOURCES.txt

@@ -90,6 +90,7 @@ pof/obfuscator/esoteric/imports.py
 pof/obfuscator/junk/__init__.py
 pof/obfuscator/junk/add_comments.py
 pof/obfuscator/junk/add_newlines.py
+pof/obfuscator/junk/dead_code.py
 pof/obfuscator/other/__init__.py
 pof/obfuscator/other/tokens.py
 pof/obfuscator/remove/__init__.py

{python_obfuscation_framework-1.9.3 → python_obfuscation_framework-1.9.4}/tests/obfuscator/conftest.py

@@ -32,6 +32,7 @@ from pof.obfuscator import (
     CommentsObfuscator,
     ConstantsObfuscator,
     ControlFlowFlattenObfuscator,
+    DeadCodeObfuscator,
     DeepEncryptionObfuscator,
     DefinitionsObfuscator,
     DocstringObfuscator,
@@ -191,6 +192,7 @@ OBFUSCATOR_REGISTRY: list[ObfuscatorEntry] = [
     # Junk / behavior-altering
     ObfuscatorEntry(AddCommentsObfuscator, "AddCommentsObfuscator", "junk"),
     ObfuscatorEntry(AddNewlinesObfuscator, "AddNewlinesObfuscator", "junk"),
+    ObfuscatorEntry(DeadCodeObfuscator, "DeadCodeObfuscator", "junk"),
     # name/variable obfuscators
     ObfuscatorEntry(ConstantsObfuscator, "ConstantsObfuscator", "other"),
     ObfuscatorEntry(

{python_obfuscation_framework-1.9.3 → python_obfuscation_framework-1.9.4}/tests/obfuscator/fixtures/multiline_strings.py

@@ -1,30 +1,22 @@
 # Language features: implicit string concatenation (multi-line and single-line)
-
-
-# Multi-line implicit concatenation (parenthesized)
 a = ("hello"
 "world")
 print(a)
 
-# In function call across lines
 print(("foo"
 "bar"))
 
-# Three strings across lines
 b = ("one"
 "two"
 "three")
 print(b)
 
-# Mixed quote styles
 c = ('hello'
 "world")
 print(c)
 
-# Single-line implicit concatenation
 d = "hello" "world"
 print(d)
 
-# Three strings on one line
 e = "a" "b" "c"
 print(e)