ob混淆AST

2020-08-28

ob混淆的特征

大数组+位移函数+解密函数，多个位置多次调用解密函数。

写AST

自执行函数如果带参数的都会有个加载器，我们看看兄弟节点有啥用吧。

这些setCookie这类的只是为某个obj的属性。只需观察这些函数里面有没有啥实参。

对这个自执行的函数来说，全局的变量只有这么两个_0x1032, 0x1a7,就围绕这两个看看。

这两个实参到这个函数里是_0x263f33,_0x270f13.

JS的函数的参数是啥传递。

也就是说，如果不通过属性来修改对象的值，那都不影响实参！！！

我们来看看这个函数里有哪里用到了实参。

只有这一处使用到了实参，数组实参只有加载器用到。

步进看看该函数是干啥的。

执行的函数是加载器，加载器的作用也只是为了执行参数而已。也就是说，其实整段代码其实也就只有++那段有用。

也就是这段。只需把函数名改为加载器的函数名，参数改为形参的参数名即可。

我们可以手动删掉，也可以通过AST来删。这里我们来用AST。

接下来我们来分析一下解密函数。

我们看到用到_0x270f13只有一处。
再看rc4这函数是啥。

保留了以上提到的，后面这里===undefine处，仅仅只需保留

该处即可。

控制流平坦化

像这种通过switch和while来混淆代码的执行顺序，既是控制流平坦化，这类的代码比较麻烦，不过可以看看极验那块的代码，那块的控制流平坦化比ob混淆的要好些，这个相对简单，直接附上代码。

const decode_while = {
    WhileStatement(path) {
        let {test, body} = path.node;
        let swithchNode = body.body[0];
        if (!types.isUnaryExpression(test) || !types.isSwitchStatement(swithchNode)) return;
        let {discriminant, cases} = swithchNode;
        if (!types.isMemberExpression(discriminant) || !types.isUpdateExpression(discriminant.property)) return;
        let arrayName = discriminant.object.name;
        let per_bro_node = path.getAllPrevSiblings();
        let array = []
        per_bro_node.forEach(per_node => {
            const {declarations} = per_node.node;
            let {id, init} = declarations[0];
            if (arrayName === id.name) {
                array = init.callee.object.value.split('|');
            }
            per_node.remove();
        });

        let replace_body = [];
        array.forEach(index => {
                let case_body = cases[index].consequent;
                if (types.isContinueStatement(case_body[case_body.length - 1])) {
                    case_body.pop();
                }
            replace_body = replace_body.concat(case_body);
            }
        );
        path.replaceInline(replace_body);
    }
}

traverse(ast, decode_while);

完整代码：

/***********************************************************
 ob混淆这类的特征是大数组加位移函数加解密函数
 ***********************************************************/


const parser = require("@babel/parser");
const traverse = require("@babel/traverse").default;
const types = require("@babel/types");
const generator = require("@babel/generator").default;
const fs = require('fs');
decode_file = 'D:\\huangsheng\\self\\js_workspace\\node_workspace\\js_parse\\bitstamp\\js\\result.js'
var jscode = fs.readFileSync('D:\\huangsheng\\self\\js_workspace\\node_workspace\\js_parse\\bitstamp\\js\\source.js', "utf-8", function (err, data) {
    if (err) {
        console.log(err);
    } else {
        code = data.toString();
    }
});
let ast = parser.parse(jscode)

/***********************************************************
 NumericLiteral ---> Literal
 StringLiteral  ---> Literal
 用于处理已十六进制显示的字符串或者数值
 ***********************************************************/
const delete_extra =
    {
        "NumericLiteral|StringLiteral": function (path) {
            delete path.node.extra;
        },
    }

traverse(ast, delete_extra);

