add: bitwise operations for number and boolean obfuscators

deoktr · deoktr · commit 261fc7e99315 · 2026-03-30T20:09:55.000+02:00
diff --git a/README.md b/README.md
@@ -373,30 +373,38 @@ print(len('bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb'))
 
 # Boolean
 print((True+True+True+True+True+True+True+True+True+True+True+True+True+True+True+True+True+True+True+True+True+True+True+True+True+True+True+True+True+True+True+True+True+True+True+True+True+True+True+True+True+True))
+
+# Bitwise XOR
+print((53^31))
+
+# Bitwise shift
+print((21<<1))
+
+# Bitwise NOT complement
+print((~(~42)))
 ```
 
 #### BooleanObfuscator
 
 Source: `print(True)`
 
 ```python
-# 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))
+print(bool(1&1))
+print(bool(~0))
+```
+
+Source: `print(False)`
+
+```python
+print(bool(1&0))
+print(bool(1^1))
+print(bool(0|0))
 ```
 
 #### ConstantsObfuscator
diff --git a/pof/obfuscator/boolean.py b/pof/obfuscator/boolean.py
@@ -15,15 +15,15 @@
 # along with this program.  If not, see <https://www.gnu.org/licenses/>.
 
 import random
-from tokenize import LPAR, LSQB, NAME, NUMBER, RPAR, RSQB, STRING
+from tokenize import LPAR, LSQB, NAME, NUMBER, OP, RPAR, RSQB, STRING
 
 
 class BooleanObfuscator:
     """Obfuscate booleans with multiple methods."""
 
     @staticmethod
-    def obf_true():
-        match random.randint(1, 6):
+    def obf_true():  # noqa: PLR0911
+        match random.randint(1, 9):
             case 1:
                 # all([])
                 return [
@@ -77,10 +77,39 @@ def obf_true():
                     (NUMBER, "1"),
                     (RPAR, ")"),
                 ]
+            case 7:
+                # bool(1&1)
+                return [
+                    (NAME, "bool"),
+                    (LPAR, "("),
+                    (NUMBER, "1"),
+                    (OP, "&"),
+                    (NUMBER, "1"),
+                    (RPAR, ")"),
+                ]
+            case 8:
+                # bool(1|0)
+                return [
+                    (NAME, "bool"),
+                    (LPAR, "("),
+                    (NUMBER, "1"),
+                    (OP, "|"),
+                    (NUMBER, "0"),
+                    (RPAR, ")"),
+                ]
+            case 9:
+                # bool(~0)
+                return [
+                    (NAME, "bool"),
+                    (LPAR, "("),
+                    (OP, "~"),
+                    (NUMBER, "0"),
+                    (RPAR, ")"),
+                ]
 
     @staticmethod
-    def obf_false():
-        match random.randint(1, 6):
+    def obf_false():  # noqa: PLR0911
+        match random.randint(1, 9):
             case 1:
                 # False = all([[]])
                 return [
@@ -137,6 +166,36 @@ def obf_false():
                     (NUMBER, "0"),
                     (RPAR, ")"),
                 ]
+            case 7:
+                # bool(1&0)
+                return [
+                    (NAME, "bool"),
+                    (LPAR, "("),
+                    (NUMBER, "1"),
+                    (OP, "&"),
+                    (NUMBER, "0"),
+                    (RPAR, ")"),
+                ]
+            case 8:
+                # bool(0|0)
+                return [
+                    (NAME, "bool"),
+                    (LPAR, "("),
+                    (NUMBER, "0"),
+                    (OP, "|"),
+                    (NUMBER, "0"),
+                    (RPAR, ")"),
+                ]
+            case 9:
+                # bool(1^1)
+                return [
+                    (NAME, "bool"),
+                    (LPAR, "("),
+                    (NUMBER, "1"),
+                    (OP, "^"),
+                    (NUMBER, "1"),
+                    (RPAR, ")"),
+                ]
 
     def obfuscate_boolean(self, tokval):
         if tokval == "True":
diff --git a/pof/obfuscator/numbers.py b/pof/obfuscator/numbers.py
@@ -43,18 +43,21 @@ class NStrats(Enum):
         HEX = 3
         BOOLEAN = 4
         LEN = 5
+        BITWISE = 6
 
     INT_STRATS = (  # positive int obfuscation strategies
         NStrats.STRING,
         NStrats.ADDITION,
         NStrats.HEX,
         NStrats.LEN,
+        NStrats.BITWISE,
     )
     NEG_INT_STRATS = (  # negative int obfuscation strategies
         NStrats.STRING,
         NStrats.ADDITION,
         NStrats.HEX,
         NStrats.LEN,
+        NStrats.BITWISE,
     )
     FLOAT_STRATS = (  # positive float obfuscation strategies
         NStrats.STRING,
@@ -203,6 +206,133 @@ def obf_len_random(tokval):
         )
         return t
 
+    @staticmethod
+    def obf_bitwise(tokval):  # noqa: C901, PLR0912
+        """Obfuscate integer using bitwise operations."""
+        n = int(tokval)
+
+        # choose a sub-strategy randomly
+        strategies = ["xor", "shift", "not"]
+        if n != 0:
+            strategies.append("or_compose")
+        strategy = random.choice(strategies)
+
+        if strategy == "xor":
+            # n = a ^ b where a is random, b = n ^ a
+            mask = random.randint(1, max(abs(n) + 100, 255))
+            other = n ^ mask
+            tokens = [
+                (NUMBER, str(mask)),
+                (OP, "^"),
+            ]
+            if other < 0:
+                tokens.extend(
+                    [
+                        (LPAR, "("),
+                        (NUMBER, str(other)),
+                        (RPAR, ")"),
+                    ],
+                )
+            else:
+                tokens.append((NUMBER, str(other)))
+
+        elif strategy == "shift":
+            if n == 0:
+                # 1 >> 1 = 0
+                tokens = [
+                    (NUMBER, "1"),
+                    (OP, ">>"),
+                    (NUMBER, "1"),
+                ]
+            elif n > 0:
+                # find a valid shift amount
+                k = random.randint(1, 3)
+                shifted = n >> k
+                remainder = n - (shifted << k)
+                if remainder == 0:
+                    tokens = [
+                        (NUMBER, str(shifted)),
+                        (OP, "<<"),
+                        (NUMBER, str(k)),
+                    ]
+                else:
+                    tokens = [
+                        (LPAR, "("),
+                        (NUMBER, str(shifted)),
+                        (OP, "<<"),
+                        (NUMBER, str(k)),
+                        (RPAR, ")"),
+                        (OP, "|"),
+                        (NUMBER, str(remainder)),
+                    ]
+            else:
+                # for negatives, use ~(~n)
+                complement = ~n
+                tokens = [
+                    (OP, "~"),
+                    (NUMBER, str(complement)),
+                ]
+
+        elif strategy == "not":
+            # ~(~n) = n, but render as ~m where m = ~n
+            complement = ~n
+            if complement >= 0:
+                tokens = [
+                    (OP, "~"),
+                    (NUMBER, str(complement)),
+                ]
+            else:
+                tokens = [
+                    (OP, "~"),
+                    (LPAR, "("),
+                    (NUMBER, str(complement)),
+                    (RPAR, ")"),
+                ]
+
+        else:
+            # or_compose: split n into disjoint bit groups
+            # a | b where a & b == 0 and a | b == n
+            if n > 0:
+                bit_len = n.bit_length()
+                split = random.randint(1, max(bit_len - 1, 1))
+                mask = (1 << split) - 1
+                a = n & mask
+                b = n & ~mask
+            else:
+                # for negatives, use XOR as fallback
+                mask = random.randint(1, 255)
+                other = n ^ mask
+                tokens = [
+                    (NUMBER, str(mask)),
+                    (OP, "^"),
+                ]
+                if other < 0:
+                    tokens.extend(
+                        [
+                            (LPAR, "("),
+                            (NUMBER, str(other)),
+                            (RPAR, ")"),
+                        ],
+                    )
+                else:
+                    tokens.append((NUMBER, str(other)))
+                return [
+                    (LPAR, "("),
+                    *tokens,
+                    (RPAR, ")"),
+                ]
+            tokens = [
+                (NUMBER, str(a)),
+                (OP, "|"),
+                (NUMBER, str(b)),
+            ]
+
+        return [
+            (LPAR, "("),
+            *tokens,
+            (RPAR, ")"),
+        ]
+
     @staticmethod
     def verify_number_obfuscation(tokval, tokens):
         # if only one token then it's the same
@@ -217,7 +347,7 @@ def verify_number_obfuscation(tokval, tokens):
         logger.error(msg)
         return False
 
-    def obfuscate_number(self, toknum, tokval):  # noqa: C901 PLR0912
+    def obfuscate_number(self, toknum, tokval):  # noqa: C901, PLR0912, PLR0915
         unobfuscated = [(toknum, tokval)]
 
         # get token type
@@ -268,6 +398,8 @@ def obfuscate_number(self, toknum, tokval):  # noqa: C901 PLR0912
                 tokens = self.obf_boolean_conversion(tokval)
             elif strategy == self.NStrats.LEN:
                 tokens = self.obf_len_random(tokval)
+            elif strategy == self.NStrats.BITWISE:
+                tokens = self.obf_bitwise(tokval)
             else:
                 msg = f"Strategy {strategy} not found"
                 raise PofError(msg)  # noqa: TRY301
diff --git a/pyproject.toml b/pyproject.toml
@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "python-obfuscation-framework"
-version = "1.12.0"
+version = "1.12.1"
 description = "Python Obfuscation Framework"
 readme = "README.md"
 requires-python = ">=3.12"
diff --git a/tests/obfuscator/fixtures/booleans.py b/tests/obfuscator/fixtures/booleans.py
@@ -10,21 +10,15 @@
     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('' in '')
 print(bool(1))
+print(bool(1&1))
+print(bool(~0))
+
+print(bool(1&0))
+print(bool(1^1))
+print(bool(0|0))
diff --git a/tests/obfuscator/fixtures/numbers.py b/tests/obfuscator/fixtures/numbers.py
@@ -27,3 +27,12 @@
 
 # Boolean
 print((True+True+True+True+True+True+True+True+True+True+True+True+True+True+True+True+True+True+True+True+True+True+True+True+True+True+True+True+True+True+True+True+True+True+True+True+True+True+True+True+True+True))
+
+# Bitwise XOR
+print((53^31))
+
+# Bitwise shift
+print((21<<1))
+
+# Bitwise NOT complement
+print((~(~42)))
