python-obfuscation-framework 1.9.4__py3-none-any.whl → 1.11.0__py3-none-any.whl

pof/cli_v2.py

@@ -92,9 +92,6 @@ def add_obfuscation(tokens, args):
     if args.obf_constants:
         logger.debug("obfuscating constants")
         tokens = ConstantsObfuscator().obfuscate_tokens(tokens)
-    if args.obf_definitions:
-        logger.debug("obfuscating definitions")
-        tokens = DefinitionsObfuscator().obfuscate_tokens(tokens)
     if args.obf_a85:
         logger.debug("obfuscating a85")
         tokens = ASCII85Obfuscator().obfuscate_tokens(tokens)
@@ -146,9 +143,6 @@ def add_obfuscation(tokens, args):
     if args.obf_names:
         logger.debug("obfuscating names")
         tokens = NamesObfuscator().obfuscate_tokens(tokens)
-    if args.obf_names_rope:
-        logger.debug("obfuscating names_rope")
-        tokens = NamesRopeObfuscator().obfuscate_tokens(tokens)
     if args.obf_numbers:
         logger.debug("obfuscating numbers")
         tokens = NumberObfuscator().obfuscate_tokens(tokens)

pof/main.py

@@ -45,7 +45,6 @@ from pof.obfuscator import (
     BuiltinsObfuscator,
     CommentsObfuscator,
     ConstantsObfuscator,
-    DefinitionsObfuscator,
     DocstringObfuscator,
     ExceptionObfuscator,
     GlobalsObfuscator,
@@ -56,7 +55,6 @@ from pof.obfuscator import (
     NumberObfuscator,
     PrintObfuscator,
     StringsObfuscator,
-    VariablesObfuscator,
     XORObfuscator,
 )
 from pof.stager import ImageStager, RC4Stager
@@ -123,8 +121,6 @@ class Obfuscator(BaseObfuscator):
                 generator=ex_generator,
             ).obfuscate_tokens(tokens)
 
-        tokens = DefinitionsObfuscator().obfuscate_tokens(tokens)
-
         # configure generator
         # generator = alphabet_generator()
         gen_dict = {
@@ -145,42 +141,7 @@ class Obfuscator(BaseObfuscator):
             obf_builtins_rate=0.3,
         ).obfuscate_tokens(tokens)
 
-        # FIXME (deoktr): breaks !
-        # for detailed explanation just consider the following:
-        #   ```
-        #   import module
-        #   class Bar:
-        #       def __init__(self):
-        #           self.foo = getattr(config, "FOO", True)
-        #           module.imported.function(self.foo)
-        #   ```
-        # in this case the first instance of `foo` will successfully be
-        # obfuscated (as it should) but then with the getattr it's marked has
-        # "imported" because it's the result of a builtin function, but notice
-        # that it's not a "simple" variable but rather it's a class attribute
-        # and has a 'self' behind it, so if the variable is marked has imported
-        # and a `.` is placed behind it, it won't be changed, this is the case
-        # in the function call, which is itself imported, and thus set the
-        # imported attribute for itself and all the parameters given to it
-        # this is because we don't keep track of the level of the imported
-        #
-        # FIXME (deoktr): breaks !
-        # Another problem is related to result of function, this is, ofc very
-        # hard to deal with, but if a function returns an object, such has for
-        # example an object of an imported class, which attribute are not
-        # obfuscatable, then it breaks.
-        #   ```
-        #   import foo
-        #   def a():
-        #       return foo.bar()
-        #   x = a()
-        #   x.baz()
-        #   ```
-        # In this context, `baz` would be obfuscated, but it shouldn't because
-        # the function is part of the `foo` imported module
-        # tokens = NamesObfuscator(generator=generator).obfuscate_tokens(tokens)
-        # TODO (deoktr): use alternative variable obfuscator using the AST
-        # tokens = VariablesObfuscator().obfuscate_tokens(tokens)
+        tokens = NamesObfuscator(generator=generator).obfuscate_tokens(tokens)
 
         tokens = GlobalsObfuscator().obfuscate_tokens(tokens)
         tokens = BuiltinsObfuscator().obfuscate_tokens(tokens)
@@ -241,9 +202,7 @@ class Obfuscator(BaseObfuscator):
         tokens = self._get_tokens(source)
         tokens = CommentsObfuscator().obfuscate_tokens(tokens)
         generator = BasicGenerator.alphabet_generator()
-        # tokens = NamesObfuscator(generator=generator).obfuscate_tokens(tokens)
-        tokens = VariablesObfuscator(generator=generator).obfuscate_tokens(tokens)
-        tokens = DefinitionsObfuscator(generator=generator).obfuscate_tokens(tokens)
+        tokens = NamesObfuscator(generator=generator).obfuscate_tokens(tokens)
         tokens = IndentsObfuscator().obfuscate_tokens(tokens)
         tokens = NewlineObfuscator().obfuscate_tokens(tokens)
         return self._untokenize(tokens)
