js RPC及Sekro的使用

已于 2022-02-11 10:17:35 修改
阅读量2.9k 收藏 29
点赞数 6
文章标签： python javascript node.js
于 2021-10-05 23:21:14 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq409732112/article/details/120619610
版权

有时候遇到一些加密参数，我们不想知道它是怎么生成的，只想取它的值，这种情况下就适合使用RPC了
第一种使用websocket的方式，通过油猴脚本把浏览器生成好的加密参数通过socket通信方式发送到本地
以这个网址为例，这是一个rs的网址
http://www.nhc.gov.cn/
查看一下源代码，懂得都懂
在这里插入图片描述

油猴脚本代码

// ==UserScript==
// @name         ws
// @namespace    http://tampermonkey.net/
// @version      0.1
// @description  try to take over the world!
// @author       You
// @match        http://www.fangdi.com.cn/*
// @icon         data:image/gif;base64,R0lGODlhAQABAAAAACH5BAEKAAEALAAAAAABAAEAAAICTAEAOw==
// @grant        none
// @run-at       document-start
// ==/UserScript==

(function() {
    window.ws = new WebSocket('ws://127.0.0.1:8010/');
    ws.onopen = function(){
        console.log("连接服务器成功");
        ws.send("Browser start");
    };
    ws.onclose = function(){
        console.log("服务器关闭");
    };
    ws.onerror = function(){
        console.log("连接出错");
    };
    ws.onmessage = function(evt){
        console.log(evt.data)
        console.log(document.cookie);
    }
})();

本地使用python去连接

import asyncio
import websockets

# 把接受的消息打印后返回回去
async def recv_msg(websocket):
    while True:
        recv_text = await websocket.recv()
        print(recv_text)
        await websocket.send(recv_text)

async def main(websocket, path):
    await recv_msg(websocket)

start_server = websockets.serve(main, 'localhost', 8010)
asyncio.get_event_loop().run_until_complete(start_server)
asyncio.get_event_loop().run_forever()

先运行python，再刷新对应的网址
在控制台输入ws.send(document.cookie)
python就可以接受到cookie
效果如下
在这里插入图片描述

发现只有一个sVoELocvxVW0T，应该有三个cookie的才对
这里需要在浏览器上设置一下
在这里插入图片描述

打了勾的是无法获取，需要双击后点击取消掉
现在三个cookie都能拿到
试下能不能拿到网页数据
在这里插入图片描述

上面的方式虽然可以拿到cookie，但是每次都需要去控制台send
能不能做成api的形式
请求一下就可以拿到cookie的
当然有了，这里大力推荐渣总的Sekrio框架

Sekrio

渣总开发的框架，现成轮子使用、更简单的接入rpc
github: https://github.com/virjar/sekiro
官方文档：https://sekiro.virjar.com/sekiro-doc/index.html
我用的是window，操作以window为例

安装

先把代码下载下来
然后双击运行 build_demo_server.sh
它会自动构建
在这里插入图片描述

构建完成之后
在sekiro-service-demo\target\sekiro-release-demo\bin下有两个启动文件，bat结尾的win，sh是linux
运行sekiro.bat
在这里插入图片描述

可以链接查看是否正常启动 http://127.0.0.1:5620/business-demo/groupList

样例

先把案例跑通，
把https://sekiro.virjar.com/sekiro-doc/assets/sekkiro_js_demo.html页面源码都复制下来
创建一个html文件粘贴进去
然后把其中代码修改一下

<script type="text/javascript" src="sekiro_web_client.js"></script> 
改为
<script type="text/javascript" src="https://sekiro.virjar.com/sekiro-doc/assets/sekiro_web_client.js"></script>

它里面连接的是自己的服务器
如果要把服务器改为自己的话，就把

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

在这里插入图片描述

运行，在浏览器打开控制台可以看到
在这里插入图片描述

浏览器访问 http://127.0.0.1:5620/business-demo/groupList
看到服务已开启

{"data":["test","ws-group"],"ok":true,"status":0}

用python测试一下

import requests
params ={
    "group":"ws-group",#接口名称
    "action":"executeJs",#注册的服务名
}
res = requests.get("http://127.0.0.1:5620/business-demo/invoke", params=params)
print(res.text)

在这里插入图片描述

修改端口

Sekrio默认的端口是5620
需要修改的话
在项目根目录下\sekiro-service-demo\target\sekiro-release-demo\conf\config.properties进行修改即可

rs网站实战

这里的话还是用上面的网址
这里我们需要油猴来做服务

编辑脚本

新建油猴脚本
在这里插入图片描述

访问https://sekiro.virjar.com/sekiro-doc/assets/sekiro_web_client.js
把sekrio依赖的js脚本复制放到油猴里
并上面样例的html里的这几行也复制进油猴里
在这里插入图片描述

