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

{python_obfuscation_framework-1.9.4/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.9.4
+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>
@@ -320,53 +320,44 @@ echo "print('Hello, world')" | pof -f obfuscator -k UUIDObfuscator | python
 
 ### Obfuscator
 
-`VariablesObfuscator` the most basic obfuscator will rename variables.
+`NamesObfuscator` obfuscator is renaming variables, classes, and functions.
 
 Source in `examples/source.py`.
 
 ```python
 import os
 
-def get_linux_release_info():
+def BJM4FaQJf1():
     """Get Linux release info from /etc/os-release."""
-    uggNx = '/etc/os-release'
-    if not os.path.exists(uggNx):
+    h77 = '/etc/os-release'
+    if not os.path.exists(h77):
         print('OS release file not found. This might not be a Linux system.')
         return None
-    LY3mN = {}
+    jkFr = {}
     try:
-        with open(uggNx, 'r') as kj0:
-            for Stv9o in kj0:
-                if not Stv9o or '=' not in Stv9o:
+        with open(h77, 'r') as LfQ:
+            for GIVt40c7RR in LfQ:
+                if not GIVt40c7RR or '=' not in GIVt40c7RR:
                     continue
-                l0j, QE5kCKYwMe = Stv9o.strip().split('=', 1)
-                QE5kCKYwMe = QE5kCKYwMe.strip('"\'\n')
-                LY3mN[l0j] = QE5kCKYwMe
+                KPO5j, RQvTXmL = GIVt40c7RR.strip().split('=', 1)
+                RQvTXmL = RQvTXmL.strip('"\'\n')
+                jkFr[KPO5j] = RQvTXmL
         print('\nLinux Release Information:')
-        print(f"Distribution: {LY3mN.get('NAME', 'Unknown')}")
-        print(f"Version: {LY3mN.get('VERSION', 'Unknown')}")
-        print(f"Version ID: {LY3mN.get('VERSION_ID', 'Unknown')}")
-        print(f"Pretty Name: {LY3mN.get('PRETTY_NAME', 'Unknown')}")
-        return LY3mN
-    except Exception as e:
-        print(f'Error reading release file: {e}')
+        print(f"Distribution: {jkFr.get('NAME', 'Unknown')}")
+        print(f"Version: {jkFr.get('VERSION', 'Unknown')}")
+        print(f"Version ID: {jkFr.get('VERSION_ID', 'Unknown')}")
+        print(f"Pretty Name: {jkFr.get('PRETTY_NAME', 'Unknown')}")
+        return jkFr
+    except Exception as LzYLqi_:
+        print(f'Error reading release file: {LzYLqi_}')
         return None
 if __name__ == '__main__':
     if os.name == 'posix' and os.path.exists('/etc/os-release'):
-        E_R72 = get_linux_release_info()
+        yv4HAqmn = BJM4FaQJf1()
     else:
         print('This script is designed for Linux systems.')
 ```
 
-`DefinitionsObfuscator` obfuscate function names.
-
-> [!WARNING]
-> `NamesObfuscator` obfuscator is renaming variables, classes, functions, and
-> imports. Right now this obfuscator can fail under very specific circumstances,
-> see `pof/obfuscator/names.py`. There is an alternative implementation at
-> `NamesRopeObfuscator` that uses `rope`, it's a work in progress and currently
-> does not obfuscate variables declared inside functions.
-
 Other very basic obfuscation functions are done by specific obfuscators like:
 
 - Removing comments with `CommentsObfuscator`.
@@ -804,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
@@ -873,6 +894,21 @@ def greet(name):
 > [!NOTE]
 > Functions containing `yield`, `async`, or `try/except` are skipped and left unchanged.
 
+#### DeadCodeObfuscator
+
+Insert dead (unreachable/unused) code blocks into the source.
+
+Source: `print('Hello, world')`
+
+```python
+while False:
+    Etb4inx6B1=[21,7,46,2]
+    agw_QLOu=283-42
+    FwQ2='msg'
+
+print('Hello, world')
+```
+
 ### Stager
 
 #### DownloadStager
@@ -1366,8 +1402,6 @@ Other Python obfuscation projects:
 
 ## TODO
 
-- Add dead code, opaque predicates.
-- Fix `NamesObfuscator`.
 - Add option to prepend a shebang, and add ability to customize it.
 
 ## License

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

@@ -275,53 +275,44 @@ echo "print('Hello, world')" | pof -f obfuscator -k UUIDObfuscator | python
 
 ### Obfuscator
 
-`VariablesObfuscator` the most basic obfuscator will rename variables.
+`NamesObfuscator` obfuscator is renaming variables, classes, and functions.
 
 Source in `examples/source.py`.
 
 ```python
 import os
 
-def get_linux_release_info():
+def BJM4FaQJf1():
     """Get Linux release info from /etc/os-release."""
-    uggNx = '/etc/os-release'
-    if not os.path.exists(uggNx):
+    h77 = '/etc/os-release'
+    if not os.path.exists(h77):
         print('OS release file not found. This might not be a Linux system.')
         return None
-    LY3mN = {}
+    jkFr = {}
     try:
-        with open(uggNx, 'r') as kj0:
-            for Stv9o in kj0:
-                if not Stv9o or '=' not in Stv9o:
+        with open(h77, 'r') as LfQ:
+            for GIVt40c7RR in LfQ:
+                if not GIVt40c7RR or '=' not in GIVt40c7RR:
                     continue
-                l0j, QE5kCKYwMe = Stv9o.strip().split('=', 1)
-                QE5kCKYwMe = QE5kCKYwMe.strip('"\'\n')
-                LY3mN[l0j] = QE5kCKYwMe
+                KPO5j, RQvTXmL = GIVt40c7RR.strip().split('=', 1)
+                RQvTXmL = RQvTXmL.strip('"\'\n')
+                jkFr[KPO5j] = RQvTXmL
         print('\nLinux Release Information:')
-        print(f"Distribution: {LY3mN.get('NAME', 'Unknown')}")
-        print(f"Version: {LY3mN.get('VERSION', 'Unknown')}")
-        print(f"Version ID: {LY3mN.get('VERSION_ID', 'Unknown')}")
-        print(f"Pretty Name: {LY3mN.get('PRETTY_NAME', 'Unknown')}")
-        return LY3mN
-    except Exception as e:
-        print(f'Error reading release file: {e}')
+        print(f"Distribution: {jkFr.get('NAME', 'Unknown')}")
+        print(f"Version: {jkFr.get('VERSION', 'Unknown')}")
+        print(f"Version ID: {jkFr.get('VERSION_ID', 'Unknown')}")
+        print(f"Pretty Name: {jkFr.get('PRETTY_NAME', 'Unknown')}")
+        return jkFr
+    except Exception as LzYLqi_:
+        print(f'Error reading release file: {LzYLqi_}')
         return None
 if __name__ == '__main__':
     if os.name == 'posix' and os.path.exists('/etc/os-release'):
-        E_R72 = get_linux_release_info()
+        yv4HAqmn = BJM4FaQJf1()
     else:
         print('This script is designed for Linux systems.')
 ```
 
-`DefinitionsObfuscator` obfuscate function names.
-
-> [!WARNING]
-> `NamesObfuscator` obfuscator is renaming variables, classes, functions, and
-> imports. Right now this obfuscator can fail under very specific circumstances,
-> see `pof/obfuscator/names.py`. There is an alternative implementation at
-> `NamesRopeObfuscator` that uses `rope`, it's a work in progress and currently
-> does not obfuscate variables declared inside functions.
-
 Other very basic obfuscation functions are done by specific obfuscators like:
 
 - Removing comments with `CommentsObfuscator`.
@@ -759,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
@@ -828,6 +849,21 @@ def greet(name):
 > [!NOTE]
 > Functions containing `yield`, `async`, or `try/except` are skipped and left unchanged.
 
+#### DeadCodeObfuscator
+
+Insert dead (unreachable/unused) code blocks into the source.
+
+Source: `print('Hello, world')`
+
+```python
+while False:
+    Etb4inx6B1=[21,7,46,2]
+    agw_QLOu=283-42
+    FwQ2='msg'
+
+print('Hello, world')
+```
+
 ### Stager
 
 #### DownloadStager
@@ -1321,8 +1357,6 @@ Other Python obfuscation projects:
 
 ## TODO
 
-- Add dead code, opaque predicates.
-- Fix `NamesObfuscator`.
 - Add option to prepend a shebang, and add ability to customize it.
 
 ## License

{python_obfuscation_framework-1.9.4 → python_obfuscation_framework-1.11.0}/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)

{python_obfuscation_framework-1.9.4 → python_obfuscation_framework-1.11.0}/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)

{python_obfuscation_framework-1.9.4 → python_obfuscation_framework-1.11.0}/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",

{python_obfuscation_framework-1.9.4 → 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.9.4 → 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 = [