// 删除加载器下的多余的节点
const decode_str = {
    VariableDeclarator(path) {
        let {id, init} = path.node;
        if (!types.isArrayExpression(init) || init.elements.length == 0) return;
        let code = path.toString();

        let second_sibling = path.parentPath.getNextSibling(); //获取移位函数节点
        let third_sibling = second_sibling.getNextSibling();   //获取解密函数节点

        // 开始检测特征
        if (!types.isExpressionStatement(second_sibling) || !types.isVariableDeclaration(third_sibling)) return;
        let expression = second_sibling.get('expression');
        if (!expression.isCallExpression()) return;

        let {callee, arguments} = expression.node;
        if (arguments.length !== 2 ||
            !types.isFunctionExpression(callee) ||
            !types.isIdentifier(arguments[0], {name: id.name}) ||
            !types.isNumericLiteral(arguments[1])
        ) return;

        let {declarations} = third_sibling.node;

        if (!declarations ||
            declarations.length !== 1 ||
            !types.isFunctionExpression(declarations[0].init)
        ) return;

        // 检测结束
        let sourceSecond = second_sibling.toString()
        let thirdFuncName = third_sibling.node.declarations[0].id.name;
        // 开始处理移位函数
        if (sourceSecond.indexOf('removeCookie') !== -1) {
            let second_arg_node = callee.params[1];
            let body = callee.body.body;
            let call_fun = body[0].declarations[0].id;  //解密函数的函数名，用于遍历其作用域
            body.pop();
            body.pop();
            body.push(types.ExpressionStatement(types.UpdateExpression("++", second_arg_node)));
            body.push(types.ExpressionStatement(types.callExpression(call_fun, [second_arg_node])));

            // 位移函数处理结束

            // 处理解密函数开始
            let end = third_sibling.node.end; //防止遍历函数体里的调用
            third_sibling.traverse({
                AssignmentExpression(path_) {
                    let left = path_.get('left');
                    let leftCode = left.toString()
                    let right = path_.get('right');
                    let rightCode = right.toString();
                    if (rightCode.indexOf(thirdFuncName) === -1 || rightCode.indexOf(leftCode) === -1) return;
                    let ifParantNode = path_.findParent(g => {
                        return g.isIfStatement();
                    });
                    ifParantNode && ifParantNode.replaceWith(path_.node);
                }
            });
            code += ';!' + second_sibling.toString() + third_sibling.toString();
            //eval到本地环境
            eval(code);

            const binding = third_sibling.scope.getBinding(thirdFuncName);
            if (!binding || binding.constantViolations.length > 0) return;

            let can_removed = true;
            for (const temp of binding.referencePaths) {
                // 为了处理调用解密函数处，修改为常量，故不能调用到解密函数中
                if (temp.node.start < end) {
                    continue;
                }
                let callPath = temp.findParent(p => {
                    return p.isCallExpression();
                });
                try {
                    let fun_value = eval(callPath.toString());
                    console.log('del with fun:', callPath.toString(), '  is value:', fun_value);
                    callPath && callPath.replaceWith(types.valueToNode(fun_value));
                } catch (e) {
                    can_removed = false;
                }
            }
            if (can_removed) {
                path.parentPath.remove();
                second_sibling.remove();
                third_sibling.remove();
            }
        }
    }
}

traverse(ast, decode_str);

// 处理BinaryExpression
const decode_binary = {
    BinaryExpression(path) {
        const {confident, value} = path.evaluate();
        if (Infinity === value) return;
        confident && path.replaceWith(types.valueToNode(value));
    }
}

traverse(ast, decode_binary);

// 处理控制流平坦化
const decode_while = {
    WhileStatement(path) {
        let {test, body} = path.node;
        let swithchNode = body.body[0];
        if (!types.isUnaryExpression(test) || !types.isSwitchStatement(swithchNode)) return;
        let {discriminant, cases} = swithchNode;
        if (!types.isMemberExpression(discriminant) || !types.isUpdateExpression(discriminant.property)) return;
        let arrayName = discriminant.object.name;
        let per_bro_node = path.getAllPrevSiblings();
        let array = []
        per_bro_node.forEach(per_node => {
            const {declarations} = per_node.node;
            let {id, init} = declarations[0];
            if (arrayName === id.name) {
                array = init.callee.object.value.split('|');
            }
            per_node.remove();
        });

        let replace_body = [];
        array.forEach(index => {
                let case_body = cases[index].consequent;
                if (types.isContinueStatement(case_body[case_body.length - 1])) {
                    case_body.pop();
                }
            replace_body = replace_body.concat(case_body);
            }
        );
        path.replaceInline(replace_body);
    }
}

traverse(ast, decode_while);

/************************************
 处理完毕，生成新代码
 *************************************/
let {code} = generator(ast);
fs.writeFile(decode_file, code, (err) => {
});