某侠网js逆向wasm解析

news2024/11/19 18:46:51

本次目标地址如下，使用base64解密获得
aHR0cHM6Ly93d3cud2FpbWFveGlhLm5ldC9sb2dpbg==

打开网址，本次的目标是登录接口，如下图
在这里插入图片描述
本文主要讲解wasm的解析，所以对其他参数不做逆向处理，本次由wasm加密的参数只有sign一个，我们跟栈查看源代码
在这里插入图片描述
从这里发现，sign由sign函数通过传入其他5个参数获得，我们查看sign函数
在这里插入图片描述
sign函数是go这个类中的一个函数，其中go中用到的_inst.exports.resume函数是wasm中的加密函数，如下图展示：
在这里插入图片描述
这就是本文需要解析的wasm文件，接着，我们寻找wasm文件的导入操作部分，全局搜索wasm，发现这个位置有通过fetch请求得到wasm文件
在这里插入图片描述
我们还原这段加载wasm的代码，并补齐then调用需要用到的Go这个类，js如下

// Copyright 2018 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
//
// This file has been modified for use by the TinyGo compiler.


	// End of polyfills for common API.

	const encoder = new TextEncoder("utf-8");
	const decoder = new TextDecoder("utf-8");
	var logLine = [];

	global.Go = class {
		constructor() {
			this._callbackTimeouts = new Map();
			this._nextCallbackTimeoutID = 1;

			const mem = () => {
				// The buffer may change when requesting more memory.
				return new DataView(this._inst.exports.memory.buffer);
			}

			const setInt64 = (addr, v) => {
				mem().setUint32(addr + 0, v, true);
				mem().setUint32(addr + 4, Math.floor(v / 4294967296), true);
			}

			const getInt64 = (addr) => {
				const low = mem().getUint32(addr + 0, true);
				const high = mem().getInt32(addr + 4, true);
				return low + high * 4294967296;
			}

			const loadValue = (addr) => {
				const f = mem().getFloat64(addr, true);
				if (f === 0) {
					return undefined;
				}
				if (!isNaN(f)) {
					return f;
				}

				const id = mem().getUint32(addr, true);
				return this._values[id];
			}

			const storeValue = (addr, v) => {
				const nanHead = 0x7FF80000;

				if (typeof v === "number") {
					if (isNaN(v)) {
						mem().setUint32(addr + 4, nanHead, true);
						mem().setUint32(addr, 0, true);
						return;
					}
					if (v === 0) {
						mem().setUint32(addr + 4, nanHead, true);
						mem().setUint32(addr, 1, true);
						return;
					}
					mem().setFloat64(addr, v, true);
					return;
				}

				switch (v) {
					case undefined:
						mem().setFloat64(addr, 0, true);
						return;
					case null:
						mem().setUint32(addr + 4, nanHead, true);
						mem().setUint32(addr, 2, true);
						return;
					case true:
						mem().setUint32(addr + 4, nanHead, true);
						mem().setUint32(addr, 3, true);
						return;
					case false:
						mem().setUint32(addr + 4, nanHead, true);
						mem().setUint32(addr, 4, true);
						return;
				}

				let id = this._ids.get(v);
				if (id === undefined) {
					id = this._idPool.pop();
					if (id === undefined) {
						id = this._values.length;
					}
					this._values[id] = v;
					this._goRefCounts[id] = 0;
					this._ids.set(v, id);
				}
				this._goRefCounts[id]++;
				let typeFlag = 1;
				switch (typeof v) {
					case "string":
						typeFlag = 2;
						break;
					case "symbol":
						typeFlag = 3;
						break;
					case "function":
						typeFlag = 4;
						break;
				}
				mem().setUint32(addr + 4, nanHead | typeFlag, true);
				mem().setUint32(addr, id, true);
			}

			const loadSlice = (array, len, cap) => {
				return new Uint8Array(this._inst.exports.memory.buffer, array, len);
			}

			const loadSliceOfValues = (array, len, cap) => {
				const a = new Array(len);
				for (let i = 0; i < len; i++) {
					a[i] = loadValue(array + i * 8);
				}
				return a;
			}

			const loadString = (ptr, len) => {
				return decoder.decode(new DataView(this._inst.exports.memory.buffer, ptr, len));
			}

			const timeOrigin = Date.now() - performance.now();
			this.importObject = {
				wasi_snapshot_preview1: {
					// https://github.com/WebAssembly/WASI/blob/main/phases/snapshot/docs.md#fd_write
					fd_write: function(fd, iovs_ptr, iovs_len, nwritten_ptr) {
						let nwritten = 0;
						if (fd == 1) {
							for (let iovs_i=0; iovs_i<iovs_len;iovs_i++) {
								let iov_ptr = iovs_ptr+iovs_i*8; // assuming wasm32
								let ptr = mem().getUint32(iov_ptr + 0, true);
								let len = mem().getUint32(iov_ptr + 4, true);
								nwritten += len;
								for (let i=0; i<len; i++) {
									let c = mem().getUint8(ptr+i);
									if (c == 13) { // CR
										// ignore
									} else if (c == 10) { // LF
										// write line
										let line = decoder.decode(new Uint8Array(logLine));
										logLine = [];
										console.log(line);
									} else {
										logLine.push(c);
									}
								}
							}
						} else {
							console.error('invalid file descriptor:', fd);
						}
						mem().setUint32(nwritten_ptr, nwritten, true);
						return 0;
					},
					fd_close: () => 0,      // dummy
					fd_fdstat_get: () => 0, // dummy
					fd_seek: () => 0,       // dummy
					"proc_exit": (code) => {
						if (global.process) {
							// Node.js
							process.exit(code);
						} else {
							// Can't exit in a browser.
							throw 'trying to exit with code ' + code;
						}
					},
					random_get: (bufPtr, bufLen) => {
						crypto.getRandomValues(loadSlice(bufPtr, bufLen));
						return 0;
					},
				},
				env: {
					// func ticks() float64
					"runtime.ticks": () => {
						return timeOrigin + performance.now();
					},

					// func sleepTicks(timeout float64)
					"runtime.sleepTicks": (timeout) => {
						// Do not sleep, only reactivate scheduler after the given timeout.
						setTimeout(this._inst.exports.go_scheduler, timeout);
					},

					// func finalizeRef(v ref)
					"syscall/js.finalizeRef": (sp) => {
						// Note: TinyGo does not support finalizers so this should never be
						// called.
						//console.error('syscall/js.finalizeRef not implemented');
                        const id = mem().getUint32(sp + 8, true);
                        this._goRefCounts[id]--;
                        if (this._goRefCounts[id] === 0) {
                            const v = this._values[id];
                            this._values[id] = null;
                            this._ids.delete(v);
                            this._idPool.push(id);
                        }
					},

					// func stringVal(value string) ref
					"syscall/js.stringVal": (ret_ptr, value_ptr, value_len) => {
						const s = loadString(value_ptr, value_len);
						storeValue(ret_ptr, s);
					},

					// func valueGet(v ref, p string) ref
					"syscall/js.valueGet": (retval, v_addr, p_ptr, p_len) => {
						let prop = loadString(p_ptr, p_len);
						let value = loadValue(v_addr);
						let result = Reflect.get(value, prop);
						storeValue(retval, result);
					},

					// func valueSet(v ref, p string, x ref)
					"syscall/js.valueSet": (v_addr, p_ptr, p_len, x_addr) => {
						const v = loadValue(v_addr);
						const p = loadString(p_ptr, p_len);
						const x = loadValue(x_addr);
						Reflect.set(v, p, x);
					},

					// func valueDelete(v ref, p string)
					"syscall/js.valueDelete": (v_addr, p_ptr, p_len) => {
						const v = loadValue(v_addr);
						const p = loadString(p_ptr, p_len);
						Reflect.deleteProperty(v, p);
					},

					// func valueIndex(v ref, i int) ref
					"syscall/js.valueIndex": (ret_addr, v_addr, i) => {
						storeValue(ret_addr, Reflect.get(loadValue(v_addr), i));
					},

					// valueSetIndex(v ref, i int, x ref)
					"syscall/js.valueSetIndex": (v_addr, i, x_addr) => {
						Reflect.set(loadValue(v_addr), i, loadValue(x_addr));
					},

					// func valueCall(v ref, m string, args []ref) (ref, bool)
					"syscall/js.valueCall": (ret_addr, v_addr, m_ptr, m_len, args_ptr, args_len, args_cap) => {
						const v = loadValue(v_addr);
						const name = loadString(m_ptr, m_len);
						const args = loadSliceOfValues(args_ptr, args_len, args_cap);
						try {
							const m = Reflect.get(v, name);
							storeValue(ret_addr, Reflect.apply(m, v, args));
							mem().setUint8(ret_addr + 8, 1);
						} catch (err) {
							storeValue(ret_addr, err);
							mem().setUint8(ret_addr + 8, 0);
						}
					},

					// func valueInvoke(v ref, args []ref) (ref, bool)
					"syscall/js.valueInvoke": (ret_addr, v_addr, args_ptr, args_len, args_cap) => {
						try {
							const v = loadValue(v_addr);
							const args = loadSliceOfValues(args_ptr, args_len, args_cap);
							storeValue(ret_addr, Reflect.apply(v, undefined, args));
							mem().setUint8(ret_addr + 8, 1);
						} catch (err) {
							storeValue(ret_addr, err);
							mem().setUint8(ret_addr + 8, 0);
						}
					},

					// func valueNew(v ref, args []ref) (ref, bool)
					"syscall/js.valueNew": (ret_addr, v_addr, args_ptr, args_len, args_cap) => {
						const v = loadValue(v_addr);
						const args = loadSliceOfValues(args_ptr, args_len, args_cap);
						try {
							storeValue(ret_addr, Reflect.construct(v, args));
							mem().setUint8(ret_addr + 8, 1);
						} catch (err) {
							storeValue(ret_addr, err);
							mem().setUint8(ret_addr+ 8, 0);
						}
					},

					// func valueLength(v ref) int
					"syscall/js.valueLength": (v_addr) => {
						return loadValue(v_addr).length;
					},

					// valuePrepareString(v ref) (ref, int)
					"syscall/js.valuePrepareString": (ret_addr, v_addr) => {
						const s = String(loadValue(v_addr));
						const str = encoder.encode(s);
						storeValue(ret_addr, str);
						setInt64(ret_addr + 8, str.length);
					},

					// valueLoadString(v ref, b []byte)
					"syscall/js.valueLoadString": (v_addr, slice_ptr, slice_len, slice_cap) => {
						const str = loadValue(v_addr);
						loadSlice(slice_ptr, slice_len, slice_cap).set(str);
					},

					// func valueInstanceOf(v ref, t ref) bool
					"syscall/js.valueInstanceOf": (v_addr, t_addr) => {
 						return loadValue(v_addr) instanceof loadValue(t_addr);
					},

					// func copyBytesToGo(dst []byte, src ref) (int, bool)
					"syscall/js.copyBytesToGo": (ret_addr, dest_addr, dest_len, dest_cap, source_addr) => {
						let num_bytes_copied_addr = ret_addr;
						let returned_status_addr = ret_addr + 4; // Address of returned boolean status variable

						const dst = loadSlice(dest_addr, dest_len);
						const src = loadValue(source_addr);
						if (!(src instanceof Uint8Array)) {
							mem().setUint8(returned_status_addr, 0); // Return "not ok" status
							return;
						}
						const toCopy = src.subarray(0, dst.length);
						dst.set(toCopy);
						setInt64(num_bytes_copied_addr, toCopy.length);
						mem().setUint8(returned_status_addr, 1); // Return "ok" status
					},

					// copyBytesToJS(dst ref, src []byte) (int, bool)
					// Originally copied from upstream Go project, then modified:
					//   https://github.com/golang/go/blob/3f995c3f3b43033013013e6c7ccc93a9b1411ca9/misc/wasm/wasm_exec.js#L404-L416
					"syscall/js.copyBytesToJS": (ret_addr, dest_addr, source_addr, source_len, source_cap) => {
						let num_bytes_copied_addr = ret_addr;
						let returned_status_addr = ret_addr + 4; // Address of returned boolean status variable

						const dst = loadValue(dest_addr);
						const src = loadSlice(source_addr, source_len);
						if (!(dst instanceof Uint8Array)) {
							mem().setUint8(returned_status_addr, 0); // Return "not ok" status
							return;
						}
						const toCopy = src.subarray(0, dst.length);
						dst.set(toCopy);
						setInt64(num_bytes_copied_addr, toCopy.length);
						mem().setUint8(returned_status_addr, 1); // Return "ok" status
					},
				}
			};
		}

		async run(instance) {
			this._inst = instance;
			this._values = [ // JS values that Go currently has references to, indexed by reference id
				NaN,
				0,
				null,
				true,
				false,
				global,
				this,
			];
			this._goRefCounts = []; // number of references that Go has to a JS value, indexed by reference id
			this._ids = new Map();  // mapping from JS values to reference ids
			this._idPool = [];      // unused ids that have been garbage collected
			this.exited = false;    // whether the Go program has exited

			const mem = new DataView(this._inst.exports.memory.buffer)

			while (true) {
				const callbackPromise = new Promise((resolve) => {
					this._resolveCallbackPromise = () => {
						if (this.exited) {
							throw new Error("bad callback: Go program has already exited");
						}
						setTimeout(resolve, 0); // make sure it is asynchronous
					};
				});
				this._inst.exports._start();
				if (this.exited) {
					break;
				}
				await callbackPromise;
			}
		}

		_resume() {
			if (this.exited) {
				throw new Error("Go program has already exited");
			}
			this._inst.exports.resume();
			if (this.exited) {
				this._resolveExitPromise();
			}
		}

		_makeFuncWrapper(id) {
			const go = this;
			return function () {
				const event = { id: id, this: this, args: arguments };
				go._pendingEvent = event;
				go._resume();
				return event.result;
			};
		}
	}
	



