【JS 逆向百例】AST 脫混淆實戰,某 ICP 備案號查詢介面 jsjiami v6 分析

K哥爬蟲發表於2022-05-26

關注微信公眾號:K哥爬蟲,持續分享爬蟲進階、JS/安卓逆向等技術乾貨!

宣告

本文章中所有內容僅供學習交流,抓包內容、敏感網址、資料介面均已做脫敏處理,嚴禁用於商業用途和非法用途,否則由此產生的一切後果均與作者無關,若有侵權,請在公眾號聯絡我立即刪除!

逆向目標

  • 目標:站 Z 之家網站 ICP 備案號查詢
  • 主頁:aHR0cDovL2ljcC5jaGluYXouY29tLw==
  • 介面:aHR0cDovL2ljcC5jaGluYXouY29tL2hvbWUvR2V0UGVyaW1pdEJ5SG9zdA==
  • 逆向引數:hostTokenpermitToken

本次主要是 AST 解混淆實戰,本例中的 JS 混淆方式是 sojson 旗下的 jsjiami v6 版本,感興趣的可以去官網體驗一下:https://www.jsjiami.com/ ,如果你還不瞭解 AST,可以先看看 K 哥上期的文章(非常詳細):《逆向進階,利用 AST 技術還原 JavaScript 混淆程式碼》,本文部分 AST 還原始碼直接使用了上期文章中的程式碼,所以細節方面不再贅述,有疑問的地方可以參考參考上期文章。

第三方工具

逆向領域大佬雲集,市面上已經有很多大佬寫好的解混淆工具了,除了我們自己手動去寫 AST 解析程式碼以外,有時候直接使用工具會更加方便,當然並沒有十全十美的工具,不過大部分情況下都能成功解混淆的,以下工具值得去體驗一下:

抓包分析

進入主題,首先抓包看看,來到 ICP 備案查詢頁面,查詢結果中,其他資訊都可以直接在相應的 html 原始碼中找到,只有這個備案號是通過介面傳過來的,對應的請求和相關加密引數如下圖所示:

01

02

加密定位

直接搜尋關鍵字 hostToken 或者 permitToken 即可定位:

03

04

關鍵程式碼:

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

這裡的混淆可以手動跟一下,還原後如下:

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

kw 是查詢的域名,有用的就是 generateHostKey()generateWordKey() 兩個方法了,跟進去看,程式碼經過了 jsjiami v6 混淆:

05

06

07

AST 脫混淆

jsjiami 混淆的特徵其實和 OB 混淆是類似的:

  1. 一般由一個大陣列或者含有大陣列的函式、一個陣列位移操作的自執行函式、一個解密函式和加密後的函式四部分組成;
  2. 函式名和變數名通常以 _0x 或者 0x 開頭,後接 1~6 位數字或字母組合;
  3. 陣列位移操作的自執行函式裡,有明顯的 push、shift 關鍵字。

本例中,generateHostKey() 方法在 commo.js 裡,generateWordKey() 方法在 generatetoken.js 裡,結構如下圖所示:

08

觀察 generatetoken.js 檔案,可以發現這裡面也有 commo.js 裡面的 generateHostKey()getRandom() 方法,從方法名來看貌似是重複了,實際上混淆還原後方法是一樣的,所以這裡我們只需要還原 generatetoken.js 就可以了。

檔案結構

  • 混淆 JS 檔案:generatetoken.js
  • AST 還原始碼:generatetokenAst.js
  • 還原後的程式碼:generatetokenNew.js

解密函式還原

在原來混淆後的 JS 裡,解密函式是 _0x530e,首先觀察整個 JS,呼叫了很多次解密函式,類似於:_0x530e('1', '7XEq')

注意這裡程式碼裡面有一些特殊字元,類似於 RLERLO 之類的,如果在 VSCode 開啟是一些 U+202BU+202E 的字元,實際上這是 RTLO (Right-to-Left Override) 字元,U+202BU+202E 的意思分別是根據記憶體順序從左至右和從右至左顯示字元,感興趣的可以網上搜尋瞭解一下。這裡並不影響我們進行還原操作。但是如果直接複製過來的話就會導致前後文顯示的順序不對,所以本文中為了方便描述,貼上的部分程式碼就手動去掉了這些字元。

09

10

所以第一步我們要還原一下解密函式,把所有 _0x530e 呼叫的地方直接替換成實際值,首先需要將大陣列、自執行函式、加密函式和解密函式分割開,將程式碼放到 astexplorer.net 看一下,也就是將 body 的前四部分和後面剩餘部分分割開來,如下圖所示:

11

分割程式碼:

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);

在上面的獲取加密函式和解密函式的程式碼中,方法不是唯一的,多種多樣,比如直接迴圈取 body 並轉換成 JS 程式碼,比如直接人工把大陣列、自執行函式和解密函式三部分,拿出來放到一個新檔案裡,然後匯出解密方法,後續直接呼叫也可以。

在本例中,拿到解密函式後,需要將其賦值給整個 AST 節點,然後再將整個 AST 節點轉換成 JavaScript 程式碼,這裡注意有可能會檢測程式碼是否格式化,所以建議轉換要加一個 compact 引數,避免格式化,轉換完成後 eval 執行一下,讓陣列位移操作完成,然後我們就可以直接呼叫解密函式,即 _0x530e()

// 將解密函式賦值給整個 AST 節點
astCode.program.body = decryptFunction

// 將 AST 節點轉換成 JS 程式碼,並 eval 執行一下
decryptFunction = generate(astCode, {compact: true}).code
eval(decryptFunction);

// 測試一下,直接呼叫 _0x530e 函式可以正確拿到結果
// 輸出 split
// console.log(_0x530e('‮b', 'Zp9G'))

現在我們能直接呼叫解密函式 _0x530e() 了,接下來要做的就是怎麼把混淆程式碼中所有呼叫 _0x530e() 的地方替換成真實值,在此之前,我們要把加密函式(generateKey()generateHostKey()generateWordKey()getRandom())賦值給整個 AST 節點,此時整個節點就沒有大陣列、自執行函式和解密函式了,解密函式 _0x530e() 已經被寫入記憶體,所以後面不影響我們呼叫。

老樣子,還是先在 astexplorer.net 看一下呼叫 _0x530e() 的地方,以 _0x530e('b', 'Zp9G') 為例,其真實值應該是 split,對比一下替換前後的結構,如下圖所示:

12

13

可以看到節點由原來的 CallExpression 變成了 StringLiteral,所以我們可以遍歷 CallExpression,如果函式名為解密函式名,那就通過 path.toString() 方法獲取節點原始碼,也就類似 _0x530e('b', 'Zp9G') 的原始碼,然後 eval 執行一下獲取其真實值,再使用 types.stringLiteral() 構建 StringLiteral 節點,最後通過 path.replaceInline() 方法替換節點,遍歷程式碼如下:

// 將加密函式賦值給整個 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)}))

自此,第一步的解密函式還原就完成了,可以看一下還原前後的對比,如下圖所示淺藍色標記的地方,所有呼叫 _0x530e() 的地方都被還原了:

14

大物件還原

初步還原後我們的程式碼裡就只剩下以下四個方法:

  • generateKey()
  • generateHostKey()
  • generateWordKey()
  • getRandom()

再觀察程式碼,發現每個方法一開始都有個大的物件,他們分別是:

  • _0x3b79c6
  • _0x278b2d
  • _0x4115c4
  • _0xd8ec33

後續的程式碼也在不斷呼叫這個物件的方法,比如 _0x3b79c6["esdtg"](_0x2e5848["length"], 0x4) 實際上就是 _0x2e5848["length"] != 0x4,如下圖所示:

15

首先我們將這四個大的物件單獨提取出來,還是保持原來的鍵值對樣式,提取完成後刪除這兩個節點,遍歷程式碼如下:

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'
}

針對不同的情況有不同的處理方法,同時還要注意傳參和 return 返回的引數位置,不要還原後把 a - b 搞成 b - a 了,當然在本例中傳入和返回的順序是一樣的,就不需要考慮這個問題。

