关于python:RPC-技术及其框架-Sekiro-在爬虫逆向中的应用加密数据一把梭

53次阅读

共计 11515 个字符，预计需要花费 29 分钟才能阅读完成。

什么是 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…

而后在本地运行（须要有 Java 环境，自行配置）：

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

以 Windows 为例，启动后如下：

接下来就须要在浏览器里注入代码了，须要将作者提供的 sekiro_web_client.js（下载地址：https://sekiro.virjar.com/sek…）注入到浏览器环境，而后通过 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/busines…
  • 查看队列状态：http://127.0.0.1:5620/busines…
  • 调用转发：http://127.0.0.1:5620/busines…

比方咱们当初要调用 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 逆向，能够说是目前比拟万能、高效的办法了，肯定水平上做到了加密参数一把梭！

正文完
python
发表至： python
2022-02-22
 0
一行命令给猎狐-F4-带口罩-检测是否带口罩
关于python:wxpython入门第六步高级组件
关于python:颠覆你认知的Python39
python面向对象21多重继承方法解析顺序