M = new Go

G = "https://wmx-1253696238.cos.ap-shanghai.myqcloud.com/main.wasm";
WebAssembly.instantiateStreaming(fetch(G), M.importObject).then((function(t) {
            F = t.instance,
            M.run(F)
			
			
			console.log(sign("123", "79922afce16ebe8bce34bb651eb0494f", "000000cabf2f4f37bbb10c358b865c41",
								"1X_RK3ag_IKlW15iHhSywQ==","2cc051e0c885a08dd046f1a789cffa72eddfc266f663cb2ded1ac08a5102bfe9", "1623828054"));

        }
        ))

发现，直接调用即可，完美解决sign值
在这里插入图片描述

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1389658.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

07 整合SSM的快速理解

07 整合SSM的快速理解

1.1 第一问&#xff1a;SSM整合需要几个IoC容器&#xff1f; 两个容器 本质上说&#xff0c;整合就是将三层架构和框架核心API组件交给SpringIoC容器管理&#xff01; 一个容器可能就够了&#xff0c;但是我们常见的操作是创建两个IoC容器&#xff08;web容器和root容器&…
阅读更多...
记一次小黄站渗透过程，实操！

记一次小黄站渗透过程，实操！

前言 记录某一次无意点开的一个小网站的渗透过程&#xff0c;幸运的是搭建平台是phpstudy&#xff0c;cms是beecms&#xff0c;beecms有通用漏洞&#xff0c;然后去网上找了资料&#xff0c;成功getshell并获取服务器权限。 渗透过程 无意点开一个网站&#xff0c;发现网站比…
阅读更多...
【操作系统】在阅读论文：OrcFS: Orchestrated file system for flash storage时需要补充的基础知

