某 ICP 備案号查詢接口 jsjiami v6 分析

'data': {
    'kw': kw,
    'hostToken': _0x791532['IIPmq'](generateHostKey, kw),
    'permitToken': _0x791532[_0x404f('‫1df', '7Gn4')](generateWordKey, kw)
}

'data': {
    'kw': kw,
    'hostToken': generateHostKey(kw),
    'permitToken': generateWordKey(kw)
}

const fs = require("fs");
const parse = require("@babel/parser").parse;
const generate = require("@babel/generator").default
const traverse = require("@babel/traverse").default
const types = require("@babel/types")
// 導入混淆代碼并解析爲 AST
const oldCode = fs.readFileSync("generatetoken.js", {encoding: "utf-8"});
const astCode = parse(oldCode);
// 獲取整個 AST 節點的長度
let astCodeLength = astCode.program.body.length
// 獲取解密函數的名字 也就是 _0x530e
let decryptFunctionName = astCode.program.body[3].id.name
// 分割加密函數和解密函數，即 body 的前四部分和後面剩餘部分
let decryptFunction = astCode.program.body.slice(0, 4)
let encryptFunction = astCode.program.body.slice(4, astCodeLength)
// 獲取加密函數和解密函數的方法多種多樣，比如可以挨個取值并轉換成 JS 代碼
// 這樣做就不需要将解密函數賦值給整個 AST 節點了
// let decryptFunction = "";
// for(let i=0; i<4; i++){
//     decryptFunction += generate(astCode.program.body[i], {compact: true}).code
// }
// eval(decryptFunction);

// 将解密函數賦值給整個 AST 節點
astCode.program.body = decryptFunction
// 将 AST 節點轉換成 JS 代碼，并 eval 執行一下
decryptFunction = generate(astCode, {compact: true}).code
eval(decryptFunction);
// 測試一下，直接調用 _0x530e 函數可以正确拿到結果
// 輸出 split
// console.log(_0x530e('‮b', 'Zp9G'))

// 将加密函數賦值給整個 AST 節點，此時整個節點就沒有大數組、自執行函數和解密函數了
astCode.program.body = encryptFunction
// 調用解密函數，直接計算出類似以下方法的值并替換
// 混淆代碼：_0x530e('‮b', 'Zp9G')
// 還原後：split
const visitor1 = {
    CallExpression(path){
        if (path.node.callee.name === decryptFunctionName && path.node.arguments.length === 2){
            path.replaceInline(types.stringLiteral(eval(path.toString())))
        }
    }
}
// 遍曆節點
traverse(astCode, visitor1)
// 将 AST 節點轉換成 JS 代碼并寫入到新文件裏
const result = generate(astCode, {concise:true}).code
fs.writeFile("./generatetokenNew.js", result, (err => {console.log(err)}))

let functionName = {
    "_0x3b79c6": {},
    "_0x278b2d": {},
    "_0x4115c4": {},
    "_0xd8ec33": {}
}
// 單獨提取出四個大對象
const visitor2 = {
    VariableDeclarator(path){
        for (let key in functionName){
            if (path.node && path.node.id.name == key) {
                const properties = path.node.init.properties
                for (let i=0; i<properties.length; i++){
                    functionName[key][properties[i].key.value] = properties[i].value
                }
                // 寫入對象後就可以删除該節點了
                path.remove()
            }
        }
    }
}

var _0x3b79c6 = {
    'MuRlB': function (_0x3ca134, _0x50ee94) {
        return _0x3ca134 + _0x50ee94;
    }, 
    'Ucwyj': function (_0x32bfa3, _0x3b191b) {
        return _0x32bfa3(_0x3b191b);
    }, 
    'YrYQW': '#IpValue'
}

// 函數替換，字符串替換：将類似 _0x3b79c6['YrYQW'] 變成 '#IpValue'
const visitor3 = {
    MemberExpression(path) {
        for (let key in functionName){
            if (path.node.object && path.node.object.name == key && path.inList ) {
                path.replaceInline(functionName[key][path.node.property.value])
            }
            if (path.node.object && path.node.object.name == key && path.parent.property && path.parent.property.value == "split") {
                path.replaceInline(functionName[key][path.node.property.value])
            }
        }
    }
}

// 函數替換，二項式計算：将類似 _0x278b2d['CnTaO'](_0x691267["length"], 0x1) 變成 _0x691267["length"] - 0x1
const visitor4 = {
    CallExpression(path){
        for (let key in functionName) {
            if (path.node.callee && path.node.callee.object && path.node.callee.object.name == key) {
                let func = functionName[key][path.node.callee.property.value]
                if (func.body.body[0].argument.type == "BinaryExpression") {
                    let operator = func.body.body[0].argument.operator
                    let left = path.node.arguments[0]
                    let right = path.node.arguments[1]
                    path.replaceInline(types.binaryExpression(operator, left, right))
                }
            }
        }
    }
}

