ErBing

往事已经定格，未来还要继续。
  博客园  :: 首页  :: 新随笔  :: 联系 :: 订阅 订阅  :: 管理
js逆向

一、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

1.4.1 hook

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.4.2 全局搜索

全局搜索：document.cookie  ，没有就搜document或者document[

1.5 过无限debugger反调试

1.5.1 方法含有deugger

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

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

1.5.2 定时器中debugger

setInterval，他有两个必须的参数，第一个是要执行的方法，第二个是时间参数，即周期性调用方法的时间间隔，以毫秒为单位。返回 ID 值。

// 先保留原定时器
var setInterval_ = setInterval
setInterval = function (func, time){
    // 如果function中没有debugger,返回原方法
    if(func.toString().indexof('debugger') == -1) {
      return setInterval_(func, time)
    }
}
// 停止 setInterval() 方法执行的函数代码
for(var i=0; i<99999; i++) {
  window.clearInterval(i);
}

或者直接粗暴的把setInterval方法置空

setInterval = function(){}   //置空

1.5.3 构造器中的debugger

构造方法，一般在对象创建或者实例化时候被调用，它的基本语法是：constructor([arguments]) { ... }，如果 debugger 是 constructor 的 arguments 参数

// 先保留原 constructor
Function.prototype.constructor_ = Function.prototype.constructor;
Function.prototype.constructor = function (a) {
    // 如果参数为 debugger，就返回空方法
    if(a == "debugger") {
        return function (){};
    }
    // 如果参数不为 debugger，还是返回原方法
    return Function.prototype.constructor_(a);
};

通用hook

(function() {
    var _constructor = unsafeWindow.Function.prototype.constructor;
    // Hook Function.prototype.constructor
    unsafeWindow.Function.prototype.constructor = function() {
        var fnContent = arguments[0];
        if (fnContent) {
            if (fnContent.includes('debugger')) { // An anti-debugger is attempting to stop debugging
                var caller = Function.prototype.constructor.caller; // Non-standard hack to get the function caller
                var callerContent = caller.toString();
                if (callerContent.includes(/\bdebugger\b/gi)) { // Eliminate all debugger statements from the caller, if any
                    callerContent = callerContent.replace(/\bdebugger\b/gi, ''); // Remove all debugger expressions
                    eval('caller = ' + callerContent); // Replace the function
                }
                return (function () {});
            }
        }
        // Execute the normal function constructor if nothing unusual is going on
        return _constructor.apply(this, arguments);
    };
})();

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渲染出来的。

// 主要形式
!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存储所有模块 r是调用下标 call或apply方法是执行
        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)

WebPack是链式调用模块，缺少其他模块时，在call之前打印r，即模块名或下标，再加上响应的模块代码。e['12'].toString()可以在控制台将模块代码打印出来。

半自动扣webpack
我们可以在解析器中hook调用的代码，储存调用代码，然后打印出来。
在加密函数(方法)和加密函数(方法)后打上两个断点（避免打印出其他地方调用的），断点在加密函数(方法)断住后，追入到加载器函数，然后在加载器后面下断点(类似 return e[n].call(r.exports, r, r.exports, d) )，跳转到加载器后面的断点，在控制台输入HooK函数(根据不同的加载器函数改变HooK函数代码)，取消加载器后面的断点，跳转到加密函数(方法)后的断点，在控制台输入window._wbpk后得到所有与加密函数有关的模块代码。
//hook函数为：
//  加载器函数n，加载器函数传入的参数r(也就是模块名称)
//  对象或者数组e(储存所有的模块)

window.web = n;
window._wbpk =  r.toString()+":"+(e[r]+"")+ ",";
n = function(r){
    window._wbpk = window._wbpk + r.toString()+":"+(e[r]+"")+ ",";
    return window.web(r);
}

八、js混淆

 

九、方法总结

9.1 

十、python调用js

execjs会自动使用当前电脑上的运行时环境，建议用nodejs。

# js直接写
import execjs
js = """
function a(m,n) {
  return m+n
}
"""
ctx = execjs.compile(js)
val = ctx.call('a', 1, 2)
print(val)
#加载js文件
import execjs
# 读取外部JS文件内容
with open('jstest.js', 'r') as file:
    js_code = file.read()
# 编译并执行包含外部JS文件的代码,cwd是node_modules路径
ctx = execjs.compile(js_code, cwd='/Users/shaoxingqian/work/js/node_modules')
#args方法所需要的参数，可多个
result = ctx.call("secretMethod", '18611627457')
print(result)

 

posted on 2024-01-09 14:56  ErBing  阅读(339)  评论(0)  编辑  收藏  举报