【操作系统】在阅读论文：OrcFS: Orchestrated file system for flash storage时需要补充的基础知

在阅读论文&#xff1a;OrcFS: Orchestrated file system for flash storage是需要补充的基础知识 这篇论文是为了解决软件层次之间的信息冗余问题 To minimize the disk traffic, the file system buffers the updates and then flushes them to the disk as a single unit, …
阅读更多...
datawhale 大模型理论基础 引言

datawhale 大模型理论基础 引言

学习地址&#xff1a;大模型理论基础 一、什么是语言模型&#xff08;Language Model) 语言模型其实是一个概率模型&#xff0c;给每一个句子列表计算一个概率值&#xff1a; p(x1​,…,xL​) 例如&#xff1a; p(the, mouse, ate, the, cheese)0.02…
阅读更多...
HPE BladeSystem c7000 现场图片

HPE BladeSystem c7000 现场图片

阅读更多...
解决若依Vue3前后端分离---路由切换时显示白屏

解决若依Vue3前后端分离---路由切换时显示白屏

解决若依Vue3前后端分离---路由切换时显示白屏 1.问题重述 解决基于Vue3若依前后端分离项目中出现的路由正常切换但是就是不显示数据的问题&#xff0c;也就是不发起网络请求的问题。 找到如下位置中AppMain.vue文件 将除了css中的代码进行替换成如下的代码。 <template&g…
阅读更多...
Python数据分析案例34——IMDB电影评论情感分析(Transformer)

