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

什麼是 RPC

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

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

解決了分布式系統中，服務之間的互相調用問題；
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 通信代碼寫在一起，然後根據需求，改寫一下通信部分代碼：

ws 連結改為： ws://127.0.0.1:5620/business-demo/register?group=rpc-test&clientId= ，自定義 group 為 rpc-test ；
注冊一個事件 registerAction 為 getH5fingerprint ；
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，這裡需要注意一下幾點問題：

第一個是時機的問題，需要等待 document 這些元素加載完成才能建立 SekiroClient 通信，不然調用 SekiroClient 是會報錯的，這裡可以用 setTimeout 方法，該方法用于在指定的毫秒數後調用函數或計算表達式，将 SekiroClient 通信代碼單獨封裝成一個函數，比如 function startSekiro() ，然後等待 1-2 秒後再執行 SekiroClient 通信代碼；
由于 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 逆向，可以說是目前比較萬能、高效的方法了，一定程度上做到了加密參數一把梭！

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

什麼是 RPC

JSRPC

Sekiro

優缺點

繼續閱讀

無法解析的外部符号 wmain，該符号在函數 "void cdecl mainCRTStartupHelper(struct HINSTANCE *,unsigned short con......

TestLink導出用例轉換工具(XML2Excel)

YAML簡介和PyYAML安全操作YAML支援的類型YAML的優點：yaml的基本文法python操作

Small tricks

libsvm for python 安裝

學習軟體測試基礎測試第七天

Zeppelin 配置通路 REST APIApache Zeppelin Configuration REST API

【Torch】最簡潔logging使用指南

27. Remove Element(清單)題目代碼

sort()函數到底是怎樣進行數字排序的

Cloud Studio初體驗

使用 ctypes 進行 Python 和 C 的混合程式設計

【python】【資料處理】畫多元資料分布圖

【python】netconf協定對接管理裝置

「Python 網絡自動化」NETCONF —— Python 使用 NETCONF 管理配置 H3C 網絡裝置

在python中建立excel并寫入