@@ -309,18 +268,7 @@ class Obfuscator(BaseObfuscator):
         tokens = CommentsObfuscator().obfuscate_tokens(tokens)
         tokens = ExceptionObfuscator(generator=generator).obfuscate_tokens(tokens)
         tokens = LoggingObfuscator(generator=generator).obfuscate_tokens(tokens)
-        # FIXME (deoktr): when placed BEFORE NamesObfuscator it breaks the code
-        # tokens = ConstantsObfuscator(
-        #     generator=generator,
-        #     obf_number_rate=1,
-        #     # FIXME (deoktr): breaks if obf_string_rate=1 with NamesObfuscator
-        #     obf_string_rate=0,
-        #     # FIXME (deoktr): breaks if obf_builtins_rate=1 with NamesObfuscator
-        #     obf_builtins_rate=0,
-        # ).obfuscate_tokens(tokens)
-        # tokens = NamesObfuscator(generator=generator).obfuscate_tokens(tokens)
-        tokens = VariablesObfuscator(generator=generator).obfuscate_tokens(tokens)
-        tokens = DefinitionsObfuscator(generator=generator).obfuscate_tokens(tokens)
+        tokens = NamesObfuscator(generator=generator).obfuscate_tokens(tokens)
         tokens = ConstantsObfuscator(
             generator=generator,
             obf_number_rate=1,
@@ -384,10 +332,9 @@ class Obfuscator(BaseObfuscator):
         # tokens = ConstantsObfuscator(generator=generator).obfuscate_tokens(tokens)
 
         tokens = CommentsObfuscator().obfuscate_tokens(tokens)
-        # tokens = DeepEncryptionEvasion().add_evasion(tokens)  # TODO (deoktr): fix
-        # tokens = NamesObfuscator(
-        #     generator=AdvancedGenerator.fixed_length_generator(),
-        # ).obfuscate_tokens(tokens)
+        tokens = NamesObfuscator(
+            generator=AdvancedGenerator.fixed_length_generator(),
+        ).obfuscate_tokens(tokens)
         tokens = BooleanObfuscator().obfuscate_tokens(tokens)
         tokens = IndentsObfuscator().obfuscate_tokens(tokens)
         tokens = NewlineObfuscator().obfuscate_tokens(tokens)

pof/obfuscator/__init__.py

@@ -26,7 +26,6 @@ from .compression.lzma import LzmaObfuscator
 from .compression.zlib import ZlibObfuscator
 from .constants import ConstantsObfuscator
 from .controlflow.control_flow_flatten import ControlFlowFlattenObfuscator
-from .definitions import DefinitionsObfuscator
 from .encoding.a85 import ASCII85Obfuscator
 from .encoding.b16 import Base16Obfuscator
 from .encoding.b32 import Base32Obfuscator
@@ -45,7 +44,6 @@ 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
 from .other.tokens import TokensObfuscator
 from .remove.comments import CommentsObfuscator
@@ -59,7 +57,6 @@ from .stegano.ipv6encoding import IPv6Obfuscator
 from .stegano.macencoding import MACObfuscator
 from .stegano.uuidencoding import UUIDObfuscator
 from .strings import StringsObfuscator
-from .variables import VariablesObfuscator
 
 __all__ = [
     "ASCII85Obfuscator",
@@ -81,7 +78,6 @@ __all__ = [
     "ControlFlowFlattenObfuscator",
     "DeadCodeObfuscator",
     "DeepEncryptionObfuscator",
-    "DefinitionsObfuscator",
     "DocstringObfuscator",
     "ExceptionObfuscator",
     "ExtractVariablesObfuscator",
@@ -95,7 +91,6 @@ __all__ = [
     "LzmaObfuscator",
     "MACObfuscator",
     "NamesObfuscator",
-    "NamesRopeObfuscator",
     "NewlineObfuscator",
     "NumberObfuscator",
     "PrintObfuscator",
@@ -105,7 +100,6 @@ __all__ = [
     "StringsObfuscator",
     "TokensObfuscator",
     "UUIDObfuscator",
-    "VariablesObfuscator",
     "WhitespaceObfuscator",
     "XORObfuscator",
     "ZlibObfuscator",

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

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 = [

pof/obfuscator/esoteric/imports.py

@@ -14,58 +14,244 @@
 # 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 LPAR, NAME, NEWLINE, OP, RPAR, STRING
+from tokenize import ENDMARKER, NAME, NEWLINE, NL, OP, STRING
 
 
 class ImportsObfuscator:
-    """Obfuscate the import statement.
+    """Obfuscate import statements using __import__().
+
+    Supported forms:
 
     ```
-    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
     ```
 
-    Would become:
+    Left unchanged:
+
     ```
-    pathlib = __import__("pathlib")
+    from X import *
+    from . import X
     ```
-
-    Note that this has not been tested very well.
     """
 
+    @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 obfuscate_tokens(cls, tokens):
-        skip_next = False
-        result = []  # obfuscated tokens
-        prev_toknum = None
-        for index, (toknum, tokval, *_) in enumerate(tokens):
-            new_tokens = [(toknum, tokval)]
-            next_tokval = None
-            if len(tokens) > index + 1:
-                _, next_tokval, *__ = tokens[index + 1]
-            next_next_toknum = None
-            if len(tokens) > index + 2:
-                next_next_toknum, _, *__ = tokens[index + 2]
-
-            if not skip_next:
-                if (
-                    tokval == "import"
-                    and prev_toknum in [None, NEWLINE]
-                    and next_next_toknum == NEWLINE
-                ):
-                    new_tokens = [
-                        (NAME, next_tokval),
-                        (OP, "="),
-                        (NAME, "__import__"),
-                        (LPAR, "("),
-                        (STRING, repr(next_tokval)),
-                        (RPAR, ")"),
-                    ]
-                    skip_next = True
+    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:
-                new_tokens = []
-                skip_next = False
+                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
 
-            if new_tokens:
-                result.extend(new_tokens)
-            prev_toknum = toknum
+            result.append((toknum, tokval))
+            i += 1
         return result

pof/obfuscator/junk/dead_code.py

@@ -147,17 +147,37 @@ class DeadCodeObfuscator:
         tokens.append((DEDENT, ""))
         return tokens
 
-    def _generate_dead_if_tokens(self, indent_level: int):
+    @staticmethod
+    def _get_false_cond():
         false_conds = [
             [(NAME, "False")],
             [(NUMBER, "0")],
             [(STRING, '""')],
             [(NAME, "None")],
+            [
+                (NUMBER, str(random.randint(1, 50))),
+                (OP, ">"),
+                (NUMBER, str(random.randint(51, 100))),
+            ],
+            [
+                (NUMBER, str(random.randint(1, 50))),
+                (OP, "=="),
+                (NUMBER, str(random.randint(51, 100))),
+            ],
+            [(NAME, "not"), (NAME, "True")],
+            [(NAME, "True"), (NAME, "and"), (NAME, "False")],
+            [(NUMBER, "0"), (OP, "*"), (NUMBER, str(random.randint(1, 999)))],
+            [(NAME, "len"), (OP, "("), (STRING, '""'), (OP, ")")],
+            [(NAME, "bool"), (OP, "("), (NUMBER, "0"), (OP, ")")],
+            [(OP, "("), (OP, ")"), (NAME, "and"), (NAME, "True")],
         ]
+        return random.choice(false_conds)
+
+    def _generate_dead_if_tokens(self, indent_level: int):
         inner_indent = "    " * (indent_level + 1)
 
         tokens = [(NAME, "if")]
-        tokens.extend(random.choice(false_conds))
+        tokens.extend(self._get_false_cond())
         tokens.extend(
             [
                 (OP, ":"),
@@ -171,7 +191,7 @@ class DeadCodeObfuscator:
         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(self._get_false_cond())
             tokens.extend(
                 [
                     (OP, ":"),
@@ -191,6 +211,10 @@ class DeadCodeObfuscator:
         empty_choices = [
             [(OP, "["), (OP, "]")],
             [(NAME, "range"), (OP, "("), (NUMBER, "0"), (OP, ")")],
+            [(OP, "("), (OP, ")")],
+            [(OP, "{"), (OP, "}")],
+            [(STRING, '""')],
+            [(NAME, "set"), (OP, "("), (OP, ")")],
         ]
 
         tokens = [
@@ -212,13 +236,15 @@ class DeadCodeObfuscator:
 
     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 = [(NAME, "while")]
+        tokens.extend(self._get_false_cond())
+        tokens.extend(
+            [
+                (OP, ":"),
+                (NEWLINE, "\n"),
+                (INDENT, inner_indent),
+            ],
+        )
         tokens.extend(self._body_tokens())
         tokens.append((DEDENT, ""))
         return tokens
@@ -301,7 +327,7 @@ class DeadCodeObfuscator:
 
             if toknum == OP and tokval == "@":
                 in_decorator = True
-            if in_decorator and toknum == NEWLINE:
+            if in_decorator and toknum == NAME and tokval in ("def", "class"):
                 in_decorator = False
 
             result.append((toknum, tokval))