Python数据分析案例34——IMDB电影评论情感分析(Transformer)

电影评论的情感分析 案例背景 很多同学对电影系列的数据都比较喜欢&#xff0c;那我就补充一下这个最经典的文本分类数据集&#xff0c;电影情感评论分析。用神经网络做。对国外的英文评论文本进行分类&#xff0c;看是正面还是负面情感。 数据集介绍 数据集&#xff1a;IMDb…
阅读更多...
C# wpf 获取控件的刷新时机

C# wpf 获取控件的刷新时机

文章目录 前言一、为何需要刷新时机&#xff1f;例子一、隐藏控件后截屏例子二、修改控件大小后做计算 二、如何实现&#xff1f;1.使用动画2.使用TaskCompletionSource 三、完整代码四、使用示例1、隐藏工具条截屏2、修改宽高后获取ActualWidth、ActualHeight 总结 前言 做wp…
阅读更多...
Codeforces Round 920 (Div. 3) F题 根号分治，后缀和，后缀和的后缀和

Codeforces Round 920 (Div. 3) F题 根号分治，后缀和，后缀和的后缀和

Problem - F - Codeforces 我看的这位UP的视频讲解 &#xff1a; Codeforces Round 920 (Div. 3) F题 根号分治 详解_哔哩哔哩_bilibili 目录 题意&#xff1a; 思路&#xff1a; 后缀和的后缀和: 后缀和的后缀和的中间段如何求&#xff1a; ———— 根号分治: 核心…
阅读更多...
2024极新生态营再出发，携手华为云点燃AI技术与商业创新的火花