// 函數替換，二項式計算：将類似 _0x278b2d['CnTaO'](_0x691267["length"], 0x1) 變成 _0x691267["length"] - 0x1
// 函數替換，方法調用：将類似 _0x4115c4["PJbSm"](getRandom, 0x64, 0x3e7) 變成 getRandom(0x64, 0x3e7)
const visitor4 = {
    CallExpression(path){
        for (let key in functionName) {
            if (path.node.callee && path.node.callee.object && path.node.callee.object.name == key) {
                let func = functionName[key][path.node.callee.property.value]
                if (func.body.body[0].argument.type == "BinaryExpression") {
                    let operator = func.body.body[0].argument.operator
                    let left = path.node.arguments[0]
                    let right = path.node.arguments[1]
                    path.replaceInline(types.binaryExpression(operator, left, right))
                }
                if (func.body.body[0].argument.type == "CallExpression") {
                    let identifier = path.node.arguments[0]
                    let arguments = path.node.arguments.slice(1)
                    path.replaceInline(types.callExpression(identifier, arguments))
                }
            }
        }
    }
}

// switch-case 反控制流平坦化
const visitor5 = {
    WhileStatement(path) {
        // switch 節點
        let switchNode = path.node.body.body[0];
        // switch 語句内的控制流數組名，本例中是 _0x28073a、_0x2efb35、_0x187fb8
        let arrayName = switchNode.discriminant.object.name;
        // 獲取控制流數組綁定的節點
        let bindingArray = path.scope.getBinding(arrayName);
        // 獲取節點整個表達式的參數、分割方法、分隔符
        let init = bindingArray.path.node.init;
        let object = init.callee.object.value;
        let property = init.callee.property.value;
        let argument = init.arguments[0].value;
        // 模拟執行 '3|2|1|4|5|0|6'['split']('|') 語句
        let array = object[property](argument)
        // 也可以直接取參數進行分割，方法不通用，比如分隔符換成 , 就不行了
        // let array = init.callee.object.value.split('|');
        // switch 語句内的控制流自增變量名，本例中是 _0x38c69e、_0x396880、_0x3b3dc7
        let autoIncrementName = switchNode.discriminant.property.argument.name;
        // 獲取控制流自增變量名綁定的節點
        let bindingAutoIncrement = path.scope.getBinding(autoIncrementName);
        // 可選擇的操作：删除控制流數組綁定的節點、自增變量名綁定的節點
        bindingArray.path.remove();
        bindingAutoIncrement.path.remove();
        // 儲存正确順序的控制流語句
        let replace = [];
        // 遍曆控制流數組，按正确順序取 case 内容
        array.forEach(index => {
                let consequent = switchNode.cases[index].consequent;
                // 如果最後一個節點是 continue 語句，則删除 ContinueStatement 節點
                if (types.isContinueStatement(consequent[consequent.length - 1])) {
                    consequent.pop();
                }
                // concat 方法拼接多個數組，即正确順序的 case 内容
                replace = replace.concat(consequent);
            }
        );
        // 替換整個 while 節點，兩種方法都可以
        path.replaceWithMultiple(replace);
        // path.replaceInline(replace);
    }
}

const visitor5 = {
    // 十六進制、Unicode 編碼等，轉正常字符
    "StringLiteral|NumericLiteral"(path){
        delete path.node.extra;
    },
    // _0x3cbc20["length"] 轉換成 _0x3cbc20.length
    MemberExpression(path){
        if (path.node.property.type == "StringLiteral") {
            path.node.computed = false
            path.node.property = types.identifier(path.node.property.value)
        }
    },
    // 表達式還原，!![] 直接計算成 true
    "BinaryExpression|UnaryExpression"(path) {
        let {confident, value} = path.evaluate()
        if (confident){
            path.replaceInline(types.valueToNode(value))
        }
    },
    // 删除未引用的變量，比如 _0xodD = "jsjiami.com.v6";
    AssignmentExpression(path){
        let binding = path.scope.getBinding(path.node.left.name);
        if (!binding) {
            path.remove();
        }
    }
}
// 删除冗餘邏輯代碼，隻保留 if 爲 true 的
const visitor6 = {
    IfStatement(path) {
        if(path.node.test.type == "BooleanLiteral") {
            if(path.node.test.value) {
                path.replaceInline(path.node.consequent.body)
            } else {
                path.replaceInline(path.node.alternate.body)
            }
        }
    }
}