526互联

js逆向

发布时间 2024-01-09 15:06:29作者: ErBing

一、hook

相当于在浏览器注入JS

1.1 JSON.parse、JSON.stringify

把JSON.parse赋值到parse_变量中，这时候就可以调用parse_就相当于执行了JSON.parse，然后重写该方法，让它遇到JSON.parse的时候就debugger端住，然后返回原来的逻辑。

arg是JSON.arse方法里传入的参数 也就是密文

(function() {
    var parse_ = JSON.parse;
    JSON.parse = function(arg) {
        console.log("您猜怎么着？断住了！ ——> ",arg);
        debugger;
        return parse_(arg);  // 不改变原来的执行逻辑 
    }})();

1.2 xhr请求

定义变量open = window.XMLHttpRequest.prototype.open;

保留原始 XMLHttpRequest.open 方法 用于返回原来的逻辑。

然后重写XMLHttpRequest.open方法，判断如果t参数的字符串在url就下debugger，否则返回原来的逻辑。

 (function () {
    var open = window.XMLHttpRequest.prototype.open;
    window.XMLHttpRequest.prototype.open = function (method, url, async) {
        if (url.indexOf("参数名称") != -1) {
            debugger;
        }
        return open.apply(this, arguments);
    };
})();

1.3 XMLHttpRequest（header参数）

保留原始请求，判断当setRequestHeader的时候 变量名是enc的时候 下debugger 否则 执行原来的逻辑