2024极新生态营再出发，携手华为云点燃AI技术与商业创新的火花

“ 成功的风口是时间加产品竞争力 ” 文&#xff5c;欣桐&凯丰 编辑 | 云舒 出品&#xff5c;极新 2023年大模型获得突破性进展&#xff0c;正在带来新一轮科技革命和产业变革&#xff0c;众多头部企业在一年内完成了产品迭代、拿到多轮融资&#xff0c;初创企业更是如…
阅读更多...
Java-网络爬虫(三)

Java-网络爬虫(三)

文章目录 前言一、爬虫的分类二、跳转页面的爬取三、网页去重四、综合案例1. 案例三 上篇&#xff1a;Java-网络爬虫(二) 前言 上篇文章介绍了 webMagic&#xff0c;通过一个简单的入门案例&#xff0c;对 webMagic 的核心对象和四大组件都做了简要的说明&#xff0c;以下内容…
阅读更多...
不是人才用不起，而是AI巡检更有性价比！

不是人才用不起，而是AI巡检更有性价比！

在许多行业中&#xff0c;如煤炭、电力、化工等&#xff0c;安全生产是至关重要的。这就需要通过巡检&#xff0c;对设备运行状态进行实时监测&#xff0c;及时发现并处理潜在的安全隐患&#xff0c;从而降低事故发生的概率。但是传统的巡检方式通常依赖于人工进行&#xff0c;…
阅读更多...
odoo17 | Qweb模板简介

