python-obfuscation-framework 1.10.0__tar.gz → 1.11.1__tar.gz

{python_obfuscation_framework-1.10.0/python_obfuscation_framework.egg-info → python_obfuscation_framework-1.11.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-obfuscation-framework
-Version: 1.10.0
+Version: 1.11.1
 Summary: Python Obfuscation Framework
 Author-email: deoktr <35725720+deoktr@users.noreply.github.com>
 Maintainer-email: deoktr <35725720+deoktr@users.noreply.github.com>
@@ -795,20 +795,50 @@ exec(binascii.a2b_hex("".join(['7072696e-7428-2748-656c-6c6f2c20776f','726c6427-
 
 #### ImportsObfuscator
 
-Source: `import pathlib`
+Remove keyword `import`.
 
 ```python
-pathlib=__import__('pathlib')
+# import X
+X = __import__("X")
+
+# import X as Y
+Y = __import__("X")
+
+# import X, Y
+X = __import__("X")
+Y = __import__("Y")
+
+# import X.Y
+X = __import__("X.Y")
+
+# from X import Y
+Y = __import__("X", fromlist=["Y"]).Y
+
+# from X import Y as Z
+Z = __import__("X", fromlist=["Y"]).Y
+
+# from X import Y, Z
+Y = __import__("X", fromlist=["Y"]).Y
+Z = __import__("X", fromlist=["Z"]).Z
 ```
 
+> [!NOTE]
+> Does not support wildcard imports `*`, or local imports `from . import`.
+
 #### CharFromDocObfuscator
 
+Get a single character from a documentation.
+
 Source: `print('h')`
 
 ```python
 print(oct.__doc__[8])
 ```
 
+> [!WARNING]
+> This is highly prone to error, if the documentation change between Python
+> versions, then this may break.
+
 #### AddCommentsObfuscator
 
 ```python
@@ -1372,7 +1402,6 @@ Other Python obfuscation projects:
 
 ## TODO
 
-- Fix `NamesObfuscator`.
 - Add option to prepend a shebang, and add ability to customize it.
 
 ## License

{python_obfuscation_framework-1.10.0 → python_obfuscation_framework-1.11.1}/README.md

@@ -750,20 +750,50 @@ exec(binascii.a2b_hex("".join(['7072696e-7428-2748-656c-6c6f2c20776f','726c6427-
 
 #### ImportsObfuscator
 
-Source: `import pathlib`
+Remove keyword `import`.
 
 ```python
-pathlib=__import__('pathlib')
+# import X
+X = __import__("X")
+
+# import X as Y
+Y = __import__("X")
+
+# import X, Y
+X = __import__("X")
+Y = __import__("Y")
+
+# import X.Y
+X = __import__("X.Y")
+
+# from X import Y
+Y = __import__("X", fromlist=["Y"]).Y
+
+# from X import Y as Z
+Z = __import__("X", fromlist=["Y"]).Y
+
+# from X import Y, Z
+Y = __import__("X", fromlist=["Y"]).Y
+Z = __import__("X", fromlist=["Z"]).Z
 ```
 
+> [!NOTE]
+> Does not support wildcard imports `*`, or local imports `from . import`.
+
 #### CharFromDocObfuscator
 
+Get a single character from a documentation.
+
 Source: `print('h')`
 
 ```python
 print(oct.__doc__[8])
 ```
 
+> [!WARNING]
+> This is highly prone to error, if the documentation change between Python
+> versions, then this may break.
+
 #### AddCommentsObfuscator
 
 ```python
@@ -1327,7 +1357,6 @@ Other Python obfuscation projects:
 
 ## TODO
 
-- Fix `NamesObfuscator`.
 - Add option to prepend a shebang, and add ability to customize it.
 
 ## License

{python_obfuscation_framework-1.10.0 → python_obfuscation_framework-1.11.1}/pof/obfuscator/boolean.py

@@ -44,24 +44,30 @@ class BooleanObfuscator:
                     (RPAR, ")"),
                 ]
             case 3:
-                # not False
+                # (not False)
                 return [
+                    (LPAR, "("),
                     (NAME, "not"),
                     (NAME, "False"),
+                    (RPAR, ")"),
                 ]
             case 4:
-                # not not True
+                # (not not True)
                 return [
+                    (LPAR, "("),
                     (NAME, "not"),
                     (NAME, "not"),
                     (NAME, "True"),
+                    (RPAR, ")"),
                 ]
             case 5:
-                # "" in ""
+                # ("" in "")
                 return [
+                    (LPAR, "("),
                     (STRING, "''"),
                     (NAME, "in"),
                     (STRING, "''"),
+                    (RPAR, ")"),
                 ]
             case 6:
                 # bool(1)
@@ -97,25 +103,31 @@ class BooleanObfuscator:
                     (RPAR, ")"),
                 ]
             case 3:
-                # not True
+                # (not True)
                 return [
+                    (LPAR, "("),
                     (NAME, "not"),
                     (NAME, "True"),
+                    (RPAR, ")"),
                 ]
             case 4:
-                # not not False
+                # (not not False)
                 return [
+                    (LPAR, "("),
                     (NAME, "not"),
                     (NAME, "not"),
                     (NAME, "False"),
+                    (RPAR, ")"),
                 ]
             case 5:
-                # "" not in ""
+                # ("" not in "")
                 return [
+                    (LPAR, "("),
                     (STRING, "''"),
                     (NAME, "not"),
                     (NAME, "in"),
                     (STRING, "''"),
+                    (RPAR, ")"),
                 ]
             case 6:
                 # bool(0)

{python_obfuscation_framework-1.10.0 → python_obfuscation_framework-1.11.1}/pof/obfuscator/esoteric/doc.py

@@ -183,31 +183,31 @@ class CharFromDocObfuscator:
     )
 
     @staticmethod
-    def get_char_indexes(string, char):
+    def _get_char_indexes(string, char):
         return [pos for pos, c in enumerate(string) if c == char]
 
     @classmethod
-    def try_find_doc_index(cls, char):
+    def _try_find_doc_index(cls, char):
         # take a random builtin doc and search for index in it
         builtin = random.choice(cls.BUILTINS)
         doc = __builtins__[builtin].__doc__
         if not doc:
             msg = f"doc for {builtin} is not a string"
             raise PofError(msg)
-        indexes = cls.get_char_indexes(doc, char)
+        indexes = cls._get_char_indexes(doc, char)
         if len(indexes) == 0:
             msg = "char not present"
             raise PofError(msg)
         index = random.choice(indexes)
         return builtin, index
 
-    def obfuscate_char(self, char):
+    def _obfuscate_char(self, char):
         builtin = None
         index = None
         retry = 3
         for _ in range(retry):
             try:
-                builtin, index = self.try_find_doc_index(char)
+                builtin, index = self._try_find_doc_index(char)
             except PofError:
                 pass
             else:
@@ -239,7 +239,7 @@ class CharFromDocObfuscator:
                 string = ast.literal_eval(tokval)
                 if len(string) == 1:
                     try:
-                        new_tokens = self.obfuscate_char(string)
+                        new_tokens = self._obfuscate_char(string)
                     except PofError as e:
                         logger.debug(str(e))
                     except Exception:  # noqa: BLE001

{python_obfuscation_framework-1.10.0 → python_obfuscation_framework-1.11.1}/pof/obfuscator/esoteric/globals.py

@@ -15,7 +15,7 @@
 # along with this program.  If not, see <https://www.gnu.org/licenses/>.
 
 import keyword
-from tokenize import LPAR, NAME, OP, RPAR, STRING
+from tokenize import LPAR, NAME, NEWLINE, NL, OP, RPAR, STRING
 
 
 # TODO (deoktr): add frequency
@@ -42,14 +42,24 @@ class GlobalsObfuscator:
     def obfuscate_tokens(cls, tokens):
         local_functions = []
         prev_tokval = None
-        for toknum, tokval, *_ in tokens:
-            if prev_tokval in ["def", "class"] and toknum == NAME:
+        prev_col = -1
+        for toknum, tokval, *rest in tokens:
+            start = rest[0] if rest else (0, 0)
+            if prev_tokval in ["def", "class"] and toknum == NAME and prev_col == 0:
                 local_functions.append(tokval)
+            if toknum == NAME and tokval in ("def", "class"):
+                prev_col = start[1]
             prev_tokval = tokval
 
-        result = []  # obfuscated tokens
+        result = []
         prev_tokval = None
+        in_import = False
         for index, (toknum, tokval, *_) in enumerate(tokens):
+            if tokval in ("import", "from") and toknum == NAME:
+                in_import = True
+            elif toknum in (NEWLINE, NL):
+                in_import = False
+
             new_tokens = [(toknum, tokval)]
             next_tokval = None
             if len(tokens) > index + 1:
@@ -60,8 +70,10 @@ class GlobalsObfuscator:
                 # ensure it's not a definition
                 and prev_tokval not in ["def", "class", "."]
                 # ensure it's not an argument of a call
-                and next_tokval not in ["="]
+                and next_tokval != "="
                 and tokval not in cls.RESERVED
+                # ensure it's not inside an import statement
+                and not in_import
             ):
                 new_tokens = [
                     (NAME, "globals"),

python_obfuscation_framework-1.11.1/pof/obfuscator/esoteric/imports.py

@@ -0,0 +1,257 @@
+# 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/>.
+
+from tokenize import ENDMARKER, NAME, NEWLINE, NL, OP, STRING
+
+
+class ImportsObfuscator:
+    """Obfuscate import statements using __import__().
+
+    Supported forms:
+
+    ```
+    # import X
+    X = __import__("X")
+
+    # import X as Y
+    Y = __import__("X")
+
+    # import X, Y
+    X = __import__("X")
+    Y = __import__("Y")
+
+    # import X.Y
+    X = __import__("X.Y")
+
+    # from X import Y
+    Y = __import__("X", fromlist=["Y"]).Y
+
+    # from X import Y as Z
+    Z = __import__("X", fromlist=["Y"]).Y
+
+    # from X import Y, Z
+    Y = __import__("X", fromlist=["Y"]).Y
+    Z = __import__("X", fromlist=["Z"]).Z
+    ```
+
+    Left unchanged:
+
+    ```
+    from X import *
+    from . import X
+    ```
+    """
+
+    @staticmethod
+    def _is_statement_start(preceding_tokens: list) -> bool:
+        """Check if the current position is a valid statement start."""
+        if not preceding_tokens:
+            return True
+        for toknum, _ in reversed(preceding_tokens):
+            if toknum in (NEWLINE, NL, ENDMARKER):
+                return True
+            if toknum in (NAME, OP, STRING):
+                return False
+        return True
+
+    @classmethod
+    def _transform_import(cls, stmt_tokens: list) -> list | None:
+        """Transform collected import statement tokens into __import__() calls.
+
+        Returns None if the import should be left unchanged.
+        """
+        body = [
+            (t, v)
+            for t, v in stmt_tokens
+            if t not in (NEWLINE, NL, ENDMARKER) and v not in ("(", ")")
+        ]
+        trailing = [(t, v) for t, v in stmt_tokens if t in (NEWLINE, NL, ENDMARKER)]
+
+        if not body:
+            return None
+
+        first_val = body[0][1]
+
+        if first_val == "import":
+            return cls._transform_simple_import(body[1:]) + trailing
+        if first_val == "from":
+            t = cls._transform_from_import(body[1:])
+            if t is None:
+                return None
+            return t + trailing
+        return None
+
+    @classmethod
+    def _transform_simple_import(cls, tokens: list) -> list:
+        """Transform: import X / import X as Y / import X, Y / import X.Y."""
+        groups = cls._split_by_comma(tokens)
+        result: list = []
+
+        for group in groups:
+            if not group:
+                continue
+            if result:
+                result.append((NEWLINE, "\n"))
+
+            names, alias = cls._extract_alias(group)
+            module_name = cls._join_dotted_name(names)
+            bind_name = alias or names[0][1]
+
+            result.extend(
+                [
+                    (NAME, bind_name),
+                    (OP, "="),
+                    (NAME, "__import__"),
+                    (OP, "("),
+                    (STRING, repr(module_name)),
+                    (OP, ")"),
+                ],
+            )
+
+        return result
+
+    @classmethod
+    def _transform_from_import(cls, tokens: list) -> list | None:
+        """Transform: from X import Y / from X import Y as Z / from X import Y, Z.
+
+        Returns None for relative imports or wildcard imports.
+        """
+        import_idx = None
+        for idx, (_, v) in enumerate(tokens):
+            if v == "import":
+                import_idx = idx
+                break
+
+        if import_idx is None:
+            return None
+
+        module_tokens = tokens[:import_idx]
+        name_tokens = tokens[import_idx + 1 :]
+
+        if any(v == "." for _, v in module_tokens):
+            return None
+
+        if any(v == "*" for _, v in name_tokens):
+            return None
+
+        module_name = cls._join_dotted_name(module_tokens)
+
+        groups = cls._split_by_comma(name_tokens)
+        result: list = []
+
+        for group in groups:
+            if not group:
+                continue
+            if result:
+                result.append((NEWLINE, "\n"))
+
+            names, alias = cls._extract_alias(group)
+            imported_name = names[0][1]
+            bind_name = alias or imported_name
+
+            result.extend(
+                [
+                    (NAME, bind_name),
+                    (OP, "="),
+                    (NAME, "__import__"),
+                    (OP, "("),
+                    (STRING, repr(module_name)),
+                    (OP, ","),
+                    (NAME, "fromlist"),
+                    (OP, "="),
+                    (OP, "["),
+                    (STRING, repr(imported_name)),
+                    (OP, "]"),
+                    (OP, ")"),
+                    (OP, "."),
+                    (NAME, imported_name),
+                ],
+            )
+
+        return result
+
+    @staticmethod
+    def _split_by_comma(tokens: list) -> list[list]:
+        """Split a token list by comma operators."""
+        groups: list[list] = [[]]
+        for toknum, tokval in tokens:
+            if toknum == OP and tokval == ",":
+                groups.append([])
+            else:
+                groups[-1].append((toknum, tokval))
+        return groups
+
+    @staticmethod
+    def _extract_alias(tokens: list) -> tuple[list, str | None]:
+        """Extract name tokens and alias from a token group.
+
+        Returns (name_tokens, alias_string_or_None).
+        """
+        alias = None
+        name_tokens = []
+        saw_as = False
+        for toknum, tokval in tokens:
+            if tokval == "as":
+                saw_as = True
+            elif saw_as:
+                alias = tokval
+                saw_as = False
+            else:
+                name_tokens.append((toknum, tokval))
+        return name_tokens, alias
+
+    @staticmethod
+    def _join_dotted_name(tokens: list) -> str:
+        """Join NAME and OP('.') tokens into a dotted module name string."""
+        return "".join(v for _, v in tokens)
+
+    @classmethod
+    def obfuscate_tokens(cls, tokens: list) -> list:
+        result: list = []
+        i = 0
+        while i < len(tokens):
+            toknum, tokval, *_ = tokens[i]
+
+            if (
+                toknum == NAME
+                and tokval in ("import", "from")
+                and cls._is_statement_start(result)
+            ):
+                stmt_tokens = []
+                j = i
+                paren_depth = 0
+                while j < len(tokens):
+                    st, sv, *_ = tokens[j]
+                    stmt_tokens.append((st, sv))
+                    if sv == "(":
+                        paren_depth += 1
+                    elif sv == ")":
+                        paren_depth -= 1
+                    if st in (NEWLINE, NL, ENDMARKER) and paren_depth <= 0:
+                        break
+                    j += 1
+
+                replacement = cls._transform_import(stmt_tokens)
+                if replacement is not None:
+                    result.extend(replacement)
+                else:
+                    result.extend(stmt_tokens)
+                i = j + 1
+                continue
+
+            result.append((toknum, tokval))
+            i += 1
+        return result

{python_obfuscation_framework-1.10.0 → python_obfuscation_framework-1.11.1}/pof/obfuscator/names.py

@@ -50,6 +50,22 @@ class _ScopeAnalyzer(ast.NodeVisitor):
             self.imported_names.add(alias.asname or alias.name)
         self.generic_visit(node)
 
+    def visit_Assign(self, node: ast.Assign) -> None:
+        """Detect `x = __import__(...)` and treat x as an imported name."""
+        if len(node.targets) == 1 and isinstance(node.targets[0], ast.Name):
+            value = node.value
+            # unwrap attribute chains: x = __import__("m", fromlist=["y"]).y
+            # as they could be generated from the ImportObfuscator
+            while isinstance(value, ast.Attribute):
+                value = value.value
+            if (
+                isinstance(value, ast.Call)
+                and isinstance(value.func, ast.Name)
+                and value.func.id == "__import__"
+            ):
+                self.imported_names.add(node.targets[0].id)
+        self.generic_visit(node)
+
     def visit_ClassDef(self, node: ast.ClassDef) -> None:
         self.class_names.add(node.name)
         prev = self._in_class
@@ -176,14 +192,30 @@ class _StringFixer(ast.NodeTransformer):
             node.args[1] = ast.Constant(value=self.mapping[node.args[1].value])
         return node
 
+    def _is_globals_call(self, node: ast.expr) -> bool:
+        """Check if node is a call to globals()."""
+        return (
+            isinstance(node, ast.Call)
+            and isinstance(node.func, ast.Name)
+            and node.func.id == "globals"
+            and not node.args
+        )
+
     def visit_Subscript(self, node: ast.Subscript) -> ast.Subscript:
         self.generic_visit(node)
         if (
-            isinstance(node.value, ast.Attribute)
-            and node.value.attr == "__dict__"
-            and isinstance(node.slice, ast.Constant)
+            isinstance(node.slice, ast.Constant)
             and isinstance(node.slice.value, str)
             and node.slice.value in self.mapping
+            and (
+                # __dict__['name'] pattern
+                (
+                    isinstance(node.value, ast.Attribute)
+                    and node.value.attr == "__dict__"
+                )
+                # globals()['name'] pattern
+                or self._is_globals_call(node.value)
+            )
         ):
             node.slice = ast.Constant(value=self.mapping[node.slice.value])
         return node
@@ -196,6 +228,7 @@ class NamesObfuscator:
         "__file__",
         "__name__",
         "__doc__",
+        "__builtins__",
         "__package__",
         "__loader__",
         "__spec__",

{python_obfuscation_framework-1.10.0 → python_obfuscation_framework-1.11.1}/pof/obfuscator/remove/print.py

@@ -53,7 +53,7 @@ class PrintObfuscator:
 
             if inside_print:
                 if print_par_depth == parenthesis_depth and (
-                    tokval not in ("(", "print") and prev_tokval != "print"
+                    tokval not in ("(", "print") and prev_tokval not in {"print", "."}
                 ):  # check if still inside print
                     inside_print = False
                 else: