RPC 技術及其框架 Sekiro 在爬蟲逆向中的應用，加密資料一把梭！

什麼是 RPC

RPC，英文 RangPaCong，中文讓爬蟲，旨在為爬蟲開路，秒殺一切，讓爬蟲暢通無阻！

開個玩笑，實際上 RPC 為遠端過程呼叫，全稱 Remote Procedure Call，是一種技術思想而非一種規範或協議。RPC 的誕生事實上離不開分散式的發展，RPC 主要解決了兩個問題：

1. 解決了分散式系統中，服務之間的互相呼叫問題；
2. RPC 使得在遠端呼叫時，像本地呼叫一樣方便，讓呼叫者感知不到遠端呼叫的邏輯。

RPC 的存在讓構建分散式系統更加容易，相比於 HTTP 協議，RPC 採用二進位制位元組碼傳輸，因此也更加高效、安全。在一個典型 RPC 的使用場景中，包含了服務發現、負載、容錯、網路傳輸、序列化等元件，完整 RPC 架構圖如下圖所示：

JSRPC

RPC 技術是非常複雜的，對於我們搞爬蟲、逆向的來說，不需要完全瞭解，只需要知道這項技術如何在逆向中應用就行了。

RPC 在逆向中，簡單來說就是將本地和瀏覽器，看做是服務端和客戶端，二者之間通過 WebSocket 協議進行 RPC 通訊，在瀏覽器中將加密函式暴露出來，在本地直接呼叫瀏覽器中對應的加密函式，從而得到加密結果，不必去在意函式具體的執行邏輯，也省去了扣程式碼、補環境等操作，可以省去大量的逆向除錯時間。我們以某團網頁端的登入為例來演示 RPC 在逆向中的具體使用方法。（假設你已經有一定逆向基礎，瞭解 WebSocket 協議，純小白可以先看看K哥以前的文章）

• 主頁（base64）：aHR0cHM6Ly9wYXNzcG9ydC5tZWl0dWFuLmNvbS9hY2NvdW50L3VuaXRpdmVsb2dpbg==
• 引數：h5Fingerprint

首先抓一下包，登入介面有一個超級長的引數 h5Fingerprint，如下圖所示：

直接搜一下就能找到加密函式：

其中 utility.getH5fingerprint() 傳入的引數 window.location.origin + url 格式化後，引數如下：

url = "https://passport.脫敏處理.com/account/unitivelogin"
params = {
    "risk_partner": "0",
    "risk_platform": "1",
    "risk_app": "-1",
    "uuid": "96309b5f00ba4143b920.1644805104.1.0.0",
    "token_id": "DNCmLoBpSbBD6leXFdqIxA",
    "service": "www",
    "continue": "https://www.脫敏處理.com/account/settoken?continue=https%3A%2F%2Fwww.脫敏處理.com%2F"
}

uuid 和 token_id 都可以直接搜到，不是本次研究重點，這裡不再細說，接下來我們使用 RPC 技術，直接呼叫瀏覽器裡的 utility.getH5fingerprint() 方法，首先在本地編寫服務端程式碼，使其能夠一直輸入待加密字串，接收並列印加密後的字串：

# ==================================
# --*-- coding: utf-8 --*--
# @Time    : 2022-02-14
# @Author  : 微信公眾號：K哥爬蟲
# @FileName: ws_server.py
# @Software: PyCharm
# ==================================


import sys
import asyncio
import websockets


async def receive_massage(websocket):
    while True:
        send_text = input("請輸入要加密的字串: ")
        if send_text == "exit":
            print("Exit, goodbye!")
            await websocket.send(send_text)
            await websocket.close()
            sys.exit()
        else:
            await websocket.send(send_text)
            response_text = await websocket.recv()
            print("\n加密結果：", response_text)


start_server = websockets.serve(receive_massage, '127.0.0.1', 5678)  # 自定義埠
asyncio.get_event_loop().run_until_complete(start_server)
asyncio.get_event_loop().run_forever()

編寫瀏覽器客戶端 JS 程式碼，收到訊息就直接 utility.getH5fingerprint() 得到加密引數併傳送給服務端：

/* ==================================
# @Time    : 2022-02-14
# @Author  : 微信公眾號：K哥爬蟲
# @FileName: ws_client.js
# @Software: PyCharm
# ================================== */


var ws = new WebSocket("ws://127.0.0.1:5678");  // 自定義埠

ws.onmessage = function (evt) {
    console.log("Received Message: " + evt.data);
    if (evt.data == "exit") {
        ws.close();
    } else {
        ws.send(utility.getH5fingerprint(evt.data))
    }
};

然後我們需要把客戶端程式碼注入到網頁中，這裡方法有很多，比如抓包軟體 Fiddler 替換響應、瀏覽器外掛 ReRes 替換 JS、瀏覽器開發者工具 Overrides 重寫功能等，也可以通過外掛、油猴等注入 Hook 的方式插入，反正方法很多，對這些方法不太瞭解的朋友可以去看看K哥以前的文章，都有介紹。

這裡我們使用瀏覽器開發者工具 Overrides 重寫功能，將 WebSocket 客戶端程式碼加到加密的這個 JS 檔案裡並 Ctrl+S 儲存，這裡將其寫成了 IIFE 自執行方式，這樣做的原因是防止汙染全域性變數，不用自執行方式當然也是可以的。

然後先執行本地服務端程式碼，網頁上先登入一遍，網頁上先登入一遍，網頁上先登入一遍，重要的步驟說三遍！然後就可以在本地傳入待加密字串，獲取 utility.getH5fingerprint() 加密後的結果了：

Sekiro

通過前面的示例，可以發現自己寫服務端太麻煩了，不易擴充套件，那這方面有沒有現成的輪子呢？答案是有的，這裡介紹兩個專案：

• JsRPC-hliang：https://github.com/jxhczhl/JsRpc
• Sekiro：https://github.com/virjar/sekiro

JsRPC-hliang 是用 go 語言寫的，是專門為 JS 逆向做的專案，而 Sekiro 功能更加強大，Sekiro 是由鄧維佳大佬，俗稱渣總，寫的一個基於長連結和程式碼注入的 Android Private API 暴露框架，可以用在 APP 逆向、APP 資料抓取、Android 群控等場景，同時 Sekiro 也是目前公開方案唯一穩定的 JSRPC 框架，兩者在 JS 逆向方面的使用方法其實都差不多，本文主要介紹一下 Sekiro 在 Web JS 逆向中的應用。

參考 Sekiro 文件，首先在本地編譯專案：

• Linux & Mac：執行指令碼 build_demo_server.sh，之後得到產出釋出壓縮包：sekiro-service-demo/target/sekiro-release-demo.zip

• Windows：可以直接下載：https://oss.virjar.com/sekiro/sekiro-demo

然後在本地執行（需要有 Java 環境，自行配置）：

• Linux & Mac：bin/sekiro.sh
• Windows：bin/sekiro.bat

以 Windows 為例，啟動後如下：

接下來就需要在瀏覽器裡注入程式碼了，需要將作者提供的 sekiro_web_client.js（下載地址：https://sekiro.virjar.com/sekiro-doc/assets/sekiro_web_client.js） 注入到瀏覽器環境，然後通過 SekiroClient 和 Sekiro 伺服器通訊，即可直接 RPC 呼叫瀏覽器內部方法，官方提供的 SekiroClient 程式碼樣例如下：

function guid() {
    function S4() {
        return (((1+Math.random())*0x10000)|0).toString(16).substring(1);
    }
    return (S4()+S4()+"-"+S4()+"-"+S4()+"-"+S4()+"-"+S4()+S4()+S4());
}

var client = new SekiroClient("wss://sekiro.virjar.com/business/register?group=ws-group&clientId="+guid());

client.registerAction("clientTime",function(request, resolve, reject){
    resolve(""+new Date());
})

wss 連結裡，如果是免費版，要將 business 改成 business-demo，解釋一下涉及到的名詞：

• group：業務型別（介面組），每個業務一個 group，group 下面可以註冊多個終端（SekiroClient），同時 group 可以掛載多個 Action；
• clientId：指代裝置，多個裝置使用多個機器提供 API 服務，提供群控能力和負載均衡能力；
• SekiroClient：服務提供者客戶端，主要場景為手機/瀏覽器等。最終的 Sekiro 呼叫會轉發到 SekiroClient。每個 client 需要有一個惟一的 clientId；
• registerAction：介面，同一個 group 下面可以有多個介面，分別做不同的功能；
• resolve：將內容傳回給客戶端的方法；
• request：客戶端傳過來的請求，如果請求裡有多個引數，可以以鍵值對的方式從裡面提取引數然後再做處理。

說了這麼多可能也不好理解，直接實戰，還是以某團網頁端登入為例，我們將 sekiro_web_client.js 與 SekiroClient 通訊程式碼寫在一起，然後根據需求，改寫一下通訊部分程式碼：

1. ws 連結改為：ws://127.0.0.1:5620/business-demo/register?group=rpc-test&clientId=，自定義 group 為 rpc-test；
2. 註冊一個事件 registerAction 為 getH5fingerprint；
3. resolve 返回的結果為 utility.getH5fingerprint(request["url"])，即加密並返回客戶端傳過來的 url 引數。

完整程式碼如下（留意末尾 SekiroClient 通訊程式碼部分的寫法）：

/* ==================================
# @Time    : 2022-02-14
# @Author  : 微信公眾號：K哥爬蟲
# @FileName: sekiro.js
# @Software: PyCharm
# ================================== */

(function () {
    'use strict';
    function SekiroClient(wsURL) {
        this.wsURL = wsURL;
        this.handlers = {};
        this.socket = {};
        // check
        if (!wsURL) {
            throw new Error('wsURL can not be empty!!')
        }
        this.webSocketFactory = this.resolveWebSocketFactory();
        this.connect()
    }

    SekiroClient.prototype.resolveWebSocketFactory = function () {
        if (typeof window === 'object') {
            var theWebSocket = window.WebSocket ? window.WebSocket : window.MozWebSocket;
            return function (wsURL) {

                function WindowWebSocketWrapper(wsURL) {
                    this.mSocket = new theWebSocket(wsURL);
                }

                WindowWebSocketWrapper.prototype.close = function () {
                    this.mSocket.close();
                };

                WindowWebSocketWrapper.prototype.onmessage = function (onMessageFunction) {
                    this.mSocket.onmessage = onMessageFunction;
                };

                WindowWebSocketWrapper.prototype.onopen = function (onOpenFunction) {
                    this.mSocket.onopen = onOpenFunction;
                };
                WindowWebSocketWrapper.prototype.onclose = function (onCloseFunction) {
                    this.mSocket.onclose = onCloseFunction;
                };

                WindowWebSocketWrapper.prototype.send = function (message) {
                    this.mSocket.send(message);
                };

                return new WindowWebSocketWrapper(wsURL);
            }
        }
        if (typeof weex === 'object') {
            // this is weex env : https://weex.apache.org/zh/docs/modules/websockets.html
            try {
                console.log("test webSocket for weex");
                var ws = weex.requireModule('webSocket');
                console.log("find webSocket for weex:" + ws);
                return function (wsURL) {
                    try {
                        ws.close();
                    } catch (e) {
                    }
                    ws.WebSocket(wsURL, '');
                    return ws;
                }
            } catch (e) {
                console.log(e);
                //ignore
            }
        }
        //TODO support ReactNative
        if (typeof WebSocket === 'object') {
            return function (wsURL) {
                return new theWebSocket(wsURL);
            }
        }
        // weex 和 PC環境的websocket API不完全一致，所以做了抽象相容
        throw new Error("the js environment do not support websocket");
    };

    SekiroClient.prototype.connect = function () {
        console.log('sekiro: begin of connect to wsURL: ' + this.wsURL);
        var _this = this;
        // 不check close，讓
        // if (this.socket && this.socket.readyState === 1) {
        //     this.socket.close();
        // }
        try {
            this.socket = this.webSocketFactory(this.wsURL);
        } catch (e) {
            console.log("sekiro: create connection failed,reconnect after 2s");
            setTimeout(function () {
                _this.connect()
            }, 2000)
        }

        this.socket.onmessage(function (event) {
            _this.handleSekiroRequest(event.data)
        });

        this.socket.onopen(function (event) {
            console.log('sekiro: open a sekiro client connection')
        });

        this.socket.onclose(function (event) {
            console.log('sekiro: disconnected ,reconnection after 2s');
            setTimeout(function () {
                _this.connect()
            }, 2000)
        });
    };

    SekiroClient.prototype.handleSekiroRequest = function (requestJson) {
        console.log("receive sekiro request: " + requestJson);
        var request = JSON.parse(requestJson);
        var seq = request['__sekiro_seq__'];

        if (!request['action']) {
            this.sendFailed(seq, 'need request param {action}');
            return
        }
        var action = request['action'];
        if (!this.handlers[action]) {
            this.sendFailed(seq, 'no action handler: ' + action + ' defined');
            return
        }

        var theHandler = this.handlers[action];
        var _this = this;
        try {
            theHandler(request, function (response) {
                try {
                    _this.sendSuccess(seq, response)
                } catch (e) {
                    _this.sendFailed(seq, "e:" + e);
                }
            }, function (errorMessage) {
                _this.sendFailed(seq, errorMessage)
            })
        } catch (e) {
            console.log("error: " + e);
            _this.sendFailed(seq, ":" + e);
        }
    };

    SekiroClient.prototype.sendSuccess = function (seq, response) {
        var responseJson;
        if (typeof response == 'string') {
            try {
                responseJson = JSON.parse(response);
            } catch (e) {
                responseJson = {};
                responseJson['data'] = response;
            }
        } else if (typeof response == 'object') {
            responseJson = response;
        } else {
            responseJson = {};
            responseJson['data'] = response;
        }


        if (Array.isArray(responseJson)) {
            responseJson = {
                data: responseJson,
                code: 0
            }
        }

        if (responseJson['code']) {
            responseJson['code'] = 0;
        } else if (responseJson['status']) {
            responseJson['status'] = 0;
        } else {
            responseJson['status'] = 0;
        }
        responseJson['__sekiro_seq__'] = seq;
        var responseText = JSON.stringify(responseJson);
        console.log("response :" + responseText);
        this.socket.send(responseText);
    };

    SekiroClient.prototype.sendFailed = function (seq, errorMessage) {
        if (typeof errorMessage != 'string') {
            errorMessage = JSON.stringify(errorMessage);
        }
        var responseJson = {};
        responseJson['message'] = errorMessage;
        responseJson['status'] = -1;
        responseJson['__sekiro_seq__'] = seq;
        var responseText = JSON.stringify(responseJson);
        console.log("sekiro: response :" + responseText);
        this.socket.send(responseText)
    };

    SekiroClient.prototype.registerAction = function (action, handler) {
        if (typeof action !== 'string') {
            throw new Error("an action must be string");
        }
        if (typeof handler !== 'function') {
            throw new Error("a handler must be function");
        }
        console.log("sekiro: register action: " + action);
        this.handlers[action] = handler;
        return this;
    };

    function guid() {
        function S4() {
            return (((1 + Math.random()) * 0x10000) | 0).toString(16).substring(1);
        }

        return (S4() + S4() + "-" + S4() + "-" + S4() + "-" + S4() + "-" + S4() + S4() + S4());
    }

    var client = new SekiroClient("ws://127.0.0.1:5620/business-demo/register?group=rpc-test&clientId=" + guid());

    client.registerAction("getH5fingerprint", function (request, resolve, reject) {
        resolve(utility.getH5fingerprint(request["url"]));
    })

})();

與前面的方法一樣，使用瀏覽器開發者工具 Overrides 重寫功能，將上面的程式碼注入到網頁 JS 裡：

然後 Sekiro 為我們提供了一些 API：

• 檢視分組列表：http://127.0.0.1:5620/business-demo/groupList
• 檢視佇列狀態：http://127.0.0.1:5620/business-demo/clientQueue?group=test
• 呼叫轉發：http://127.0.0.1:5620/business-demo/invoke?group=test&action=test&param=testparm