修改下executeJs接口，获取cookie后把值传出来
在这里插入图片描述

完整的油猴脚本：

// ==UserScript==
// @name         sekrio
// @namespace    http://tampermonkey.net/
// @version      0.1
// @description  try to take over the world!
// @author       You
// @match        http://www.nhc.gov.cn/*
// @grant        none
// ==/UserScript==

(function() {

    /*
  Copyright (C) 2020 virjar <virjar@virjar.com> for https://github.com/virjar/sekiro

  Redistribution and use in source and binary forms, with or without
  modification, are permitted provided that the following conditions are met:

    * Redistributions of source code must retain the above copyright
      notice, this list of conditions and the following disclaimer.
    * Redistributions in binary form must reproduce the above copyright
      notice, this list of conditions and the following disclaimer in the
      documentation and/or other materials provided with the distribution.

  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  ARE DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY
  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/


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鐜鐨剋ebsocket 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;
    // 涓峜heck 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=ws-group&clientId=" + guid());

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

    client.registerAction("executeJs", function (request, resolve, reject) {
        var code = request['code'];
        if (!code) {
            reject("need param:{code}");
            return;
        }

        //code = "return " + code;

        console.log("executeJs: " + code);

        try {
            // var result = new Function(code)();
            var result = document.cookie;
            resolve(result);
        } catch (e) {
            reject("error: " + e);
        }

    });


})();
保存运行

保存脚本，刷新页面
这样显示表示脚本注入成功
在这里插入图片描述

服务注册也是成功的
在这里插入图片描述

接口调用

import requests
params ={
    "group":"ws-group",#接口名称
    "action":"executeJs",#注册的服务名
    "code": "document.cookie"
}
res = requests.get("http://127.0.0.1:5620/business-demo/invoke", params=params)
print(res.text)

在这里插入图片描述

经过测试正常拿到页面数据
再也不用当心逆向js代码而掉头发了

公过水蚊
关注
  • 6
    点赞
  • 踩
  • 29
    收藏
    觉得还不错? 一键收藏
  • 4
    评论
使用RabbitMQ实现RPC
01-27
作为中间件实现的RPC模式，希望对您的学习有所帮助。RabbitMQ RabbitMQ是基于AMQP协议实现的一个消息队列（MessageQueue），Message Queue是一个典型的生产者/消费者模式。生产者发布消息，消费者消费消息，生产者和...
JSRPC的三种实现方式
小龙在线
11-16 2032
RPC 为远程过程调用，本文通过在浏览器端（服务端）开启一个WebSocket服务，接收命令，执行浏览器网页的加密代码，得到密文。CMD端（客户端）也开启一个WebSocket服务与浏览器端交互，通过标准输入把命令发送给浏览器执行。
JsRPC技术案例实战
Fleehom的博客
07-04 8686
那么，我们需要进一步验证核心和cookies校验参数是哪个，当我们多次测试，便会发现是较长值参数起了作用，而它就是我们需要解决的关键。网站分析：F12打开浏览器开发者工具，Ctrl+F8跳过所有网站加载的js断点，来到Cookies专栏，便能清晰看到某数5的参数特征（以5开头，其中两个参数很接近，值是一长一短），如图。那么，我们只需打开bat文件，创建JsRPC的api接口，在油猴管理面板加入sekiro提供的js代码和自己的hook代码（注意油猴工具中的注入时机和域名范围的使用）
jsRpc js逆向远程调用加密函数
最新发布
weixin_43639743的博客
05-29 1285
RPC远程调用在js逆向中的使用，用来破解加密字段
JS逆向新技术--JSRPC
Harden13_的博客
03-26 7214
RPC 技术不需要加载多余的资源，稳定性和效率明显都更高，RPC 不需要考虑浏览器指纹、各种环境，如果风控不严的话，高并发也是能够轻松实现的，相反，由于 RPC 是一直挂载在同一个浏览器上的，所以针对风控较严格的站点，比如检测 UA、IP 与加密参数绑定之类的，那么 PRC 调用太频繁就不太行了。总之 RPC 技术还是非常牛的，除了 JS 逆向，且没有针对 RPC 进行检测的话，可以说是目前比较万能、高效的方法了，一定程度上真正做到了加密参数一把梭！！
JsRPC技术介绍及服务搭建
Fleehom的博客
07-03 8036
因为基于Sekiro的JsRPC是Sekiro框架的扩展，依然需要遵循Sekiro的各种规则定义，如group、action等参数含义。当我们下载好框架的API压缩包后解压，进到bin目录，就会看到启动的两种方式。bat文件是windows用的，sh文件是mac用的，这里我们点击bat文件启动api，如图。然后我们在本地创建该socket服务连接，根据自己的需求具体编写代码，这里我需要监控浏览器发送给服务的js信息，如图。然后，我们注入api提供的js代码，并加上自己的js逻辑 ，效果如图。
基于Sekiro的jsRPC的使用和安装
有什么问题回复不及时，可以私聊我。也可以加我的星球：知识爬行者
03-15 1246
什么是jsRPC 说实话在介绍 JSRPC 我向大家推荐一个库 Selenium-wire 感觉和JSrpc的原理很像 RPC指远程过程调用，APP里面的RPC大家比较熟悉了。 那什么是jsRPC，顾名思义，就是指利用js手段实现代码远程控制浏览器控制台的一种手段，需要借助websocket实现。 下面我们先简单的写一个小例子 var ws = require('nodejs-websocket...
知识笔记 - sekiro RPC框架的安装与简单使用
m0_51159233的博客
09-09 6127
上篇介绍了下平头哥的安装使用，这篇再来介绍下渣总的只狼（sekiro）框架然后再简单讲下如何通过平头哥注入sekiro，实现RPC调用sekiro是由邓维佳（渣总）写的一个基于长链接和代码注入的 API 服务暴露框架sekiro即可以用于app逆向，又可以用在js逆向找好注入位置时机的话，可以秒杀许多网站的加密算法（大厂也不例外）本文主要介绍了以下内容：一、sekiro是什么1.简介2.逻辑结构3.运行流程4.下载和部署二、如何开发sekiro客户端1.打开平头哥项目。
js逆向之rpc远程调用（你强任你强，我无视一切）
云霄IT的博客
04-28 2836
保存成功后，把所有断点去掉，运行下面python代码，然后刷新页面，即可进行python调用了。修改完成后按 ctrl+s 进行保存，出现下载紫色点表示成功。，注：部署到服务器用flask写个接口就可以提供远程调用啦。进行（1）操作后可直接编辑js代码了，做以下修改。注意：先运行python代码再去刷新页面。资源>>替换>>随便选一个空文件夹。
jsonrpc.js:JavaScript JSON RPC 客户端
06-29
##jsonrpc.js JSON RPC 客户端在 javascript 中的实现 ＃＃用法 创建客户端对象 var client = new JSONRPC ( { host : "localhost:3001" } ) ; 其他可用选项 host : rpc host transport: used transport , ...
使用 RSocket RPC 和 Kafka 的Proteus示例 JavaScript
06-03
client-js - 请求数字流的 Web 浏览器客户端 service - 为 kafka 读取数字流的服务 service-idl - 服务所服务的 API 的定义 number-generator - 应用程序向 kafka 发送随机数 Proteus Broker Startup docker run -p...
springcloud如何使用dubbo开发rpc服务及调用
08-25
Spring Cloud 中使用 Dubbo 开发 RPC 服务及调用 Spring Cloud 是一个基于 Java 的微服务架构开发框架，它提供了一系列的组件和工具来帮助开发者快速构建微服务系统。 Dubbo 是一个高性能的 RPC 框架，它提供了多种...
Rpc及hyperf搭建RPC微服务.zip
11-16
8. **创建RPC Client**：在需要调用RPC服务的地方，使用Hyperf的RPC客户端组件创建客户端实例，然后通过接口调用远程服务。 9. **处理响应**：客户端发送请求后，等待服务器响应，处理返回的结果。 10. **测试**：...
01 Sekiro服务器部署和第一个示例部署成功，js逆向和加解密
野路子云遇见不同的自己
11-02 1168
01 Sekiro服务器部署和第一个示例部署成功，js逆向和加解密
js逆向：rpc远程调用
快乐的大大大飞猪
10-08 1504
2.js本地替换，先下断点测试一下，然后右键js代码保存以备替代，最后单独测试一下，如果下断点没走，说明断点没找对，建议用alert()测试一下。1.一般来说开启的顺序是，服务端python代码，然后是浏览器中的js代码（调试一下），最后可以按照客户端模式调用rpc加密接口。值得注意的一点是，需要替换到本地注入的js代码。例子：这里用rsa加密为例。
Sekiro RPC框架部署使用
学习python
03-04 525
复制该页面的js代码,并追加到油猴脚本的自执行函数中，注意更改ip和端口。（2）创建script标签引入Sekior-Client.js。四、在浏览器刷新目标网站网页，让油猴脚本生效。二、运行（依赖java环境，自行安装）点击 进入Sekiro框架官网。（1）编写好油猴脚本框架。五、python访问。
【sekiro-之狼JsRPC工具使用介绍】
qq_43502467的博客
03-11 830
基于Sekiro之狼的JsRpc应用
JSON-RPC for Java 2.5 使用详解
7. **JSP中的使用**: 在客户端的JSP页面中引入JsonRpcClient.js库，并进行服务调用。 JSON-RPC for Java提供了一种简单易用的方式，让JavaScript可以直接调用Java服务，实现了前后端的无缝通信，尤其适合需要高效、...
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值