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

{python_obfuscation_framework-1.11.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.11.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>

{python_obfuscation_framework-1.11.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.11.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 = []
         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:
@@ -62,6 +72,8 @@ class GlobalsObfuscator:
                 # ensure it's not an argument of a call
                 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.0 → python_obfuscation_framework-1.11.1}/pof/obfuscator/names.py

@@ -192,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
@@ -212,6 +228,7 @@ class NamesObfuscator:
         "__file__",
         "__name__",
         "__doc__",
+        "__builtins__",
         "__package__",
         "__loader__",
         "__spec__",

{python_obfuscation_framework-1.11.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:

{python_obfuscation_framework-1.11.0 → python_obfuscation_framework-1.11.1}/pof/obfuscator/strings.py

@@ -84,15 +84,26 @@ class StringsObfuscator:
             shift_cipher_class_obj = ShiftCipher()
         self.shift_cipher_class_obj = shift_cipher_class_obj
 
-    def obf_shift(self, tokval: str):
+    @staticmethod
+    def _is_bytes_literal(tokval: str) -> bool:
+        """Check if a string token represents a bytes literal (b'...' or B'...')."""
+        prefix = tokval.split("'", maxsplit=1)[0].split('"')[0]
+        return "b" in prefix or "B" in prefix
+
+    def _obf_shift(self, tokval: str):
         # TODO (deoktr): choose random padding here
         raw_string = eval(tokval)  # noqa: S307
         if isinstance(raw_string, bytes):
-            raw_string = raw_string.decode()
+            try:
+                raw_string = raw_string.decode()
+            except UnicodeDecodeError:
+                return [(STRING, tokval)]
+        if not raw_string.isascii():
+            return [(STRING, tokval)]
         encoded = self.shift_cipher_class_obj.encode_tokens(raw_string)
         return self.shift_cipher_class_obj.decode_tokens(encoded)
 
-    def obf_base64(self, tokval: str):
+    def _obf_base64(self, tokval: str):
         """Obfuscate string with base64.
 
         ```
@@ -100,21 +111,28 @@ class StringsObfuscator:
         ```
         """
         raw_string = eval(tokval)  # noqa: S307
+        is_bytes = isinstance(raw_string, bytes)
         if isinstance(raw_string, str):
             raw_string = raw_string.encode()
         b64encoded_string = b64encode(raw_string).decode()
-        return [
+        tokens = [
             (NAME, self.b64decode_name),
             (LPAR, "("),
             (STRING, repr(b64encoded_string)),
             (RPAR, ")"),
-            (OP, "."),
-            (NAME, "decode"),
-            (LPAR, "("),
-            (RPAR, ")"),
         ]
+        if not is_bytes:
+            tokens.extend(
+                [
+                    (OP, "."),
+                    (NAME, "decode"),
+                    (LPAR, "("),
+                    (RPAR, ")"),
+                ],
+            )
+        return tokens
 
-    def obf_base85(self, tokval: str):
+    def _obf_base85(self, tokval: str):
         """Obfuscate string with base85.
 
         ```
@@ -122,38 +140,56 @@ class StringsObfuscator:
         ```
         """
         raw_string = eval(tokval)  # noqa: S307
+        is_bytes = isinstance(raw_string, bytes)
         if isinstance(raw_string, str):
             raw_string = raw_string.encode()
         b85encoded_string = b85encode(raw_string).decode()
-        return [
+        tokens = [
             (NAME, self.b85decode_name),
             (LPAR, "("),
             (STRING, repr(b85encoded_string)),
             (RPAR, ")"),
-            (OP, "."),
-            (NAME, "decode"),
-            (LPAR, "("),
-            (RPAR, ")"),
         ]
+        if not is_bytes:
+            tokens.extend(
+                [
+                    (OP, "."),
+                    (NAME, "decode"),
+                    (LPAR, "("),
+                    (RPAR, ")"),
+                ],
+            )
+        return tokens
 
     @staticmethod
-    def hex(tokval: str):
+    def _hex(tokval: str):
         # Hello --> \x48\x65\x6c\x6c\x6f
         raw_string = eval(tokval)  # noqa: S307
         if isinstance(raw_string, bytes):
-            raw_string = raw_string.decode()
+            encoded = "".join(f"\\x{b:02x}" for b in raw_string)
+            return [(STRING, f"b'{encoded}'")]
         encoded = ""
         for c in raw_string:
-            hexcode = f"\\x{hex(ord(c))[2:]:0>2}" if not c.isdigit() else c  # noqa: FURB116
-            encoded += hexcode
+            code = ord(c)
+            if c.isdigit():
+                encoded += c
+            elif code <= 0xFF:  # noqa: PLR2004
+                encoded += f"\\x{code:02x}"
+            elif code <= 0xFFFF:  # noqa: PLR2004
+                encoded += f"\\u{code:04x}"
+            else:
+                encoded += f"\\U{code:08x}"
         return [(STRING, f"'{encoded}'")]
 
     @staticmethod
-    def unicode(tokval: str):
+    def _unicode(tokval: str):
         # Hell --> \u0048\u0065\u006C\u006C
         raw_string = eval(tokval)  # noqa: S307
         if isinstance(raw_string, bytes):
-            raw_string = raw_string.decode()
+            try:
+                raw_string = raw_string.decode()
+            except UnicodeDecodeError:
+                return [(STRING, tokval)]
         encoded = ""
         for c in raw_string:
             ucode = f"\\u{hex(ord(c))[2:]:0>4}" if not c.isdigit() else c  # noqa: FURB116
@@ -161,8 +197,11 @@ class StringsObfuscator:
         return [(STRING, f"'{encoded}'")]
 
     @staticmethod
-    def additions(tokval: str):
+    def _additions(tokval: str):
         # "Hello, world!" --> "Hello, "+"world!"
+        if len(tokval) < 6:  # noqa: PLR2004
+            return [(STRING, tokval)]
+
         raw_string = False
         if tokval.startswith("r"):
             tokval = tokval[1:]
@@ -183,8 +222,11 @@ class StringsObfuscator:
         ]
 
     @staticmethod
-    def only_additions(tokval: str):
+    def _only_additions(tokval: str):
         # "Hello, world!" --> "Hello, "+"world!"
+        if len(tokval) <= 2:  # noqa: PLR2004
+            return [(STRING, tokval)]
+
         raw_string = False
         if tokval.startswith("r"):
             tokval = tokval[1:]
@@ -215,14 +257,17 @@ class StringsObfuscator:
                 add_slash = False
             else:
                 add_slash = True
-        t.pop()  # remove last +
+        if t:
+            t.pop()  # remove last +
+        else:
+            return [(STRING, tokval)]
         return t
 
     @staticmethod
-    def string_replace(tokval: str):
+    def _string_replace(tokval: str):
         raw_string = eval(tokval)  # noqa: S307
 
-        if not raw_string or isinstance(raw_string, str):
+        if not raw_string or isinstance(raw_string, (str, bytes)):
             return [(STRING, tokval)]
 
         i = random.randint(0, len(raw_string) - 1)
@@ -255,7 +300,7 @@ class StringsObfuscator:
         ]
 
     @staticmethod
-    def string_reverse(tokval: str):
+    def _string_reverse(tokval: str):
         raw_string = eval(tokval)  # noqa: S307
         reversed_string = raw_string[::-1]
         return [
@@ -268,20 +313,19 @@ class StringsObfuscator:
         ]
 
     @staticmethod
-    def string_one_on_n(tokval: str):
+    def _string_one_on_n(tokval: str):
         """One on N.
 
         "".join([l if x%2 ==0 else "" for x, l in
             enumerate("Heeeleleoe,e eweoerelede!e")])
         """
         raw_string = eval(tokval)  # noqa: S307
-        if not raw_string:
+        if not raw_string or isinstance(raw_string, bytes):
             return [(STRING, tokval)]
 
         # steps between each actual characters
         steps = random.randint(1, 7)
 
-        obf_string = raw_string
         obf_string = ""
         for char in raw_string:
             t = "".join(
@@ -323,55 +367,52 @@ class StringsObfuscator:
             (OP, ")"),
         ]
 
-    def obfuscate_string(self, tokval: str, next_tokval: str):  # noqa: C901
+    def _obfuscate_string(self, tokval: str, next_tokval: str):  # noqa: C901, PLR0912
         # TODO (deoktr): consider f"" u"" ur"" b"" r"" strings
         # consider empty strings
         # consider calling function on whole string "".format()
-        strategies = self.ALL  # list(self.Strats._value2member_map_.values())
+        is_bytes = self._is_bytes_literal(tokval)
 
-        # if len(tokval) >= 6:
-        #     strategies = strategies.copy()
-        #     strategies.append(self.Strats.ADDITION)
+        strategies = list(self.ALL)
 
-        # if len(tokval) >= 6 and next_tokval != ".":
-        #     strategies = strategies.copy()
-        #     strategies.append(self.Strats.ONLY_ADDITION)
+        if is_bytes:
+            # SHIFT and REPLACE are text-only; exclude for byte literals
+            for s in (self.Strats.SHIFT, self.Strats.REPLACE):
+                if s in strategies:
+                    strategies.remove(s)
 
         if next_tokval != ".":
-            strategies = list(strategies)
-            strategies.extend(
-                [
-                    self.Strats.HEX,
-                    self.Strats.UNICODE,
-                    self.Strats.SHIFT,
-                ],
-            )
+            strategies.append(self.Strats.HEX)
+            if not is_bytes:
+                # UNICODE uses \u escapes which are invalid in byte literals
+                strategies.append(self.Strats.UNICODE)
+                strategies.append(self.Strats.SHIFT)
 
         strategy = random.choice(strategies)
 
         if strategy == self.Strats.BASE64:
-            tokens = self.obf_base64(tokval)
+            tokens = self._obf_base64(tokval)
         elif strategy == self.Strats.ADDITION:
-            tokens = self.additions(tokval)
+            tokens = self._additions(tokval)
         elif strategy == self.Strats.ONLY_ADDITION:
-            tokens = self.only_additions(tokval)
+            tokens = self._only_additions(tokval)
         elif strategy == self.Strats.BASE85:
-            tokens = self.obf_base85(tokval)
+            tokens = self._obf_base85(tokval)
         elif strategy == self.Strats.HEX:
-            tokens = self.hex(tokval)
+            tokens = self._hex(tokval)
         elif strategy == self.Strats.UNICODE:
-            tokens = self.unicode(tokval)
+            tokens = self._unicode(tokval)
         elif strategy == self.Strats.SHIFT:
-            tokens = self.obf_shift(tokval)
+            tokens = self._obf_shift(tokval)
         elif strategy == self.Strats.REPLACE:
-            tokens = self.string_replace(tokval)
+            tokens = self._string_replace(tokval)
         elif strategy == self.Strats.REVERSE:
-            tokens = self.string_reverse(tokval)
+            tokens = self._string_reverse(tokval)
         elif strategy == self.Strats.ONE_ON_N:
-            tokens = self.string_one_on_n(tokval)
+            tokens = self._string_one_on_n(tokval)
         else:
-            logger.error("unsupported strategy %s", strategy)
-            return None
+            logger.error("unsupported strategy %s, not obfuscating", strategy)
+            return [(STRING, tokval)]
 
         return tokens
 
@@ -442,9 +483,9 @@ class StringsObfuscator:
                 ENCODING,
             ]:
                 try:
-                    new_tokens = self.obfuscate_string(tokval, next_tokval)
-                except BaseException:  # noqa: BLE001
-                    logger.exception("failed to get new token")
+                    new_tokens = self._obfuscate_string(tokval, next_tokval)
+                except Exception:  # noqa: BLE001
+                    logger.warning("failed to obfuscate string token: %s", tokval[:50])
 
             if new_tokens:
                 result.extend(new_tokens)

{python_obfuscation_framework-1.11.0 → python_obfuscation_framework-1.11.1}/pof/utils/cipher/rc4.py

@@ -399,7 +399,7 @@ class RC4Cipher:
             return "".join(res)
 
         def rc4encrypt(key, plaintext):
-            plaintext = [ord(c) for c in plaintext]
+            plaintext = list(plaintext.encode("utf-8"))
             return encrypt_logic(key, plaintext)
 
         return rc4encrypt(self.key, string)

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

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

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

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

{python_obfuscation_framework-1.11.0 → python_obfuscation_framework-1.11.1}/python_obfuscation_framework.egg-info/SOURCES.txt

@@ -166,13 +166,20 @@ tests/obfuscator/test_edge_cases.py
 tests/obfuscator/test_integration.py
 tests/obfuscator/utils.py
 tests/obfuscator/fixtures/__init__.py
+tests/obfuscator/fixtures/booleans.py
 tests/obfuscator/fixtures/complex.py
+tests/obfuscator/fixtures/compression.py
 tests/obfuscator/fixtures/decorators.py
+tests/obfuscator/fixtures/deepenc.py
+tests/obfuscator/fixtures/docs.py
+tests/obfuscator/fixtures/encoding.py
+tests/obfuscator/fixtures/esoteric.py
 tests/obfuscator/fixtures/getattr.py
 tests/obfuscator/fixtures/import.py
 tests/obfuscator/fixtures/lambda.py
 tests/obfuscator/fixtures/moderate.py
 tests/obfuscator/fixtures/numbers.py
+tests/obfuscator/fixtures/rc4.py
 tests/obfuscator/fixtures/simple.py
 tests/obfuscator/fixtures/strings.py
 tests/obfuscator/fixtures/try.py

{python_obfuscation_framework-1.11.0 → python_obfuscation_framework-1.11.1}/tests/obfuscator/conftest.py

@@ -93,9 +93,9 @@ class SkipEntry:
 
 SKIP_LIST: list[SkipEntry] = [
     SkipEntry(
-        "GlobalsObfuscator",
-        "*",
-        "Fails: replaces inner function names with globals() lookups (KeyError on nested scope)",
+        "CommentsObfuscator",
+        "docs",
+        "esoteric fixture uses Foo.__doc__ which CommentsObfuscator removes by design",
     ),
 ]
 

python_obfuscation_framework-1.11.1/tests/obfuscator/fixtures/booleans.py

@@ -0,0 +1,30 @@
+print(True)
+print(False)
+
+if True:
+    print(1)
+
+if False:
+    pass
+else:
+    print(2)
+
+# obfuscated
+
+# not False
+print(not False)
+
+# all([])
+print(all([]))
+
+# any([True])
+print(any([True]))
+
+# not not True
+print(not not True)
+
+# '' in ''
+print('' in '')
+
+# bool(1)
+print(bool(1))

{python_obfuscation_framework-1.11.0 → python_obfuscation_framework-1.11.1}/tests/obfuscator/fixtures/complex.py

@@ -77,3 +77,24 @@ print(f"stopped at {i}")
 items = ["alpha", "beta", "gamma"]
 for idx, item in enumerate(items):
     print(f"{idx}:{item}")
+
+# obfuscated
+
+# ControlFlowFlattenObfuscator
+# TODO: uncomment
+# def greet(name):
+#     _state=936
+#     _ret=None
+#     while _state!=435:
+#         if _state==995:
+#             msg=msg+name
+#             _state=528
+#         elif _state==936:
+#             msg='Hello, '
+#             _state=995
+#         elif _state==528:
+#             _ret=msg
+#             _state=435
+#     return _ret
+#
+# greet("world")

python_obfuscation_framework-1.11.1/tests/obfuscator/fixtures/compression.py

@@ -0,0 +1,15 @@
+# Bz2Obfuscator
+import bz2,marshal
+exec(marshal.loads(bz2.decompress( b'BZh91AY&SY\xcf\xf8\xcd\xdc\x00\x00\ru\x80\xc0\x10\x01\x00@\xe4\x00@\x06%\xd4\x80\x08\x00 \x00"&\x80d\x196\xa1L&\x9a\x03LI\x99\\eR\x15\xcd\xb9\x04\xd4s\x1d\x08\x00\xf8\xbb\x92)\xc2\x84\x86\x7f\xc6n\xe0')))
+
+# GzipObfuscator
+import gzip,marshal
+exec(marshal.loads(gzip.decompress( b'\x1f\x8b\x08\x00$p\x91d\x02\xff\xfb,\xc6\xc0\xc0PP\x94\x99W\xa2\xa1\xee\x91\x9a\x93\x93\xaf\xa3P\x9e_\x94\x93\xa2\xae\xc9\x05\x00\xf2\x90\x8eA\x1b\x00\x00\x00')))
+
+# LzmaObfuscator
+import lzma,marshal
+exec(marshal.loads(lzma.decompress( b"\xfd7zXZ\x00\x00\x04\xe6\xd6\xb4F\x02\x00!\x01\x16\x00\x00\x00t/\xe5\xa3\x01\x00\x1a\xf3\x16\x00\x00\x00print('Hello, world')\n\x00\x00\xd5\xa4\x00\xec\xfa;\x9c\xf1\x00\x013\x1b\xf7\x19\x88^\x1f\xb6\xf3}\x01\x00\x00\x00\x00\x04YZ")))
+
+# ZlibObfuscator
+import zlib,marshal
+exec(marshal.loads(zlib.decompress( b'x\x9c\xfb,\xc6\xc0\xc0PP\x94\x99W\xa2\xa1\xee\x91\x9a\x93\x93\xaf\xa3P\x9e_\x94\x93\xa2\xae\xc9\x05\x00va\x08H')))

python_obfuscation_framework-1.11.1/tests/obfuscator/fixtures/deepenc.py

@@ -0,0 +1,14 @@
+# DeepEncryptionObfuscator
+from base64 import b64decode
+def foo():
+    r_dict=globals().copy()
+    r_dict.update(locals())
+    exec(b64decode( b'cHJpbnQgKCJIZWxsbywgd29ybGQiKQoK'),r_dict)
+    if'r'not in r_dict:
+        return None
+    else:
+        r_val=r_dict['r']
+        del r_dict
+        return r_val
+
+foo()

python_obfuscation_framework-1.11.1/tests/obfuscator/fixtures/docs.py

@@ -0,0 +1,10 @@
+# DocstringObfuscator
+from base64 import b64decode
+class Foo:
+    """
+    cHJpbnQoJ0hlbGxvLCB3b3JsZCcpCg==
+    """
+    pass
+
+
+exec(b64decode(Foo.__doc__.replace('\n','').replace(' ','')))