比如我們現在要呼叫 utility.getH5fingerprint() 加密方法該怎麼辦呢？很簡單，程式碼注入到瀏覽器裡後，首先還是要手動登入一遍，手動登入一遍，手動登入一遍，重要的事情說三遍！然後參考上面的呼叫轉發 API 進行改寫：

• 我們自定義的分組 group 是 rpc-test；
• 事件 action 是 getH5fingerprint；
• 待加密引數名稱為 url， 其值例如為：https://www.baidu.com/

那麼我們的呼叫連結就應該是：http://127.0.0.1:5620/business-demo/invoke?group=rpc-test&action=getH5fingerprint&url=https://www.baidu.com/，直接瀏覽器開啟，返回的字典，data 裡面就是加密結果：

同樣的，在本地用 Python 的話，直接 requests 就完事兒了：

我們前面是把 sekiro_web_client.js 複製下來和通訊程式碼一起注入到瀏覽器的，這裡我們還可以有更加優雅的方法，直接給 document 新建立一個 script，通過連結的形式插入 sekiro_web_client.js，這裡需要注意一下幾點問題：

1. 第一個是時機的問題，需要等待 document 這些元素載入完成才能建立 SekiroClient 通訊，不然呼叫 SekiroClient 是會報錯的，這裡可以用 setTimeout 方法，該方法用於在指定的毫秒數後呼叫函式或計算表示式，將 SekiroClient 通訊程式碼單獨封裝成一個函式，比如 function startSekiro()，然後等待 1-2 秒後再執行 SekiroClient 通訊程式碼；
2. 由於 SekiroClient 通訊程式碼被封裝成了函式，此時直接呼叫 utility.getH5fingerprint 是會提示未定義的，所以我們要先將其導為全域性變數，比如 window.getH5fingerprint = utility.getH5fingerprint，後續直接呼叫 window.getH5fingerprint 即可。

完整程式碼如下所示：

/* ==================================
# @Time    : 2022-02-14
# @Author  : 微信公眾號：K哥爬蟲
# @FileName: sekiro.js
# @Software: PyCharm
# ================================== */

(function () {
    var newElement = document.createElement("script");
    newElement.setAttribute("type", "text/javascript");
    newElement.setAttribute("src", "https://sekiro.virjar.com/sekiro-doc/assets/sekiro_web_client.js");
    document.body.appendChild(newElement);

    window.getH5fingerprint = utility.getH5fingerprint

    function guid() {
        function S4() {
            return (((1 + Math.random()) * 0x10000) | 0).toString(16).substring(1);
        }
        return (S4() + S4() + "-" + S4() + "-" + S4() + "-" + S4() + "-" + S4() + S4() + S4());
    }

    function startSekiro() {
        var client = new SekiroClient("ws://127.0.0.1:5620/business-demo/register?group=rpc-test&clientId=" + guid());

        client.registerAction("getH5fingerprint", function (request, resolve, reject) {
            resolve(window.getH5fingerprint(request["url"]));
        })
    }

    setTimeout(startSekiro, 2000)
})();

優缺點

目前如果不去逆向 JS 來實現加密引數的話，用得最多的就是自動化工具了，比如 Selenium、Puppeteer 等，很顯然這些自動化工具配置繁瑣、執行效率極低，而 RPC 技術不需要載入多餘的資源，穩定性和效率明顯都更高，RPC 不需要考慮瀏覽器指紋、各種環境，如果風控不嚴的話，高併發也是能夠輕鬆實現的，相反，由於 RPC 是一直掛載在同一個瀏覽器上的，所以針對風控較嚴格的站點，比如檢測 UA、IP 與加密引數繫結之類的，那麼 PRC 呼叫太頻繁就不太行了，當然也可以研究研究瀏覽器群控技術，操縱多個不同瀏覽器可以一定程度上緩解這個問題。總之 RPC 技術還是非常牛的，除了 JS 逆向，可以說是目前比較萬能、高效的方法了，一定程度上做到了加密引數一把梭！