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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-obfuscation-framework
-Version: 1.10.0
+Version: 1.11.0
 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.0}/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.0}/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.0}/pof/obfuscator/esoteric/globals.py

@@ -47,7 +47,7 @@ class GlobalsObfuscator:
                 local_functions.append(tokval)
             prev_tokval = tokval
 
-        result = []  # obfuscated tokens
+        result = []
         prev_tokval = None
         for index, (toknum, tokval, *_) in enumerate(tokens):
             new_tokens = [(toknum, tokval)]
@@ -60,7 +60,7 @@ 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
             ):
                 new_tokens = [

python_obfuscation_framework-1.11.0/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.0}/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

{python_obfuscation_framework-1.10.0 → python_obfuscation_framework-1.11.0}/pof/utils/stegano/ipv6encoding.py

@@ -38,9 +38,8 @@ class IPv6Encoding:
 
         for sc in string_chunks:
             string_chunk = sc
-            if len(string_chunk) < cls.IPV6_LEN:
-                padding = cls.IPV6_LEN - len(string_chunk)
-                # TODO (deoktr): choose this randomly (anything BUT the padding_byte)
+            padding = cls.IPV6_LEN - len(string_chunk)
+            if padding > 0:
                 string_chunk += b"1"
                 string_chunk += cls.padding_byte * (padding - 1)
 
@@ -53,6 +52,11 @@ class IPv6Encoding:
 
             ipv6_list.append(ipv6)
 
+        if len(hex_string) % cls.IPV6_LEN == 0 and len(hex_string) > 0:
+            pad_chunk = (b"1" + cls.padding_byte * (cls.IPV6_LEN - 1)).decode()
+            ipv6_chunks = [pad_chunk[i : i + 4] for i in range(0, len(pad_chunk), 4)]
+            ipv6_list.append(":".join(ipv6_chunks))
+
         return ipv6_list
 
     @classmethod
@@ -78,7 +82,7 @@ class IPv6Encoding:
         """IPv6 decode tokens.
 
         ```
-        binascii.a2b_hex("".join(["...",]).replace(":", "").strip("0")[:-1])
+        binascii.a2b_hex("".join(["...",]).replace(":", "").rstrip("0")[:-1])
         ```.
         """
         return [
@@ -100,7 +104,7 @@ class IPv6Encoding:
             (STRING, repr("")),
             (OP, ")"),
             (OP, "."),
-            (NAME, "strip"),
+            (NAME, "rstrip"),
             (OP, "("),
             (STRING, repr(cls.padding_byte.decode())),
             (OP, ")"),

{python_obfuscation_framework-1.10.0 → python_obfuscation_framework-1.11.0}/pof/utils/stegano/macencoding.py

@@ -37,9 +37,8 @@ class MACEncoding:
 
         for sc in string_chunks:
             string_chunk = sc
-            if len(string_chunk) < cls.MAC_LEN:
-                padding = cls.MAC_LEN - len(string_chunk)
-                # TODO (deoktr): choose this randomly (anything BUT the padding_byte)
+            padding = cls.MAC_LEN - len(string_chunk)
+            if padding > 0:
                 string_chunk += b"1"
                 string_chunk += cls.padding_byte * (padding - 1)
 
@@ -52,6 +51,11 @@ class MACEncoding:
 
             mac_list.append(mac)
 
+        if len(hex_string) % cls.MAC_LEN == 0 and len(hex_string) > 0:
+            pad_chunk = (b"1" + cls.padding_byte * (cls.MAC_LEN - 1)).decode()
+            mac_chunks = [pad_chunk[i : i + 2] for i in range(0, len(pad_chunk), 2)]
+            mac_list.append("-".join(mac_chunks))
+
         return mac_list
 
     @classmethod
@@ -77,7 +81,7 @@ class MACEncoding:
         """MAC encoding decode tokens.
 
         ```
-        binascii.a2b_hex("".join(["...",]).replace("-", "").strip("0")[:-1])
+        binascii.a2b_hex("".join(["...",]).replace("-", "").rstrip("0")[:-1])
         ```.
         """
         return [
@@ -99,7 +103,7 @@ class MACEncoding:
             (STRING, repr("")),
             (OP, ")"),
             (OP, "."),
-            (NAME, "strip"),
+            (NAME, "rstrip"),
             (OP, "("),
             (STRING, repr(cls.padding_byte.decode())),
             (OP, ")"),

{python_obfuscation_framework-1.10.0 → python_obfuscation_framework-1.11.0}/pof/utils/stegano/uuidencoding.py

@@ -40,9 +40,8 @@ class UUIDEncoding:
 
         for string_chunk in string_chunks:
             sc = string_chunk
-            if len(sc) < cls.UUID_LEN:
-                padding = cls.UUID_LEN - len(sc)
-                # TODO (deoktr): choose this randomly (anything BUT the padding_byte)
+            padding = cls.UUID_LEN - len(sc)
+            if padding > 0:
                 sc += b"1"
                 sc += cls.padding_byte * (padding - 1)
 
@@ -58,6 +57,17 @@ class UUIDEncoding:
 
             uuid_list.append(uuid)
 
+        if len(hex_string) % cls.UUID_LEN == 0 and len(hex_string) > 0:
+            pc = (b"1" + cls.padding_byte * (cls.UUID_LEN - 1)).decode()
+            uuid_chunks = [
+                pc[0:8],
+                pc[8:12],
+                pc[12:16],
+                pc[16:20],
+                pc[20:],
+            ]
+            uuid_list.append("-".join(uuid_chunks))
+
         return uuid_list
 
     @classmethod
@@ -83,7 +93,7 @@ class UUIDEncoding:
         """UUID decode tokens.
 
         ```
-        binascii.a2b_hex("".join(["...",]).replace("-", "").strip("0")[:-1])
+        binascii.a2b_hex("".join(["...",]).replace("-", "").rstrip("0")[:-1])
         ```
         """
         return [
@@ -105,7 +115,7 @@ class UUIDEncoding:
             (STRING, '""'),
             (OP, ")"),
             (OP, "."),
-            (NAME, "strip"),
+            (NAME, "rstrip"),
             (OP, "("),
             (STRING, repr(cls.padding_byte.decode())),
             (OP, ")"),

{python_obfuscation_framework-1.10.0 → python_obfuscation_framework-1.11.0}/pyproject.toml

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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-obfuscation-framework
-Version: 1.10.0
+Version: 1.11.0
 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