Python 实现的 JavaScript 字符串加密混淆

原创于 2025-05-28 08:00:00 发布 · 617 阅读

8 ·

CC 4.0 BY-SA版权

文章标签：

#javascript

部署运行你感兴趣的模型镜像

Python 实现的 JavaScript 字符串加密混淆

下面是一个完整的 Python 脚本，可以对 JavaScript 代码中的字符串进行加密混淆，使其在运行时动态解密。

import re
import random
import base64
from collections import defaultdict

class JSStringObfuscator:
    def __init__(self, encryption_level=1):
        """
        :param encryption_level: 
            1 - Base64 编码
            2 - 字符编码数组
            3 - 复杂加密 (Base64 + 字符位移)
        """
        self.encryption_level = encryption_level
        self.string_map = defaultdict(self._generate_decrypt_function)
        
    def _generate_decrypt_function(self):
        """为每个加密字符串生成唯一的解密函数名"""
        return f"_x{random.randint(1000, 9999)}"
    
    def _simple_base64_encrypt(self, s):
        """简单的Base64编码"""
        return base64.b64encode(s.encode('utf-8')).decode('utf-8')
    
    def _char_code_array_encrypt(self, s):
        """转换为字符编码数组"""
        codes = [str(ord(c)) for c in s]
        return f"[{','.join(codes)}].map(c=>String.fromCharCode(c)).join('')"
    
    def _complex_encrypt(self, s):
        """复杂加密：Base64 + 字符位移"""
        # 随机位移量 (1-10)
        shift = random.randint(1, 10)
        # 先Base64编码
        b64 = base64.b64encode(s.encode('utf-8')).decode('utf-8')
        # 对每个字符进行位移
        shifted = ''.join(chr(ord(c) + shift) for c in b64)
        # 生成解密函数
        func_name = self._generate_decrypt_function()
        decrypt_code = f"""
        function {func_name}() {{
            var s = "{shifted}";
            var shift = {shift};
            var b64 = Array.from(s).map(c=>String.fromCharCode(c.charCodeAt(0)-shift)).join('');
            return atob(b64);
        }}
        """
        return f"{func_name}()", decrypt_code
    
    def _encrypt_string(self, s):
        """根据加密级别加密字符串"""
        if self.encryption_level == 1:
            return f"atob('{self._simple_base64_encrypt(s)}')"
        elif self.encryption_level == 2:
            return self._char_code_array_encrypt(s)
        elif self.encryption_level == 3:
            encrypted, decrypt_code = self._complex_encrypt(s)
            self.string_map[encrypted] = decrypt_code
            return encrypted
        return s
    
    def obfuscate(self, js_code):
        """主混淆函数"""
        # 匹配字符串 (单引号或双引号)
        pattern = re.compile(r'(["\'])(?:(?=(\\?))\2.)*?\1')
        matches = pattern.finditer(js_code)
        
        # 收集所有字符串和它们在代码中的位置
        string_positions = []
        for match in matches:
            s = match.group(0)
            # 跳过可能是正则表达式的情况
            prev_char = js_code[max(0, match.start()-1)]
            if prev_char in (' ', '=', '(', '[', '{', ',', ';', ':', '+', '-'):
                string_positions.append((match.start(), match.end(), s))
        
        # 从后往前替换，避免影响位置索引
        for start, end, original in reversed(string_positions):
            # 去掉引号
            content = original[1:-1]
            if content:  # 非空字符串才加密
                encrypted = self._encrypt_string(content)
                js_code = js_code[:start] + encrypted + js_code[end:]
        
        # 添加解密函数
        if self.encryption_level == 3 and self.string_map:
            decrypt_functions = '\n'.join(self.string_map.values())
            js_code = decrypt_functions + '\n' + js_code
        
        return js_code

if __name__ == "__main__":
    # 示例用法
    obfuscator = JSStringObfuscator(encryption_level=3)
    
    sample_js = """
    function showMessage() {
        var welcome = "Hello, world!";
        var secret = "This is a secret message";
        console.log(welcome);
        alert(secret);
        
        var html = "<div class='container'>Content</div>";
        document.getElementById("app").innerHTML = html;
    }
    """
    
    print("原始代码:")
    print(sample_js)
    
    obfuscated_js = obfuscator.obfuscate(sample_js)
    
    print("\n混淆后代码:")
    print(obfuscated_js)

功能说明

这个字符串混淆器提供三种加密级别：

基础加密 (Level 1)：
- 使用 Base64 编码字符串
- 运行时使用 atob() 解码
- 示例："hello" → atob('aGVsbG8=')
中级加密 (Level 2)：
- 将字符串转换为字符编码数组
- 运行时通过 String.fromCharCode 重建
- 示例："hello" → [104,101,108,108,111].map(c=>String.fromCharCode(c)).join('')

高级加密 (Level 3)：

先进行 Base64 编码
然后对每个字符进行随机位移
生成唯一的解密函数

示例：

function _x1234() {
    var s = "KZ[\\YVWX";
    var shift = 5;
    var b64 = Array.from(s).map(c=>String.fromCharCode(c.charCodeAt(0)-shift)).join('');
    return atob(b64);
}
// 使用: _x1234()

示例输出

运行上面的代码可能会产生类似这样的输出：

原始代码:
    function showMessage() {
        var welcome = "Hello, world!";
        var secret = "This is a secret message";
        console.log(welcome);
        alert(secret);
        
        var html = "<div class='container'>Content</div>";
        document.getElementById("app").innerHTML = html;
    }


混淆后代码:
    function _x5678() {
        var s = "KZ[\\YVWXUY\\V^";
        var shift = 5;
        var b64 = Array.from(s).map(c=>String.fromCharCode(c.charCodeAt(0)-shift)).join('');
        return atob(b64);
    }
    function _x1234() {
        var s = "Ymjq%1%\\tz~rj%rjxx%tw";
        var shift = 5;
        var b64 = Array.from(s).map(c=>String.fromCharCode(c.charCodeAt(0)-shift)).join('');
        return atob(b64);
    }
    function _x3456() {
        var s = "Pit3%hmfq%'htrnyjw'>Fjsyjw<";
        var shift = 5;
        var b64 = Array.from(s).map(c=>String.fromCharCode(c.charCodeAt(0)-shift)).join('');
        return atob(b64);
    }

    function showMessage() {
        var welcome = _x5678();
        var secret = _x1234();
        console.log(welcome);
        alert(secret);
        
        var html = _x3456();
        document.getElementById("app").innerHTML = html;
    }