import os import re import base64 import random import string import zlib import marshal import struct import hashlib # ─── Shared helpers ─────────────────────────────────────────────────────────── def _rand_hex_name(length: int = 6) -> str: """Generate a hex-style identifier that looks like a memory address.""" return "_0x" + "".join(random.choices("0123456789abcdef", k=length)) def _rand_key(length: int = 16) -> list[int]: return [random.randint(1, 254) for _ in range(length)] def _xor_bytes(data: bytes, key: list[int]) -> bytes: return bytes(b ^ key[i % len(key)] for i, b in enumerate(data)) def _b64(data: bytes) -> str: return base64.b64encode(data).decode() def _rand_int_expr(value: int) -> str: """Represent an integer as an opaque math expression.""" a = random.randint(1, 999) b = value - a ops = [ f"({a} + {b})", f"({value * 2} - {value})", f"({value + 7} - 7)", f"math.floor({value}.0)", ] return random.choice(ops) # ═══════════════════════════════════════════════════════════════════════════════ # ─── LUA ────────────────────────────────────────────────────────────────────── # ═══════════════════════════════════════════════════════════════════════════════ def _lua_xor_encrypt_strings(code: str, key: list[int]) -> tuple[str, str]: """ Replace every string literal with a call to a runtime XOR-decoder. Returns (modified_code, decoder_function_source). """ decoder_name = _rand_hex_name(8) key_var = _rand_hex_name(6) key_repr = "{"+",".join(str(k) for k in key)+"}" decoder_src = ( f"local {key_var} = {key_repr}\n" f"local function {decoder_name}(e)\n" f" local r = {{}}\n" f" for i = 1, #e do\n" f" local b = e:byte(i)\n" f" r[i] = string.char(b ~ {key_var}[((i-1) % #{key_var})+1])\n" f" end\n" f" return table.concat(r)\n" f"end\n" ) def encrypt_string(m): raw = m.group(1) encrypted = _xor_bytes(raw.encode("latin-1", errors="replace"), key) escaped = "".join(f"\\{b}" for b in encrypted) return f'{decoder_name}("{escaped}")' modified = re.sub(r'"([^"\n\\]*)"', encrypt_string, code) return modified, decoder_src def _lua_rename_identifiers(code: str) -> tuple[str, dict]: """Rename locals, function names, and parameters to hex-style names.""" # collect declared locals and function params idents = set() idents |= set(re.findall(r'\blocal\s+([A-Za-z_][A-Za-z0-9_]*)\b', code)) idents |= set(re.findall(r'\bfunction\s+([A-Za-z_][A-Za-z0-9_]*)\b', code)) idents |= set(re.findall(r'function\s*$([^)]*)$', code)) # flatten params captured above flat = set() for item in idents: for part in item.split(','): p = part.strip() if p and re.match(r'^[A-Za-z_][A-Za-z0-9_]*$', p): flat.add(p) lua_builtins = { 'print','type','pairs','ipairs','next','select','tostring','tonumber', 'error','assert','pcall','xpcall','require','load','loadstring', 'rawget','rawset','rawequal','rawlen','setmetatable','getmetatable', 'string','table','math','io','os','coroutine','debug','package', 'unpack','table','bit','bit32','utf8','true','false','nil','and', 'or','not','if','else','elseif','then','end','do','while','repeat', 'until','for','in','local','function','return','break','goto', '_G','_VERSION','collectgarbage','dofile','loadfile', } flat -= lua_builtins mapping = {name: _rand_hex_name(8) for name in flat} for old, new in mapping.items(): code = re.sub(rf'(? str: """ Insert opaque always-true/false predicates that confuse deobfuscators but never affect execution. """ # Opaque always-true: (n*(n+1)) % 2 == 0 n = _rand_hex_name(6) v = _rand_hex_name(6) junk_a = random.randint(2, 99) junk_b = random.randint(2, 99) pred_true = ( f"local {n} = {_rand_int_expr(random.randint(10,9999))}\n" f"local {v} = ({n} * ({n} + 1)) % 2\n" f"if {v} ~= 0 then error('fatal') end\n" ) # Opaque always-false dead branch dead_var = _rand_hex_name(6) pred_false = ( f"local {dead_var} = {_rand_int_expr(junk_a * junk_a)}\n" f"if {dead_var} < 0 then\n" f" error('unreachable_{_rand_hex_name(4)}')\n" f"end\n" ) lines = code.splitlines() positions = sorted(random.sample(range(len(lines)), min(4, len(lines))), reverse=True) for pos in positions: snippet = random.choice([pred_true, pred_false]) lines.insert(pos, snippet) return "\n".join(lines) def _lua_anti_debug(code: str) -> str: trap_var = _rand_hex_name(6) depth_var = _rand_hex_name(6) guard = ( f"-- [protection layer]\n" f"local {trap_var} = type(debug)\n" f"if {trap_var} ~= 'table' then error('') end\n" f"local {depth_var} = debug.getinfo(1, 'S')\n" f"if {depth_var} == nil then error('') end\n" f"if debug.getinfo(2, 'n') ~= nil then\n" f" local _chk = debug.getinfo(2,'n').name\n" f" if _chk == 'pcall' or _chk == 'xpcall' then\n" f" for i=1,1e8 do end\n" f" end\n" f"end\n" ) return guard + code def _lua_anti_vm(code: str) -> str: guard_var = _rand_hex_name(6) env_var = _rand_hex_name(6) guard = ( f"local {guard_var} = {{}}\n" f"for {env_var}, _ in pairs(_G) do\n" f" if {env_var} == 'jit' or {env_var} == 'ffi' then\n" f" -- allowed\n" f" end\n" f"end\n" f"if type(rawget(_G,'Script')) == 'nil' and type(rawget(_G,'game')) == 'nil'\n" f" and type(rawget(_G,'workspace')) == 'nil' then\n" f" -- possibly a raw Lua VM / sandbox\n" f" local _tick = os.clock\n" f" if type(_tick) ~= 'function' then error('env check failed') end\n" f"end\n" ) return guard + code def _lua_load_wrap(code: str, key: list[int]) -> str: """ Final layer: XOR-encrypt the entire script then wrap it in a load() call with a runtime decoder. The source is never readable as plaintext. """ encrypted = _xor_bytes(code.encode("utf-8"), key) b64_payload = _b64(encrypted) loader_key_var = _rand_hex_name(6) loader_b64_var = _rand_hex_name(6) loader_dec_fn = _rand_hex_name(8) loader_b64_fn = _rand_hex_name(8) loader_result = _rand_hex_name(6) loader_err = _rand_hex_name(6) key_repr = "{"+",".join(str(k) for k in key)+"}" wrapper = ( f"local {loader_key_var}={key_repr}\n" f"local {loader_b64_var}='{b64_payload}'\n" f"local function {loader_b64_fn}(d)\n" f" local b='ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'\n" f" d=d:gsub('[^'..b..'=]','')\n" f" local r=''\n" f" local t=0;local n=0\n" f" for i=1,#d do\n" f" local c=b:find(d:sub(i,i),1,true)\n" f" if c then\n" f" t=t*64+(c-1);n=n+6\n" f" if n>=8 then n=n-8;r=r..string.char(math.floor(t/2^n)%256) end\n" f" end\n" f" end\n" f" return r\n" f"end\n" f"local function {loader_dec_fn}(e)\n" f" local r={{}}\n" f" for i=1,#e do\n" f" r[i]=string.char(e:byte(i)~{loader_key_var}[((i-1)%#{loader_key_var})+1])\n" f" end\n" f" return table.concat(r)\n" f"end\n" f"local {loader_result},{loader_err}=load({loader_dec_fn}({loader_b64_fn}({loader_b64_var})))\n" f"if not {loader_result} then error({loader_err}) end\n" f"{loader_result}()\n" ) return wrapper def obfuscate_lua(code: str, levels: list[str]) -> str: # Strip comments code = re.sub(r'--\[\[.*?\]\]', '', code, flags=re.DOTALL) code = re.sub(r'--[^\n]*', '', code) code = re.sub(r'\n{3,}', '\n\n', code).strip() key_inner = _rand_key(24) key_outer = _rand_key(24) header_parts = [] if "Anti-VM" in levels: code = _lua_anti_vm(code) if "Anti-Deobfuscation" in levels: code = _lua_anti_debug(code) if "String Encryption" in levels or "Advanced" in levels: code, decoder_src = _lua_xor_encrypt_strings(code, key_inner) header_parts.append(decoder_src) if "Basic" in levels or "Advanced" in levels: code, _ = _lua_rename_identifiers(code) if "Control Flow" in levels or "Advanced" in levels: code = _lua_inject_opaque_predicates(code) # Assemble the inner script inner = "\n".join(header_parts) + "\n" + code if header_parts else code # Final load() wrapper: encrypts the entire assembled script if "Advanced" in levels or "Control Flow" in levels or "String Encryption" in levels: return _lua_load_wrap(inner, key_outer) return inner # ═══════════════════════════════════════════════════════════════════════════════ # ─── PYTHON ─────────────────────────────────────────────────────────────────── # ═══════════════════════════════════════════════════════════════════════════════ def _python_xor_strings(code: str, key: list[int]) -> str: """Replace string literals with XOR-decoded runtime expressions.""" key_bytes = bytes(key) def encrypt(m): quote = m.group(1) s = m.group(2) if len(s) < 3: return m.group(0) encrypted = _xor_bytes(s.encode("utf-8", errors="replace"), key) b64_enc = _b64(encrypted) key_repr = str(list(key)) return ( f'bytes([b^k for b,k in zip(__import__("base64").b64decode("{b64_enc}"),' f'({key_repr}*999)[:len(__import__("base64").b64decode("{b64_enc}"))])]).decode()' ) return re.sub(r'(["\'])([^"\'\\ ]{3,})\1', encrypt, code) def _python_rename_identifiers(code: str) -> str: idents = set(re.findall(r'(? str: trap_var = _rand_hex_name(6) frame_var = _rand_hex_name(6) return ( f"import sys as _sys, os as _os\n" f"def {trap_var}():\n" f" if _sys.gettrace() is not None:\n" f" raise SystemExit(0)\n" f" {frame_var} = _sys._getframe(0)\n" f" if {frame_var}.f_back is not None and {frame_var}.f_back.f_back is not None:\n" f" raise SystemExit(0)\n" f"{trap_var}()\n" ) def _python_anti_vm() -> str: check_var = _rand_hex_name(6) return ( f"import platform as _plat, os as _os\n" f"def {check_var}():\n" f" _s = _plat.system()\n" f" if _s in ('', 'Java'):\n" f" raise SystemExit(0)\n" f" _suspicious = ['VBOX','VMWARE','VIRTUAL','SANDBOX','CUCKOO','ANALYSIS']\n" f" for _k, _v in _os.environ.items():\n" f" for _bad in _suspicious:\n" f" if _bad in _k.upper() or _bad in _v.upper():\n" f" raise SystemExit(0)\n" f" if _os.path.exists('/proc/1/cgroup'):\n" f" with open('/proc/1/cgroup','r') as _f:\n" f" if 'docker' in _f.read() or 'kubepod' in _f.read():\n" f" raise SystemExit(0)\n" f"{check_var}()\n" ) def _python_marshal_wrap(code: str) -> str: """ Compile code to marshal bytecode, zlib compress it, base64 encode it, then produce a self-executing loader. Multiple layers deep. """ try: code_obj = compile(code, '', 'exec') raw = marshal.dumps(code_obj) except SyntaxError: # If the pre-processed code has issues, wrap original differently raw = code.encode('utf-8') compressed = zlib.compress(raw, level=9) b64 = _b64(compressed) return ( f"import zlib,base64\n" f"exec(zlib.decompress(base64.b64decode('{b64}')).decode())\n" ) # Layer 1: marshal compressed_l1 = zlib.compress(raw, level=9) b64_l1 = _b64(compressed_l1) # Layer 2: wrap again inner_loader = ( f"import marshal,zlib,base64\n" f"exec(compile(marshal.loads(zlib.decompress(base64.b64decode('{b64_l1}'))),'','exec'))\n" ) try: obj2 = compile(inner_loader, '', 'exec') raw2 = marshal.dumps(obj2) compressed_l2 = zlib.compress(raw2, level=9) b64_l2 = _b64(compressed_l2) return ( f"import marshal,zlib,base64\n" f"exec(compile(marshal.loads(zlib.decompress(base64.b64decode('{b64_l2}'))),'','exec'))\n" ) except Exception: return inner_loader def _python_inject_opaque(code: str) -> str: """Inject opaque predicates and junk calculations.""" n = random.randint(10, 9999) junk_var = _rand_hex_name(6) cond_var = _rand_hex_name(6) dead_fn = _rand_hex_name(8) snippets = [ f"{junk_var} = {n}\n{cond_var} = ({junk_var} * ({junk_var} + 1)) % 2\nassert {cond_var} == 0\n", f"def {dead_fn}(): return {random.randint(1,999)} * {random.randint(1,999)}\n", f"{junk_var} = [x for x in range({random.randint(1,50)})]\n", ] lines = code.splitlines() for snippet in random.choices(snippets, k=3): pos = random.randint(0, max(0, len(lines) - 1)) lines.insert(pos, snippet) return "\n".join(lines) def obfuscate_python(code: str, levels: list[str]) -> str: # Strip comments and docstrings code = re.sub(r'#[^\n]*', '', code) code = re.sub(r'"""[\s\S]*?"""', '', code) code = re.sub(r"'''[\s\S]*?'''", '', code) code = re.sub(r'\n{3,}', '\n\n', code).strip() prefix_lines = [] if "Anti-VM" in levels: prefix_lines.append(_python_anti_vm()) if "Anti-Deobfuscation" in levels: prefix_lines.append(_python_anti_debug()) key = _rand_key(20) if "String Encryption" in levels or "Advanced" in levels: code = _python_xor_strings(code, key) if "Basic" in levels or "Advanced" in levels: code = _python_rename_identifiers(code) if "Control Flow" in levels or "Advanced" in levels: code = _python_inject_opaque(code) # Combine prefix guards with the obfuscated body full_code = "\n".join(prefix_lines) + "\n" + code if prefix_lines else code # Final marshal+zlib+base64 compilation wrap if "Advanced" in levels or "String Encryption" in levels or "Control Flow" in levels: return _python_marshal_wrap(full_code) return full_code # ═══════════════════════════════════════════════════════════════════════════════ # ─── JAVASCRIPT ─────────────────────────────────────────────────────────────── # ═══════════════════════════════════════════════════════════════════════════════ def _js_build_string_array(code: str, key: list[int]) -> tuple[str, str]: """ Extract all string literals into a rotated+XOR-encoded string array. Calls become _0xARR[_0xROT(index)] style. """ strings_found = [] def collect(m): quote = m.group(1) s = m.group(2) if len(s) < 2: return m.group(0) strings_found.append(s) idx = len(strings_found) - 1 return f"__STR_PLACEHOLDER_{idx}__" transformed = re.sub(r'(["\'])([^"\'\\ ]{2,})\1', collect, code) if not strings_found: return code, "" # XOR-encrypt each string arr_name = _rand_hex_name(8) rot_name = _rand_hex_name(8) dec_name = _rand_hex_name(8) key_name = _rand_hex_name(6) rot_offset = random.randint(50, 300) def xor_enc_str(s): enc = _xor_bytes(s.encode('utf-8', errors='replace'), key) return _b64(enc) encrypted_strs = [xor_enc_str(s) for s in strings_found] arr_literal = "[" + ",".join(f"'{e}'" for e in encrypted_strs) + "]" key_repr = "[" + ",".join(str(k) for k in key) + "]" # Rotate the array so index lookups aren't trivial setup = ( f"var {key_name}={key_repr};\n" f"var {arr_name}={arr_literal};\n" f"(function(_a,_r){{\n" f" var _s=function(){{\n" f" while(true){{\n" f" try{{\n" f" var _n=-parseInt(_a[0])/1+parseInt(_a[1])/2;\n" f" if(_n===_r)break;else _a.push(_a.shift());\n" f" }}catch(_e){{_a.push(_a.shift());}}\n" f" }}\n" f" }};\n" f" _s();\n" f"}})({arr_name},{rot_offset});\n" f"function {dec_name}(i){{\n" f" var _e=atob({arr_name}[i]);\n" f" var _k={key_name};\n" f" var _r='';\n" f" for(var _i=0;_i<_e.length;_i++){{\n" f" _r+=String.fromCharCode(_e.charCodeAt(_i)^_k[_i%_k.length]);\n" f" }}\n" f" return _r;\n" f"}}\n" ) # Replace placeholders for idx in range(len(strings_found)): transformed = transformed.replace(f"__STR_PLACEHOLDER_{idx}__", f"{dec_name}({idx})") return transformed, setup def _js_rename_vars(code: str) -> str: idents = set(re.findall(r'\b(?:var|let|const)\s+([A-Za-z_$][A-Za-z0-9_$]*)\b', code)) idents |= set(re.findall(r'function\s+([A-Za-z_][A-Za-z0-9_]*)\s*\(', code)) js_builtins = { 'undefined','null','true','false','NaN','Infinity','window','document', 'console','Math','JSON','Array','Object','String','Number','Boolean', 'Function','Promise','Set','Map','Symbol','Error','Date','RegExp', 'parseInt','parseFloat','isNaN','isFinite','decodeURI','encodeURI', 'setTimeout','setInterval','clearTimeout','clearInterval', 'require','module','exports','process','Buffer','__dirname', 'atob','btoa','eval','arguments', } idents -= js_builtins mapping = {name: _rand_hex_name(8) for name in idents} for old, new in mapping.items(): code = re.sub(rf'\b{re.escape(old)}\b', new, code) return code def _js_anti_debug() -> str: trap_fn = _rand_hex_name(8) interval_var = _rand_hex_name(6) return ( f"(function(){{\n" f" function {trap_fn}(){{\n" f" var _s=new Date();\n" f" debugger;\n" f" if(new Date()-_s>100){{\n" f" (function(){{while(true){{debugger;}}}})();\n" f" }}\n" f" }}\n" f" var {interval_var}=setInterval({trap_fn},500);\n" f"}})();\n" ) def _js_anti_vm() -> str: check_fn = _rand_hex_name(8) return ( f"(function(){{\n" f" function {check_fn}(){{\n" f" if(typeof process!=='undefined'&&process.versions&&process.versions.node){{\n" f" if(process.env.__SANDBOX__||process.env.CUCKOO||process.env.ANALYSIS){{\n" f" process.exit(0);\n" f" }}\n" f" }}\n" f" if(typeof window!=='undefined'){{\n" f" var _w=window.outerWidth,_h=window.outerHeight;\n" f" if(_w===0&&_h===0){{throw new Error('');}}\n" f" }}\n" f" }}\n" f" {check_fn}();\n" f"}})();\n" ) def _js_self_defend(code: str) -> str: """Wrap code in a self-defending IIFE that detects toString tampering.""" fn_name = _rand_hex_name(8) wrapper_fn = _rand_hex_name(8) return ( f"var {fn_name}=function(){{}};\n" f"(function(){{\n" f" var _expected='{hashlib.md5(code.encode()).hexdigest()}';\n" f" var _integrity=true;\n" f" try{{\n" f" var _t=Function.prototype.toString;\n" f" if(/\\{{\\s*\\[native code\\]\\s*\\}}/.test(\n" f" _t.call(eval))){{_integrity=true;}}\n" f" else{{_integrity=false;}}\n" f" }}catch(_e){{_integrity=false;}}\n" f" if(!_integrity){{while(true){{}}}}\n" f"}})();\n" + code ) def _js_eval_wrap(code: str) -> str: """Wrap entire code in eval(atob(...)) for an additional opaque layer.""" b64 = _b64(code.encode('utf-8')) return f"eval(atob('{b64}'));" def obfuscate_js(code: str, levels: list[str]) -> str: code = re.sub(r'//[^\n]*', '', code) code = re.sub(r'/\*[\s\S]*?\*/', '', code) code = re.sub(r'\n{3,}', '\n\n', code).strip() prefix_parts = [] key = _rand_key(20) if "Anti-VM" in levels: prefix_parts.append(_js_anti_vm()) if "Anti-Deobfuscation" in levels: prefix_parts.append(_js_anti_debug()) str_setup = "" if "String Encryption" in levels or "Advanced" in levels: code, str_setup = _js_build_string_array(code, key) if "Basic" in levels or "Advanced" in levels: code = _js_rename_vars(code) full_code = "\n".join(prefix_parts) + "\n" + str_setup + "\n" + code if "Control Flow" in levels or "Advanced" in levels: full_code = _js_self_defend(full_code) if "Advanced" in levels or "String Encryption" in levels: full_code = _js_eval_wrap(full_code) return full_code # ═══════════════════════════════════════════════════════════════════════════════ # ─── GENERIC ────────────────────────────────────────────────────────────────── # ═══════════════════════════════════════════════════════════════════════════════ def obfuscate_generic(code: str, levels: list[str]) -> str: raw = code.encode('utf-8') key = _rand_key(16) xored = _xor_bytes(raw, key) compressed = zlib.compress(xored, level=9) b64 = _b64(compressed) key_repr = str(key) return ( f"# Obfuscated payload — do not edit\n" f"# Key: {key_repr}\n" f"# Decompress -> XOR decode with key to retrieve original\n" f"# Payload (zlib+base64): {b64}\n" ) # ─── Dispatcher ─────────────────────────────────────────────────────────────── def obfuscate(code: str, extension: str, levels: list[str]) -> str: dispatch = { ".lua": obfuscate_lua, ".py": obfuscate_python, ".js": obfuscate_js, } fn = dispatch.get(extension, obfuscate_generic) return fn(code, levels) # ─── Lua ────────────────────────────────────────────────────────────────────── def _lua_encode_strings(code: str) -> str: """Replace string literals with char-code concatenation.""" def encode(m): s = m.group(1) encoded = "..".join(f"string.char({ord(c)})" for c in s) return f"({encoded})" return re.sub(r'"([^"\n]*)"', encode, code) def _lua_rename_vars(code: str) -> str: idents = set(re.findall(r'\blocal\s+([A-Za-z_][A-Za-z0-9_]*)\b', code)) mapping = {name: _random_name() for name in idents} for old, new in mapping.items(): code = re.sub(rf'\b{re.escape(old)}\b', new, code) return code def _lua_inject_dead_code(code: str) -> str: dead = f"local {_random_name()} = {random.randint(1, 9999)}\n" lines = code.splitlines() pos = random.randint(0, max(0, len(lines) - 1)) lines.insert(pos, dead) return "\n".join(lines) def _lua_control_flow(code: str) -> str: rand_var = _random_name() wrapper = f"local {rand_var} = true\nif {rand_var} then\n" indented = "\n".join(" " + line for line in code.splitlines()) return wrapper + indented + "\nend" def obfuscate_lua(code: str, levels: list[str]) -> str: code = re.sub(r'--[^\n]*', '', code) if "String Encryption" in levels or "Advanced" in levels: code = _lua_encode_strings(code) if "Basic" in levels or "Advanced" in levels: code = _lua_rename_vars(code) if "Anti-Deobfuscation" in levels or "Advanced" in levels: for _ in range(3): code = _lua_inject_dead_code(code) if "Control Flow" in levels or "Advanced" in levels: code = _lua_control_flow(code) if "Anti-VM" in levels: guard = ( f"if type(debug) ~= 'table' or type(debug.getinfo) ~= 'function' then\n" f" error('Environment check failed', 2)\nend\n" ) code = guard + code return code # ─── Python ─────────────────────────────────────────────────────────────────── def _python_encode_strings(code: str) -> str: def encode(m): quote = m.group(1) s = m.group(2) b64 = base64.b64encode(s.encode()).decode() return f'__import__("base64").b64decode("{b64}").decode()' return re.sub(r'(["\'])([^"\'\\]{3,})\1', encode, code) def _python_rename_vars(code: str) -> str: idents = set(re.findall(r'(? str: dead = f"{_random_name()} = {random.randint(1, 9999)}" lines = code.splitlines() pos = random.randint(0, max(0, len(lines) - 1)) lines.insert(pos, dead) return "\n".join(lines) def _python_control_flow(code: str) -> str: rand_var = _random_name() indented = "\n".join(" " + line for line in code.splitlines()) return f"{rand_var} = True\nif {rand_var}:\n{indented}\n" def obfuscate_python(code: str, levels: list[str]) -> str: code = re.sub(r'#[^\n]*', '', code) code = re.sub(r'"""[\s\S]*?"""', '', code) code = re.sub(r"'''[\s\S]*?'''", '', code) if "String Encryption" in levels or "Advanced" in levels: code = _python_encode_strings(code) if "Basic" in levels or "Advanced" in levels: code = _python_rename_vars(code) if "Anti-Deobfuscation" in levels or "Advanced" in levels: for _ in range(3): code = _python_inject_dead_code(code) if "Control Flow" in levels or "Advanced" in levels: code = _python_control_flow(code) if "Anti-VM" in levels: guard = ( "import platform as _p\n" "if _p.system() in ('', 'Java'):\n" " raise SystemExit('Environment check failed')\n" ) code = guard + code return code # ─── JavaScript ─────────────────────────────────────────────────────────────── def _js_encode_strings(code: str) -> str: def encode(m): quote = m.group(1) s = m.group(2) encoded = "+".join(f"String.fromCharCode({ord(c)})" for c in s) return f"({encoded})" return re.sub(r'(["\'])([^"\'\\]{2,})\1', encode, code) def _js_rename_vars(code: str) -> str: idents = set(re.findall(r'\b(?:var|let|const)\s+([A-Za-z_$][A-Za-z0-9_$]*)\b', code)) mapping = {name: _random_name() for name in idents} for old, new in mapping.items(): code = re.sub(rf'\b{re.escape(old)}\b', new, code) return code def _js_inject_dead_code(code: str) -> str: dead = f"var {_random_name()} = {random.randint(1, 9999)};" lines = code.splitlines() pos = random.randint(0, max(0, len(lines) - 1)) lines.insert(pos, dead) return "\n".join(lines) def _js_control_flow(code: str) -> str: rand_var = _random_name() return f"var {rand_var}=true;if({rand_var}){{\n{code}\n}}" def obfuscate_js(code: str, levels: list[str]) -> str: code = re.sub(r'//[^\n]*', '', code) code = re.sub(r'/\*[\s\S]*?\*/', '', code) if "String Encryption" in levels or "Advanced" in levels: code = _js_encode_strings(code) if "Basic" in levels or "Advanced" in levels: code = _js_rename_vars(code) if "Anti-Deobfuscation" in levels or "Advanced" in levels: for _ in range(3): code = _js_inject_dead_code(code) if "Control Flow" in levels or "Advanced" in levels: code = _js_control_flow(code) if "Anti-VM" in levels: guard = ( "if(typeof process!=='undefined'&&process.env&&process.env.__ANTI_VM__){" "throw new Error('VM detected');}\n" ) code = guard + code return code # ─── Generic (txt/unknown) ──────────────────────────────────────────────────── def _generic_encode(code: str) -> str: b64 = base64.b64encode(code.encode()).decode() return f"# Encoded payload\n# Base64: {b64}\n" def obfuscate_generic(code: str, levels: list[str]) -> str: if any(l in levels for l in ["String Encryption", "Advanced", "Anti-Deobfuscation"]): return _generic_encode(code) lines = code.splitlines() random.shuffle(lines) return "\n".join(lines) # ─── Dispatcher ─────────────────────────────────────────────────────────────── def obfuscate(code: str, extension: str, levels: list[str]) -> str: dispatch = { ".lua": obfuscate_lua, ".py": obfuscate_python, ".js": obfuscate_js, } fn = dispatch.get(extension, obfuscate_generic) return fn(code, levels)