init

utils/__init__.py

@@ -0,0 +1 @@
+# This file ensures that the utils directory is treated as a Python package

utils/encryption.py

@@ -0,0 +1,82 @@
+import base64
+import hashlib
+import random
+from typing import Tuple
+
+class StringEncryptor:
+    def __init__(self, primary_key: bytes, secondary_key: bytes, salt: bytes):
+        self.primary_key = primary_key
+        self.secondary_key = secondary_key
+        self.salt = salt
+
+    def hide_byte(self, b: int) -> str:
+        """
+        Obfuscates a single byte as a random arithmetic or bitwise expression.
+        Used in the string encryption code to hide key bytes.
+        """
+        pattern = random.randint(1, 5)
+        if pattern == 1:
+            x1, x2, x3 = [random.randint(65, 90) for _ in range(3)]
+            result = x1 ^ x2 ^ x3 ^ b
+            return f"({x1}^{x2}^{x3}^{result})"
+        elif pattern == 2:
+            base = random.randint(65, 90)
+            multiplier = random.randint(2, 4)
+            adjusted = (base * multiplier - b)
+            return f"(({base}*{multiplier}-{adjusted}))"
+        elif pattern == 3:
+            shift = random.randint(1, 3)
+            modified = (b << shift) >> shift
+            diff = b - modified
+            return f"((({b << shift})>>{shift})+{diff})"
+        elif pattern == 4:
+            char1, char2 = random.sample(range(65, 91), 2)
+            result = char1 + char2 - b
+            return f"({char1}+{char2}-{result})"
+        else:
+            mod_base = random.randint(91, 100)
+            result = b % mod_base
+            factor = b // mod_base
+            return f"({factor}*{mod_base}+{result})"
+
+    def encrypt_string(self, s: str) -> Tuple[str, str, str]:
+        """
+        Encrypts a string with a multi-layer XOR scheme
+        and base85-encodes the result. Returns:
+          - encoded string,
+          - the code snippet that re-creates the keys in Python,
+          - the hex digest for the 'modifier'.
+        """
+        data = s.encode('utf-8')
+        modifier = hashlib.sha256(self.salt + data).digest()[:8]
+
+        layer1 = bytes(
+            d ^ k ^ m
+            for d, k, m in zip(
+                data,
+                self.primary_key * ((len(data) // len(self.primary_key)) + 1),
+                modifier * ((len(data) // len(modifier)) + 1)
+            )
+        )
+
+        final_data = bytes(
+            d ^ k
+            for d, k in zip(
+                layer1,
+                self.secondary_key * ((len(layer1) // len(self.secondary_key)) + 1)
+            )
+        )
+
+        encoded = base64.b85encode(final_data).decode()
+
+        primary_key_code = f"bytes([{','.join(self.hide_byte(b) for b in self.primary_key)}])"
+        secondary_key_code = f"bytes([{','.join(self.hide_byte(b) for b in self.secondary_key)}])"
+        salt_code = f"bytes([{','.join(self.hide_byte(b) for b in self.salt)}])"
+
+        key_setup = (
+            f"_pk = {primary_key_code}\n"
+            f"_sk = {secondary_key_code}\n"
+            f"_st = {salt_code}"
+        )
+        
+        return encoded, key_setup, modifier.hex()

utils/junk_gen.py

@@ -0,0 +1,54 @@
+import random
+import string
+from utils.name_gen import NameGenerator
+
+class JunkGenerator:
+    def __init__(self, name_generator: NameGenerator):
+        self.name_generator = name_generator
+
+    def add_junk(self) -> str:
+        """
+        Generates random multi-line junk code, used to pad the final output.
+        """
+        var1 = self.name_generator.generate_name()
+        var2 = self.name_generator.generate_name()
+
+        example_strings = ["HelloWorld", "CryptoMagic", "XxX_Obf_42", "DataStorm", "RandomStr", "TestString"]
+        s1 = random.choice(example_strings)
+        s2 = random.choice(example_strings)
+
+        multi_line_junks = [
+            f"{var1} = chr({random.randint(65, 90)}) + chr({random.randint(65, 90)})",
+            f"{var1} = sum([{random.randint(1,10)} for _ in range({random.randint(1,5)})])",
+            f"{var1} = len(bytes([{random.randint(65,90)}, {random.randint(65,90)}, {random.randint(65,90)}]))",
+            f"if chr({random.randint(65,90)}).isupper(): {var1} = {random.randint(0, 999)}",
+            f"{var1} = bytes([{random.randint(65,90)}] * {random.randint(1,3)})",
+            f"{var1} = ord(chr({random.randint(65,90)})) - {random.randint(1,10)}",
+
+            f"{var1} = '{s1}'.lower()\n{var2} = '{s2}'.upper()",
+            f"{var1} = [chr(random.randint(65,90)) for _ in range({random.randint(2,5)})]\n{var2} = ''.join({var1})",
+            f"{var1} = {random.randint(1,10)} ** {random.randint(1,3)}\n{var2} = {var1} % {random.randint(1,10)}",
+            f"{var1} = [{random.randint(1,5)} for _ in range({random.randint(3,5)})]\nif len({var1}) > {random.randint(1,4)}: {var2} = sum({var1})",
+            f"{var1} = {{ {random.randint(1,10)} : '{s1}' }}\n{var2} = {var1}.get({random.randint(1,10)}, None)",
+            f"{var1} = set(range({random.randint(2,5)}))\n{var2} = set(range({random.randint(2,5)}))\n{var1}.intersection({var2})"
+        ]
+        return random.choice(multi_line_junks)
+
+    def generate_junk(self) -> str:
+        """
+        Generates a single line of junk code.
+        """
+        var_name = self.name_generator.generate_name()
+        junk_code = [
+            f"{var_name} = {random.randint(0, 100)}",
+            f"{var_name} = '{''.join(random.choices(string.ascii_letters, k=10))}'",
+            f"{var_name} = {random.randint(0, 100)} + {random.randint(0, 100)}",
+            f"{var_name} = {random.randint(0, 100)} * {random.randint(0, 100)}",
+            f"{var_name} = {random.randint(0, 100)} - {random.randint(0, 100)}",
+            f"{var_name} = {random.randint(0, 100)} / {random.randint(1, 100)}",
+            f"{var_name} = '{''.join(random.choices(string.ascii_letters + string.digits, k=15))}'",
+            f"{var_name} = {random.randint(0, 100)} % {random.randint(1, 100)}",
+            f"{var_name} = {random.randint(0, 100)} ** {random.randint(0, 5)}",
+            f"{var_name} = {random.randint(0, 100)} // {random.randint(1, 100)}"
+        ]
+        return random.choice(junk_code)

utils/name_gen.py

@@ -0,0 +1,26 @@
+import itertools
+from typing import Iterator, Set
+
+class NameGenerator:
+    def __init__(self):
+        self._name_iterator = self._create_iterator()
+        self.used_names = set()
+    
+    def _create_iterator(self) -> Iterator[str]:
+        """
+        Generates obfuscated names like: vIl1lO0o0Z2z2...
+        """
+        patterns = ['Il1l', 'O0o0', 'Z2z2', 'S5s5', 'B8b8', 'Q9q9']
+        for length in itertools.count(2):  # Start with length=2, continue forever
+            for combo in itertools.product(patterns, repeat=length):
+                yield 'v' + ''.join(combo)
+
+    def generate_name(self) -> str:
+        """
+        Get a fresh unique variable name.
+        """
+        while True:
+            candidate = next(self._name_iterator)
+            if candidate not in self.used_names:
+                self.used_names.add(candidate)
+                return candidate