字串還原

首先來看字串,有以下幾種情況:

  • _0x3b79c6['YrYQW'] 為例,實際上其值為字串 '#IpValue',觀察其結構,是一個 MemberExpression,在一個列表裡;
  • _0x278b2d['pjbyX'] 為例,實際上其值為字串 '3|2|1|4|5|0|6',觀察其結構,是一個 MemberExpression,在一個字典裡;
  • _0x278b2d['CnTaO'] 為例,雖然也是一個 MemberExpression,也在一個字典裡。但實際上是二項式計算,所以要排除在外。

16

17

18

所以我們在寫遍歷程式碼時,同時要注意這三種情況,滿足條件後直接取原來大物件對應的節點進行替換即可,遍歷程式碼如下所示:

// 函式替換,字串替換:將類似 _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,看一下替換前後對比:

19

20

對於這種情況,我們可以直接提取兩個引數,然後提取大物件裡對應方法的操作符,然後將引數和操作符直接連線起來組成新的節點(binaryExpression)並替換即可,遍歷程式碼如下:

// 函式替換,二項式計算:將類似 _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))
                }
            }
        }
    }
}

方法呼叫還原

_0x4115c4["PJbSm"](getRandom, 0x64, 0x3e7) 為例,實際上是 getRandom(0x64, 0x3e7),看一下替換前後對比:

21

22

對於這種情況,傳入的第一個引數為方法名稱,後面的都是引數,那麼可以直接取第一個元素為方法名稱,使用 slice(1) 方法取後面所有的引數(因為後面的引數個數是不一定的),然後構造新的節點(callExpression)並替換即可,這部分遍歷程式碼可以和前面二項式的替換相結合,程式碼如下:

// 函式替換,二項式計算:將類似 _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))
                }
            }
        }
    }
}

自此,第二步的大物件還原就完成了,可以看一下還原前後的對比,如下圖所示淺藍色標記的地方,所有呼叫四個大物件(_0x3b79c6_0x278b2d_0x4115c4_0xd8ec33)的地方都被還原了:

23

switch-case 反控制流平坦化

經過前面幾步的還原之後,我們發現 generateHostKey()generateWordKey()getRandom() 方法裡都有一個 switch-case 的控制流,關於反控制流平坦化的講解在我上期文章有很詳細的介紹,不理解的可以看看上期文章,此處也不再贅述了,直接貼程式碼了:

// 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);
    }
}

其他細節還原

到這裡其實大部分混淆都已經還原了,已經很容易分析其邏輯了,還剩下一些細節,我們也還原一下,主要有以下細節:

  • 十六進位制、Unicode 編碼等,轉正常字元;
  • 物件屬性還原,比如 _0x3cbc20['length'] 轉換成 _0x3cbc20.length
  • 表示式還原,比如 !![] 直接計算成 true;
  • 刪除未引用的變數,比如 _0xodD= "jsjiami.com.v6";
  • 刪除冗餘邏輯程式碼,只保留 if 為 true 的。

這些還原始碼在我上期文章有詳細講過,結合程式碼,在 astexplorer.net 對照其結構看,也能理解,同樣也不贅述了,直接貼程式碼:

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)
            }
        }
    }
}

自此 jajiami v6 混淆就還原完畢了,還原前後對比一下,程式碼量縮短了很多,邏輯也更加清楚了,如下圖所示:

24

最後結合 Python 程式碼,攜帶生成的 hostTokenpermitToken,成功拿到備案號:

25

完整程式碼

原混淆程式碼 generatetoken.js、AST 脫混淆程式碼 generatetokenAst.js、還原後的程式碼 generatetokenNew.js,以及 Python 測試程式碼均在 GitHub,均有詳細註釋,歡迎 Star。所有內容僅供學習交流,嚴禁用於商業用途、非法用途,否則由此產生的一切後果均與作者無關,在倉庫中下載的檔案學習完畢之後請於 24 小時內刪除!

程式碼地址:https://github.com/kgepachong...

相關文章