(function (){
    var sh = window.XMLHttpRequest.prototype.setRequestHeader;
window.XMLHttpRequest.prototype.setRequestHeader=function(key,value){
        if(key == 'enc'){
            debugger;
        }
        return sh.apply(this,arguments);
    };

1.4 cookie

v 修改为你要端点的cookie包含的关键字

(function () {
  var cookieTemp = '';
  Object.defineProperty(document, 'cookie', {
    set: function (val) {
      if (val.indexOf('v') != -1) {
        debugger;
      }
      console.log('Hook捕获到cookie设置->', val);
      cookieTemp = val;
      return val;
    },
    get: function () {
      return cookieTemp;
    },
  });
})();

1.5 方法置空

debugger的方法置空或者设置一律不在此处暂停

function deg(){
   debugger;
}
//debugger的方法deg 直接控制台输入
deg = function(){}

有时候的网页debugger通过定时器运行的这个时候可以这么干

setInterval = function(){}   //置空

1.6 油猴

如果我们在控制台hook，刷新网页就会失效。所以可以通过相关的插件让这个hook的代码一直生效。

其他用户脚本：https://greasyfork.org/zh-CN/scripts?q=

二、base64

base64用于直接编码或混合加解密，用于图片与编码的转换。

浏览器中window对象自带了base64编解码的方法

window.btoa('123')  // 编码
window.atob('MTIz') // 解码

nodejs

// var a = "123"
// b = new Buffer(a).toString("base64");   新版本弃用了 会出提示
// console.log(b)

// 编码
const a = "123";
const b = Buffer.from(a, "utf-8").toString("base64");
console.log(b);
// 解码
const c = Buffer.from(b, "base64").toString("utf-8");
console.log(c);

pyhton

import base64
print(base64.b64encode('123'.encode()))
print(base64.b64decode('MTIz'.encode()))

 三、哈希算法

哈希算法是一种将任意长度的输入数据映射为固定长度的输出数据的算法。常见的哈希算法包括MD5、SHA-1、SHA-256、HMAC等，每种算法具有不同的哈希值长度和安全性级别。

3.1 md5

长度：32位16进制数（0-9 a-f 字母数字混合），搜索关键字：md5，.md5，md5(，.md5(等

js

var CryptoJS = require('crypto-js')

var text = "123456"
md5Text = CryptoJS.MD5(text).toString()
console.log(md5Text)
//输出： e10adc3949ba59abbe56e057f20f883e

python

import hashlib

def md5():
    md5 = hashlib.md5()
    md5.update('123456'.encode('utf-8'))
    print(md5.hexdigest())

if __name__ == '__main__':
    md5()  # e10adc3949ba59abbe56e057f20f883e

3.2 SHA

SHA（Secure Hash Algorithm）是一系列密码学哈希函数的缩写，用于将任意长度的数据映射为固定长度的哈希值。SHA算法广泛应用于密码学和数据完整性验证等领域。

SHA算法家族包括SHA-0、SHA-1、SHA-2和SHA-3。下面简要介绍其中几种常用的SHA算法：

1. SHA-1：SHA-1是最早的SHA算法，产生160位（20字节）的哈希值。然而，由于SHA-1存在碰撞攻击和安全性弱点，已被广泛认为不再安全，不推荐使用。 

2. SHA-2：SHA-2是SHA算法家族中最常用的一种，包括SHA-224、SHA-256、SHA-384和SHA-512等变体。它们分别产生不同长度的哈希值，分别为224位、256位、384位和512位。SHA-2算法具有较高的安全性，目前被广泛应用于密码学和数据完整性验证等领域。

3. SHA-3：SHA-3是SHA算法家族的最新成员，于2015年发布。SHA-3算法通过Keccak算法构建，与SHA-2算法有所不同。SHA-3算法提供了不同长度的哈希值，包括224位、256位、384位和512位。SHA-3算法在一些特定场景下可能比SHA-2算法更具优势，但在实际应用中仍相对较少见。

以加密123456为例 sha系列加密位数：
"SHA1": "7c4a8d09ca3762af61e59520943dc26494f8941b", # 40位
"SHA256":"8d969eef6ecad3c29a3a629280e686cf0c3f5d5a86aff3ca12020c923adc6c92" # 64位  
"SHA512":"ba3253876aed6bc22d4a6ff53d8406c6ad864195ed144ab5c87621b6c233b548baeae6956df346ec8c17f5ea10f35ee3cbc514797ed7ddd3145464e2a0bab413"   # 128位
"SHA3-512":"808d63ba47fcef6a7c52ec47cb63eb1b747a9d527a77385fc05c8a5ce8007586265d003b4130f6b0c8f3bb2ad89965a5da07289ba5d1e35321e160bea4f766f8" # 128位
"SHA3-384":"b306d3569477576ab9c8a9d69b514df7acc89f4617d98af67fd04530b9937241a8a94f25ab5d114192c82cfedc2ce545" #96位
"SHA3-256":"c888c9ce9e098d5864d3ded6ebcc140a12142263bace3a23a36f9905f12bd64a" # 64位
"SHA3-224":"0811eedf8207e4d497dc45ba964d58ada516bfea1e72efb8721efca8"   # 56位

js

//  引用 crypto-js 加密模块
var CryptoJS = require('crypto-js')

function SHA1Encrypt(text) {
    return CryptoJS.SHA1(text).toString();
}
var text = "123456"
console.log(SHA1Encrypt(text))

python

import hashlib

def sha1test(t):
    sha1 = hashlib.sha1()
    sha1.update(t.encode('utf-8'))
    return sha1.hexdigest()
    
if __name__ == '__main__':
    res = sha1test("123456") 
    print(res)

3.3 HMAC

HMAC（Hash-based Message Authentication Code）是一种基于哈希函数的消息认证码算法。它结合了哈希函数和密钥来提供数据完整性和身份验证的保护。HMAC算法使用一个哈希函数，如SHA-256或SHA-512，来将密钥和数据进行处理。接收方使用相同的密钥和哈希函数对接收到的数据进行处理，并验证生成的认证码是否与接收到的认证码匹配，从而判断数据是否完整和合法。

js

var CryptoJS = require('crypto-js')

function HMACEncrypt() {
    var text = "123456"
    var key = "xxxxxxxxx"       // 密钥文件
    return CryptoJS.HmacMD5(text, key).toString();
    // return CryptoJS.HmacSHA1(text, key).toString();
    // return CryptoJS.HmacSHA256(text, key).toString();
}
console.log(HMACEncrypt())

python

import hmac

def hmac_1():
    message = 'text'.encode()
    key = b'secret'
    md5 = hmac.new(key, message, digestmod='MD5')
    print(md5.hexdigest())

def hmac_2():
    key = 'secret'.encode('utf8')
    sha1 = hmac.new(key, digestmod='sha1')
    sha1.update('I love '.encode('utf8'))
    sha1.update('Python!'.encode('utf8'))
    print(sha1.hexdigest())

if __name__ == '__main__':
    hmac_1() 
    hmac_2()

四、对称加密

对称加密是一种加密方式，使用相同的密钥（也称为秘密密钥）来加密和解密数据。在对称加密中，加密和解密过程使用相同的密钥。对称加密算法包括DES、3DES、AES等。

4.1 DES

key指的是用于加密和解密数据的密钥，也称为DES密钥。

IV是Initialization Vector（初始化向量）的缩写，是在使用分组密码算法进行加密时，为了增强密码强度和安全性而引入的一个参数。

IV是一个固定长度的随机数或伪随机数，通常与明文一起作为输入参数传递给加密算法。IV的作用是在同一个密钥下，每次加密不同的明文时，都能产生不同的密文，从而增加密码的随机性和安全性。

DES算法的模式是指在使用DES算法进行加密和解密时，对数据块进行分组和处理的方式。常见的DES算法模式包括：ECB、CBC、CFB、OFB、CTR。

padding填充算法将明文数据填充到块长度的整数倍。常见的算法包括：填充0算法、PKCS5和PKCS7算法、ISO 10126算法、ANSI X.923算法，一般就是pkcs7。

js

const CryptoJS = require('crypto-js')
var key = CryptoJS.enc.Utf8.parse('dsa213d'),
iv = CryptoJS.enc.Utf8.parse('dsads23d'),
text = CryptoJS.enc.Utf8.parse('text'),

encrypted = CryptoJS.DES.encrypt(text, key, 
        {
            iv: iv,
            mode: CryptoJS.mode.CBC,
            padding: CryptoJS.pad.Pkcs7
        }
        ).toString();

console.log(encrypted)

4.2 AES

目前最常用的加密算法之一，被认为是安全可靠的。密钥长度可以是128位、192位或256位。AES同样有KEY和IV 以及mode和padding

js

const CryptoJS = require('crypto-js')
var key = CryptoJS.enc.Utf8.parse('dsa213d'),
iv = CryptoJS.enc.Utf8.parse('dsads23d'),
text = CryptoJS.enc.Utf8.parse('text'),

encrypted = CryptoJS.AES.encrypt(text, key, 
        {
            iv: iv,
            mode: CryptoJS.mode.CBC,
            padding: CryptoJS.pad.Pkcs7
        }
        ).toString();

console.log(encrypted)

五、非对称加密

非对称加密算法是一种使用不同密钥进行加密和解密的算法。它使用一对密钥，包括公钥（Public Key）和私钥（Private Key）。公钥用于加密数据，私钥用于解密数据。加密后的密文每次都不一样。

5.1 RSA

生成一组密钥对

openssl genpkey -algorithm RSA -out private_key.pem -pkeyopt rsa_keygen_bits:2048
openssl rsa -pubout -in private_key.pem -out public_key.pem

js

// jsencrypt库
window = global;
const JSEncrypt = require('jsencrypt');
var encrypt = new JSEncrypt();
const publicKey = '-----BEGIN PUBLIC KEY-----MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAySXs1EWw8v7yJbE5qJoQyngjrYn4PeL6Uhq4kE7k8lOXToG/zLk9cFciV5mortH1WY2gBMqrEAcM67tX8Ge+37RMktqVfv04G8+XKVoHv3RgFag8imVFLiOv84OhXsaD6ZaE+i5F7H66sv4Y7Kz4e8NwSzY9/PjGCNNzUr3ORohGlGzRSBkDk+C4Afjz/5e0dUF7HpWgLYcSQr5qSSO1sebNoENcEXVFzn2Hh8zximNFdHLuAQgj//I9kItCwYNR5SfTzCJJkPTpv3u3HWGcc2mT1XNV5GBmW4ukk14+kBw7tn1jEvWozBWizq3xlgBczuUx18tDaBsUjmRAwZaWowIDAQAB-----END PUBLIC KEY-----'; // 公钥
const privateKey = '-----BEGIN PRIVATE KEY-----MIIEvgIBADANBgkqhkiG9w0BAQEFAASCBKgwggSkAgEAAoIBAQDJJezURbDy/vIlsTmomhDKeCOtifg94vpSGriQTuTyU5dOgb/MuT1wVyJXmaiu0fVZjaAEyqsQBwzru1fwZ77ftEyS2pV+/Tgbz5cpWge/dGAVqDyKZUUuI6/zg6FexoPploT6LkXsfrqy/hjsrPh7w3BLNj38+MYI03NSvc5GiEaUbNFIGQOT4LgB+PP/l7R1QXselaAthxJCvmpJI7Wx5s2gQ1wRdUXOfYeHzPGKY0V0cu4BCCP/8j2Qi0LBg1HlJ9PMIkmQ9Om/e7cdYZxzaZPVc1XkYGZbi6STXj6QHDu2fWMS9ajMFaLOrfGWAFzO5THXy0NoGxSOZEDBlpajAgMBAAECggEAQZSK1V5vZZo3apCQgubQKKLoxvCfrdWt1Uz+9ZWzUUptn1vwI5gVbuYJvVPMykqL2omxLT7CbPRPgx/OeQPqGFdZS9vWN9PpEjApUYMX2ZTgqs7yBhEkb/mUqSk2WIcShPrdGhAyHfvndOohSDDQxtEecHcb2LlnH4OJKuXVNestrFND9xQWJoE43QRkgR6abMuBreMr/kgLIFqXns8N1eYrPUGnKHOz0Xvd0wOm7+fUu2PTrvx9iAXvIXZGdNH+Vw7BNzTuoHQt2re8fVa8ZSEl+zZP8nh5k42Cg1PEiJAgbr83KptvB+5orNhvFZ/kWdM05jKngKFGKndU8dhK0QKBgQD5jZfU34W9zyJ11rXEfIJwK8AtuaBOnoUKKn3/9Wr/Oevk/ZLRh2uq0Eg+0GF1Lli0N1tq0wlZ6OKNUPPk0FwmRh0vzKwmzk+/uGk8LOq5rOsVURKnrUwezXIvtNy51hU7bCVRTdXR4r2eI1fbSQxuO1KM0VRKC0lfE8zvYHdjOwKBgQDOWDVSjGXr3gfjzZRHhBmlMonEa/shfz2JbQVux3mKbT64VaoaNAbk/GotR/1wpbc+QUQ8qURC9g9NoJXYqca4fow2fb2LitbuEEEuF3jdrEwEO9cyEdZAubvJnQahTDBS7/+yqo4bF24IP6MN8vaRbUZK3NkH6ovTXOJNeK+TuQKBgEJZ7GG0IKor9byhHukkNcY/S7Sco0vkB/mA/MleZll//AGBjlTZjb337Q2OeCsg7ILWKR9JBzZ5nir2uDJBWA7xG3eHEsqqljeif5B5XNuLZ2HekXg1soSKGW8nxnw+uJx5D58Dc/N/Nu1h9k0eqghxC2zXh3K8d4CpEhcfbf7bAoGBAIMJy1sP5A3k45fMTxUXk/2v2YOOm13LYzXpsSCHtuyssb74T9zyG0rB7V+yLwWhh3wWkJIBYGMxxcgjaeW884DohHx6X6vFUPbABdSSfWQw7dlmcyPN5gUWrmW7vaEjNDEHTpeU7kfQGkVMvGy4VdNG1PPnyj/XuFJS0zglo0KpAoGBAMjYqgyFWhPGMkvrE2h0V2godO6sEICUkqgY+8l11P0GbKTB8KVx2rj9yCJTfaJZbXaUZ5ODi8EMji/ck8OKgRWUtcwS2XDuMKxZJYvEbazQAqmg9PNm2zL4r8tDNKnzrGzp68gKy6Hh0Kxp1UeNFN3aMqARQsjQkQ0sWUp2tLEY-----END PRIVATE KEY-----'; // 私钥
encrypt.setPublicKey(publicKey)
var encrypted = encrypt.encrypt('123456');
console.log(encrypted)

encrypt.setPrivateKey(privateKey)
var decrypted = encrypt.decrypt(encrypted);
console.log(decrypted)
// node-forge库
const publicKey = '-----BEGIN PUBLIC KEY-----MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAySXs1EWw8v7yJbE5qJoQyngjrYn4PeL6Uhq4kE7k8lOXToG/zLk9cFciV5mortH1WY2gBMqrEAcM67tX8Ge+37RMktqVfv04G8+XKVoHv3RgFag8imVFLiOv84OhXsaD6ZaE+i5F7H66sv4Y7Kz4e8NwSzY9/PjGCNNzUr3ORohGlGzRSBkDk+C4Afjz/5e0dUF7HpWgLYcSQr5qSSO1sebNoENcEXVFzn2Hh8zximNFdHLuAQgj//I9kItCwYNR5SfTzCJJkPTpv3u3HWGcc2mT1XNV5GBmW4ukk14+kBw7tn1jEvWozBWizq3xlgBczuUx18tDaBsUjmRAwZaWowIDAQAB-----END PUBLIC KEY-----'; // 公钥
const privateKey = '-----BEGIN PRIVATE KEY-----MIIEvgIBADANBgkqhkiG9w0BAQEFAASCBKgwggSkAgEAAoIBAQDJJezURbDy/vIlsTmomhDKeCOtifg94vpSGriQTuTyU5dOgb/MuT1wVyJXmaiu0fVZjaAEyqsQBwzru1fwZ77ftEyS2pV+/Tgbz5cpWge/dGAVqDyKZUUuI6/zg6FexoPploT6LkXsfrqy/hjsrPh7w3BLNj38+MYI03NSvc5GiEaUbNFIGQOT4LgB+PP/l7R1QXselaAthxJCvmpJI7Wx5s2gQ1wRdUXOfYeHzPGKY0V0cu4BCCP/8j2Qi0LBg1HlJ9PMIkmQ9Om/e7cdYZxzaZPVc1XkYGZbi6STXj6QHDu2fWMS9ajMFaLOrfGWAFzO5THXy0NoGxSOZEDBlpajAgMBAAECggEAQZSK1V5vZZo3apCQgubQKKLoxvCfrdWt1Uz+9ZWzUUptn1vwI5gVbuYJvVPMykqL2omxLT7CbPRPgx/OeQPqGFdZS9vWN9PpEjApUYMX2ZTgqs7yBhEkb/mUqSk2WIcShPrdGhAyHfvndOohSDDQxtEecHcb2LlnH4OJKuXVNestrFND9xQWJoE43QRkgR6abMuBreMr/kgLIFqXns8N1eYrPUGnKHOz0Xvd0wOm7+fUu2PTrvx9iAXvIXZGdNH+Vw7BNzTuoHQt2re8fVa8ZSEl+zZP8nh5k42Cg1PEiJAgbr83KptvB+5orNhvFZ/kWdM05jKngKFGKndU8dhK0QKBgQD5jZfU34W9zyJ11rXEfIJwK8AtuaBOnoUKKn3/9Wr/Oevk/ZLRh2uq0Eg+0GF1Lli0N1tq0wlZ6OKNUPPk0FwmRh0vzKwmzk+/uGk8LOq5rOsVURKnrUwezXIvtNy51hU7bCVRTdXR4r2eI1fbSQxuO1KM0VRKC0lfE8zvYHdjOwKBgQDOWDVSjGXr3gfjzZRHhBmlMonEa/shfz2JbQVux3mKbT64VaoaNAbk/GotR/1wpbc+QUQ8qURC9g9NoJXYqca4fow2fb2LitbuEEEuF3jdrEwEO9cyEdZAubvJnQahTDBS7/+yqo4bF24IP6MN8vaRbUZK3NkH6ovTXOJNeK+TuQKBgEJZ7GG0IKor9byhHukkNcY/S7Sco0vkB/mA/MleZll//AGBjlTZjb337Q2OeCsg7ILWKR9JBzZ5nir2uDJBWA7xG3eHEsqqljeif5B5XNuLZ2HekXg1soSKGW8nxnw+uJx5D58Dc/N/Nu1h9k0eqghxC2zXh3K8d4CpEhcfbf7bAoGBAIMJy1sP5A3k45fMTxUXk/2v2YOOm13LYzXpsSCHtuyssb74T9zyG0rB7V+yLwWhh3wWkJIBYGMxxcgjaeW884DohHx6X6vFUPbABdSSfWQw7dlmcyPN5gUWrmW7vaEjNDEHTpeU7kfQGkVMvGy4VdNG1PPnyj/XuFJS0zglo0KpAoGBAMjYqgyFWhPGMkvrE2h0V2godO6sEICUkqgY+8l11P0GbKTB8KVx2rj9yCJTfaJZbXaUZ5ODi8EMji/ck8OKgRWUtcwS2XDuMKxZJYvEbazQAqmg9PNm2zL4r8tDNKnzrGzp68gKy6Hh0Kxp1UeNFN3aMqARQsjQkQ0sWUp2tLEY-----END PRIVATE KEY-----'; // 私钥

const forge = require('node-forge');
const publicKey1 = forge.pki.publicKeyFromPem(publicKey);
var encrypted = publicKey1.encrypt('123456','RSA-OAEP'); // RSA-OAEP 公钥加密算法，不填默认RSAES-PKCS1-V1_5
var encryptedBase64 = forge.util.encode64(encrypted);
console.log(encryptedBase64)

const privateKey1 = forge.pki.privateKeyFromPem(privateKey);
var encrypted = forge.util.decode64(encryptedBase64);
var decrypted = privateKey1.decrypt(encrypted,'RSA-OAEP');
console.log(decrypted)
// crypto库
const crypto = require('crypto');
const { publicKey, privateKey } = crypto.generateKeyPairSync('rsa', {
  modulusLength: 2048,
});
const encryptedData = crypto.publicEncrypt(publicKey, Buffer.from('hello world'));
console.log(encryptedData.toString());

const decryptedData = crypto.privateDecrypt(privateKey, encryptedData);
console.log(decryptedData.toString());

六、国密算法

SM2非对称（基于椭圆曲线 ECC）加密算法，相比 RSA 处理速度快，消耗更少，代替RSA。

SM3散列（hash）函数算法用于完整性校验安全性及效率与 SHA-256 相当，压缩函数更复杂，代替哈希。

SM4对称（分组）加密算法用于数据加密和局域网产品分组长度、密钥长度均为 128 比特，计算轮数多，代替AES。

6.1 SM2

const sm = require('sm-crypto').sm2;
// 待加密的明文数据
const plaintext = 'babababababababababa';
// 生成密钥对
const keypair = sm.generateKeyPairHex();
// 获取公钥和私钥
const publicKey = keypair.publicKey;
const privateKey = keypair.privateKey;
// 加密
const ciphertext = sm.doEncrypt(plaintext, publicKey);
console.log('加密后的密文：', ciphertext);
// 解密
const decryptedText = sm.doDecrypt(ciphertext, privateKey);
console.log('解密后的明文：', decryptedText);

6.2 SM3

const sm3 = require('sm-crypto').sm3;
var data = "333333333333333333"
var res = sm3(data)
console.log(res)

6.3 SM4

// sm-crypto库
const sm4 = require('sm-crypto').sm4;
const key = '0123456789abcdef0123456789abcdef';
var data = '444444444safdsafdsafdsafs4dsadsada44444';
const ciphertext = sm4.encrypt(data,key)
console.log('加密:',ciphertext)
const decryptedText = sm4.decrypt(ciphertext,key)
console.log('解密:',decryptedText)
// gm-crypt库
config = {
    "key": "a85ec9f77459825e",
    "mode": "ecb",
    "cipherType": "base64"
}
const sm4 = require("gm-crypt").sm4;
var encrypted = new sm4(config).encrypt('1234567890');
console.log(encrypted)
var decrypted = new sm4(config).decrypt(encrypted);
console.log(decrypted)

七、webpack

 webpack是一个基于模块化打包构建工具，可以把开发中的资源数据模块化，用过loader加载器和plugins插件对资源进行处理，打包为符合正常的前端资源，所有资源都是JS渲染出来的。

call或apply为执行方法。

// 主要形式
!function(形参) {加载器} ([模块])
!function(形参) {加载器} ({对象})
//加载时数组形式通过下标取值，对象形式通过key取值。

js

var enc;
!function(e) {
    var t = {}; //存放加载器
    // 加载器  所有的模块都是从这个函数加载 执行
    function n(r) {
        if (t[r])
            return t[r].exports;
        var o = t[r] = {
            i: r,
            l: !1, // 标记当前模块是否被加载
            exports: {} // 导入的模块存到空对象中
        };
        // 执行函数中的方法 e是接受的列表 t是调用下标 call方法是执行
        return e[r].call(o.exports, o, o.exports, n),
            o.l = !0,
            o.exports
    }
    jzq = n // 导出加载器
}
    ({
        '12': function () {
            console.log('模块1');
            a = function(e) {
                return Buffer.from(e, "utf-8").toString("base64")
            }
            enc = a // 导出里面的加密方法，供后面自己调用
        },

        '34':function () {
            console.log('模块2')
        },
    })
    
jzq('12') // 加载模块12
password = enc('123456')
console.log(password)

八、js混淆

 

九、方法总结

9.1