odoo17 | Qweb模板简介

前言 到目前为止&#xff0c;我们的房地产模块的界面设计还相当有限。构建列表视图很简单&#xff0c;因为只需要字段列表。表单视图也是如此&#xff1a;尽管使用了几个标签&#xff0c;如 <group>标签或 <page>标签 &#xff0c;但在设计方面几乎没什么可做的。…
阅读更多...
【Java数据结构】04-图（Prim,Kruskal,Dijkstra,topo）

【Java数据结构】04-图（Prim,Kruskal,Dijkstra,topo）

5 图 推荐辅助理解 【视频讲解】bilibili Dijkstra Prim 【手动可视化】Algorithm Visualizer &#xff08;https://algorithm-visualizer.org/&#xff09; 【手动可视化】Data Structure Visualizations (https://www.cs.usfca.edu/~galles/visualization/Algorithms.ht…
阅读更多...
Python 捕获异常（Try Except Exception）

Python 捕获异常（Try Except Exception）

目录 前言 常见的十类异常类型&#xff1a; try...except...else语句 格式 示例1 示例2 捕获所有异常&#xff08;常用&#xff09; 格式 示例 try...except...finally语句 格式 示例 前言 异常捕获就是针对某一部分可能出错的代码&#xff0c;在运行期间一旦出现…
阅读更多...
免费开源OCR 软件Umi-OCR

免费开源OCR 软件Umi-OCR

Umi-OCR 是一款免费、开源、可批量的离线 OCR 软件&#xff0c;基于 PaddleOCR&#xff0c;适用于 Windows10/11 平台 免费&#xff1a;本项目所有代码开源&#xff0c;完全免费。方便&#xff1a;解压即用&#xff0c;离线运行&#xff0c;无需网络。高效&#xff1a;自带高效…
阅读更多...
Dhcp中继ensp

Dhcp中继ensp

拓扑图 <Huawei>system-view [Huawei]sysname SW1 [SW1]vlan batch 10 20 [SW1]int e0/0/1 #配置access接口 [SW1-Ethernet0/0/1]port link-type access [SW1-Ethernet0/0/1]port default vlan 10 [SW1-Etherne…
阅读更多...
基于4G数采终端的供热管网在线监测方案

基于4G数采终端的供热管网在线监测方案

我国大部地区全面进入到冬季&#xff0c;北方各地已开启冬季供暖&#xff0c;以保障居民生活所需。由于城市化的发展&#xff0c;城市内各供热区域愈发分散、供热管道漫长、供热环境复杂&#xff0c;对于供热管网及换热站点的监测和维护提出了诸多挑战。 方案介绍 针对提高供热…
阅读更多...
0、C++预备知识

0、C++预备知识

文章目录 C与C语言为什么要学习CC为什么难学c值得学习的新特征C参考书籍开发工具 可移植性和标准程序创建的技巧编译和链接 C与C语言 C是一种计算机高级程序设计语言&#xff0c;C既可以进行C语言的过程化程序设计&#xff0c;又可以进行以抽象数据类型为特点的基于对象的程序…
阅读更多...
强化学习11——DQN算法

强化学习11——DQN算法

DQN算法的全称为&#xff0c;Deep Q-Network&#xff0c;即在Q-learning算法的基础上引用深度神经网络来近似动作函数 Q ( s , a ) Q(s,a) Q(s,a) 。对于传统的Q-learning&#xff0c;当状态或动作数量特别大的时候&#xff0c;如处理一张图片&#xff0c;假设为 210 160 3 …
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023