JS逆向入门案例-某花顺股票数据（hexin-v）-07

已于 2025-04-08 20:51:04 修改
阅读量1k 收藏 31
点赞数 35
分类专栏： 爬虫逆向 js逆向入门案例 文章标签： javascript 前端 开发语言
于 2024-10-18 16:06:40 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_53444631/article/details/143054248
版权

文章目录

    • 概要
    • 整体架构流程
    • 小结

概要

提示：仅供学习，不得用做商业交易，如有侵权请及时联系！

逆向：某花顺股票数据

URL：aHR0cHM6Ly9xLjEwanFrYS5jb20uY24v

目的：hexin-v（cookie）

整体架构流程

提示：分析-调试-猜想-实现-执行

一、hook进行断点

	(function () {
	  'use strict';
	  var cookieTemp = '';
	  Object.defineProperty(document, 'cookie', {
	    set: function (val) {
	      if (val.indexOf('v') != -1) {
	        debugger;
	      }
	      console.log('Hook捕获到cookie设置->', val);
	      cookieTemp = val;
	      return val;
	    },
	    get: function () {
	      return cookieTemp;
	    },
	  });
	})();

在这里插入图片描述

继续往上跟栈，找到值生成的地方：

在这里插入图片描述
二、这里我们直接补环境，直接将该js文件全部扣下到node里面，并挂上代理：

my_Proxy = function (obj_, obj_name, proxy=true) {
   function set_traverse_object(tarrget, obj, recursion_layers) {
       recursion_layers -= 1;
       console.log();
       for (let prop in obj) {
           const value = obj[prop];
           const tg_name = `${tarrget}.${prop.toString()}`;
           const value_type = get_value_type(value);
           if (value && value_type === "object" && recursion_layers >= 1) {
               set_traverse_object(tg_name, value, recursion_layers);
               continue
           }
           if (value && value.toString() !== '[object Object]') {
               console.log(`setter  hook->${tg_name};  value-> ${value};  typeof-> ${value_type}`);
               continue
           }
           console.log(`setter  hook->${tg_name};  value-> ${value};  typeof-> ${value_type}\n`)
       }
   }

   function new_handel(target_name, obj, number) {
       return new Proxy(obj, my_handler(target_name, number))
   }

   function get_value_type(value) {
       if (Array.isArray(value)) {
           return 'Array'
       }
       return typeof value;
   }

   function my_handler(target_name, number) {
       return {
           set: function (obj, prop, value) {
               const value_type = get_value_type(value);
               const tg_name = `${target_name}.${prop.toString()}`;

               if (value && value_type === "object") {
                   set_traverse_object(tg_name, value, number)
               } else {
                   console.log(`setter  hook->${tg_name};  value-> ${value};  typeof-> ${value_type}`)
               }
               return Reflect.set(obj, prop, value);
           },
           get: function (obj, prop) {
               const tg_name = `${target_name}.${prop.toString()}`;
               const value = Reflect.get(obj, prop);
               let value_type = get_value_type(value);
               if (value && value_type === 'object') {
                   return new_handel(tg_name, value, number)
               }
               console.log(`getter  hook->${tg_name};  value-> ${value};  typeof-> ${value_type}\n`);
               return value
           },
           deleteProperty(target, propKey) {
               // 没有实现链式输出
               let result = Reflect.deleteProperty(target, propKey);
               let value_type = get_value_type(result);

               console.log(`delete hook-> ${propKey}, result-> ${result};  typeof-> ${value_type}\n`);
               return result;
           }
       }
   }
   if (!(proxy === true)){
       return obj_;
   }
   return new Proxy(obj_, my_handler(obj_name, 30));
};
function monitorWindow(obj, obj_str) {
   // 设置打印字符串长度
   const MAX_VALUE_LENGTH = 70;
   /**
    截取 value 值，用于在日志中输出时限制字符串长度，避免日志过长。
    @param {Object} value - 需要被截取的值。
    @returns {Object} 返回截取后的字符串值。
    */
   function truncateValue(value) {
       if (typeof value === "string" && value.length > MAX_VALUE_LENGTH) {
           return value.substring(0, MAX_VALUE_LENGTH) + "...";
       }

       if (typeof value !== "object") {
           return value;
       }

       const keys = Object.keys(value);
       const result = {};

       if (keys.length > 2) {
           result[keys[0]] = value[keys[0]].toString().substring(0, MAX_VALUE_LENGTH) + "...";
       }

       return "{" + Object.entries(result).map(([k,v])=>`${k}: ${v}`).join(", ") + "}";
   }

   /**
    序列化 value 值，用于在日志中输出时处理对象或方法。
    @param {Object} value - 需要被序列化的值。
    @returns {Object} 返回序列化后的字符串值。
    */
   function serializeValue(value) {
       if (typeof value === "object") {
           try {
               return JSON.stringify(value);
           } catch {
               return value;
           }
       }
       return value;
   }

   /**
    * 创建代理处理程序，用于对被代理对象的属性访问、属性设置、方法调用等进行监听并打印操作日志。
    * @param {Object} name - 对象名。
    * @returns {Object} 返回代理处理程序。
    */
   function createHandler(name) {

       function shouldSkipKey(key, name) {

           if (key === 'window' || key === 'self' || key === 'global' || key === 'globalThis' || key === name || key === "_globalObject") {
               return true;
           }

           if (typeof key === 'string' && (key.startsWith('__') || key.endsWith('__'))) {
               return true;
           }

           return String(key) === "Symbol(impl)" || String(key) === "Element" || String(key) === "prototype" || truncateValue(serializeValue(name)).includes("Symbol(impl)");

       }
       return {
           get(target, key, receiver) {
               // 打印调用栈
               // console.log(new Error().stack);
               // target=Object.defineProperty(target)
               // 获取属性值

               const value = target[key];

               // 不打印toString和valueOf特定的信息
               if (key === Symbol.unscopables || key === 'toString' || key === 'valueOf') {
                   return Reflect.get(target, key, receiver);
               }

               // 内部属性
               if (shouldSkipKey(key, name)) {
                   // debugger
                   if (typeof key != 'number') {
                       console.log(`访问: "${(String(key) + "\"内部属性").padEnd(28, " ")}|"${(truncateValue(serializeValue(name)) + "\"对象").padEnd(50, " ")}|值=`, truncateValue(serializeValue(value)));
                   }
                   
                   return value;
               }

               // 处理代理函数的构造函数
               if (typeof value === 'function' && value.hasOwnProperty('prototype')) {
                   try {
                       new value
                       // console.log(`调用了构造函数: ${String(key).padEnd(22, " ")} |"参数": ${JSON.stringify(value)}`);
                       return new Proxy(value,createHandler(`${String(name)}.${String(key)}`))
                   } catch (e) {}
               }

               // 处理代理对象的属性访问和设置()
               if (typeof value === 'function' && !value.hasOwnProperty('prototype')) {
                   return function getFunc(...args) {
                       try {
                           var result = Reflect.apply(value, target, args);
                           console.log(`调用了函数: ${(String(key)).padEnd(27, " ")}|"${(truncateValue(serializeValue(name)) + "\"对象").padEnd(50, " ")}|参数= ${truncateValue(serializeValue(args))}`);
                           return result
                       } catch (e) {// return  Reflect.apply(value, target, args[1])
                       }
                   }
               }

               // 处理代理对象的属性访问和设置(递归调用)
               if (value != null && (typeof value === 'object')) {
                   if ('number' === typeof key) {
                       console.log('key:', key);
                       console.log(`访问: "${(String(key) + "\"属性").padEnd(30, " ")}|"${(truncateValue(serializeValue(name)) + "\"对象").padEnd(50, " ")}|值=`, truncateValue(serializeValue(value)));
                   }
                   
                   return new Proxy(value,createHandler(`${String(name)}.${String(key)}`));
               }

               if (typeof value === 'function') {
                   // 在Node上和windows有些差异,node有函数也有prototype,所以需要继续回调
                   return new Proxy(value,createHandler(`${String(name)}.${String(key)}`));
               } else {
                   // 不进行代理的属性或方法
                   if (key != 'toJSON') {
                       console.log(`获取: "${(String(key) + "\"属性").padEnd(30, " ")}|"${(truncateValue(serializeValue(name)) + "\"对象").padEnd(50, " ")}|值=`, truncateValue(serializeValue(value)));
                   }
                   
               }
               return value;
           },
           set(target, key, value, receiver) {
               // 打印调用栈
               // console.log(new Error().stack);
               console.log(`设置对象: "${(String(key) + "\"").padEnd(28, " ")}|"${(truncateValue(serializeValue(name)) + "\"对象").padEnd(50, " ")}|值=`, truncateValue(serializeValue(value)));
               return Reflect.set(target, key, value, receiver);
           },
           apply(target, thisArg, args) {
               // 打印调用栈
               // console.log(new Error().stack);
               console.log(`调用了函数: ${(String(name)).padEnd(27, " ")}|"${(truncateValue(serializeValue(name)) + "\"对象").padEnd(50, " ")}|参数= ${truncateValue(serializeValue(args))}`);
               return Reflect.apply(target, thisArg, args);
           },
           construct(target, args, newTarget) {
               // 打印调用栈
               // console.log(new Error().stack);
               console.log(`调用了构造函数: ${String(target.name).padEnd(23, " ")}|"${(truncateValue(serializeValue(name)) + "\"对象").padEnd(50, " ")}|参数= ${JSON.stringify(args)}`);
               return Reflect.construct(target, args, newTarget);
           },
       };
   }
   return new Proxy(obj,createHandler(obj_str));
};

直接搜索：var rt;,给它定义成全局变量

在这里插入图片描述

挂上代理，我们直接补上window、document、navigator、location

在这里插入图片描述

继续将undefined改为浏览器对应的值：

在这里插入图片描述

下面的自己慢慢补吧,直接划一波水，帖一波最后的环境值：

window = global;
addEventListener = function () { };
document = {
    head: {},
    getElementsByTagName: function (res) {
        return []
    },
    createElement: function (res) {
        if (res === 'canvas') {
            return {
                getContext: function (res) {
                    if (res === 'webgl2') {
                        return {}
                    }
                }
            }
        }
        return {}
    },
    addEventListener: function () { },
    documentElement:{}
};
navigator = {
    plugins: {
        length: 2,
        '0': {
            name:'Chromium PDF Plugin'
        },
        '1': {
            name:'Chromium PDF Viewer'
        }
    },
    userAgent: 'Mozilla/5.0 (Windows NT 10.0; JiSu) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/118.3.1.7 Safari/537.36',
    javaEnabled: function () {
        return false
    },
    webdriver: false,
    doNotTrack: null,
    language: 'zh-CN',
    languages: ['zh-CN', 'zh'],
    platform: 'Win32',
    vendor: 'Google Inc.',
    appVersion:'5.0 (Windows NT 10.0; JiSu) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/118.3.1.7 Safari/537.36'
};
location = {
    "ancestorOrigins": {},
    "href": "https://脱密处理/",
    "origin": "https://脱密处理",
    "protocol": "https:",
    "host": "脱密处理",
    "hostname": "脱密处理",
    "port": "",
    "pathname": "/",
    "search": "",
    "hash": ""
};
XMLHttpRequest = function () { }
window.hasOwnProperty_ = hasOwnProperty;
hasOwnProperty = function (res) {
    if (res === 'fetch') {
        return true
    }
    return window.hasOwnProperty_(res)
}
Window = function () {
    
}

在这里插入图片描述

三、最终就是实现python

在这里插入图片描述

小结

提示：学习交流群：v:wzwzwz0613拉进群

【2022-07-06】某问财请求头参数hexin-v分析
不愿意透露姓名的网友
03-16 2612
网站： 二、分析 随便搜索一些东西，我们看到请求头中有加密参数,我们发现这个参数和cookie中的v是相同的。 我们全局搜索这个参数,没有匹配到 那么我们可以通过hook来hook headers里的，或者hook cookie里的v，这里我们hook这个参数，打开fiddler注入hook代码 重新搜索抓包，成功定位到，s就是结果 s是D()生成的，进入D函数，打断点，调试 再进入，返回值就是结果，打断点，调试 进入，返回值就是结果，打断点，调试 这里还获取了一些鼠标键盘时间，然后加密的，进入
同花顺某v参数详解
qq_44902227的博客
07-14 2300
声明本文章中所有内容仅供学习交流，抓包内容、敏感网址、数据接口均已做脱敏处理，严禁用于商业用途和非法用途，否则由此产生的一切后果均与作者无关，若有侵权，请联系我立即删除！目标站点：aHR0cDovL3EuMTBqcWthLmNvbS5jbi8= 通过抓包，查看，在headers中有一个hexin-v,也是Cookie中的v，经过测试，是动态发生变化的 这里我们直接hook 通过调用栈，在c这里已经生成了 继续往上回溯，来到这么一个地方 打上断点，单步进入，发现D函数是调用O函数，O函数就在上边 O函数
hexin-v参数的生成方式，可以解决同X顺的参数问题。
03-04
hexin-v参数的生成方式，可以解决同X顺的参数问题。
同花顺（股市）爬虫
qq_43704986的博客
07-11 5304
爬取同花顺（http://q.10jqka.com.cn） 站点前20页股市数据并存储在xlsx文件 难度 中 逆向参数 hexin-v =>>刷新一次会有有效次数 import copy import requests import pandas as pd from tqdm import tqdm from parsel import Selector headers = { 'hexin-v': '嘻嘻', 'User-Agent': 'Mozilla/5.0 (Wi
JS逆向-基础入门案例(详细步骤)
最新发布
金灰的博客
03-21 2012
免责声明：本文仅用于学习和研究目的，不鼓励或支持任何非法活动。所有技术内容仅供个人技术提升使用，未经授权不得用于攻击、侵犯或破坏他人系统。我不对因使用本文内容而引起的任何法律责任或损失承担责任。所谓js逆向，常说补环境，扣代码。首先找到加密数据的入口，比如登录密码通过一个函数加密的，那这就是加密的入口，函数肯定还会调用其他函数，我们要将其缺失的函数，变量等补齐，扣下来就好了。（补环境）这样就能让其主加密函数执行了呀。（我们就拿到web加密某字段的代码了）基基础案例，入门案例，大佬跳过~
Hexin-v cookies
leaon的博客
04-24 417
但是当我断下来之后第二次调试，发现断点没了，经摸索得知，每次加载的代码变量是动态变化的，于是我把代码整体抽到浏览器片段里面调试。总结: 对于混淆的代码，如果不进行AST解混淆,那么要进行调试必须得抽取代码，模拟当时环境调试。因为是在cookie里面的，所以在植入之前必定有setCookie 函数的调用。同样找到刚才这个位置，虽然混淆了，调试的时候在内存中能看到函数名hexin-v。但是多次调试之后我发现，明面上存在setcookie的都不是关键函数。这里有个关键的加密函数，它是字节码打乱了，然后还原。
hexin-v(cookie)还原
china-mogul
09-25 4632
再一次抓取目前所收录的所有股票过程中，遇到了一个小小的技术难题，那就是发现的hexin-v参数是实时生成的，所以我们需要不断的去获取该参数，以达到全部信息抓取的目的。 首先我们通过hook技术，很轻易的获取到了这个cookie设置生成的地方。 Object.defineProperty(document, 'cookie', { set: function(val) { debugger; re
python爬虫js逆向-问财的cookie（Hexin-V）
akkkk0的博客
10-25 2684
今天我们来爬取问财的股票信息：查看当天的股票涨跌数据。关键在于：有一个Hexin-V的加密参数（也是cookie中v的值）。
JS逆向-同花顺问财hexin-v参数
yinyunan1210的专栏
12-04 2362
进一步观察，发下每次请求的hexin-v参数，跟cookie里的v字段值一模一样。最终发现同花顺的问财里头，可以拿到计算好的结果，那就写个爬虫呗。通过上图，可以看到t就是我们的目标，继续往上看，可以跟踪到D函数中的rt.update()仔细观察3处有个参数hexin-v，就是我们这次的目标了，每次请求都会改变。既然已找到目标，那可以用rpc直接调用，也可以直接扣代码再补环境了。考虑到法律问题，就不放源码了，最终的js文件如下图。至此，已经找到实现的地方了，接下来只要实现就行。
股市数据采集js逆向解决hexin-v cookie 解决失效后自动更新复刻核心算法
weixin_47481982的博客
11-01 3600
股票js逆向，全解析，js调用实现无限次数请求
C#获取同花顺，问财V（hexin-v）值
cyberarmy的专栏
07-06 1968
没得这个参数想通过 get/post方式从问财获取数据获取不到，只有搞到这个参数才可以。是js生成的，扣出来很麻烦，那么我们可以不扣，直接用。用 webkit 打开，然后从cookie里获取这个值，拿到这个值之后。再去post，get就可以了。重要代码： c#Winform问财数据获取源码（包括v值获取）-C#文档类资源-CSDN下载...
c# Winform 问财数据获取源码（包括v值获取）
07-06
同花顺问财v值获取（hexin-v），获取后可通过get/post方式获取问财数据 目前只能获取某个条件搜索出来的前50条数据。可以添加多个搜索条件。 项目含搜索数据展示，过滤，excel保存等。
某网站hexin-v的解决方法，hexin-v的解密方法，hexin-v的生成方法
weixin_42792355的博客
08-13 1208
本想偷偷懒从网络上找一下解决方案，发现都是较早之前的算法了。虽然代码经过了混淆，但是通过断点调试，还是有迹可循。以前研究过某度的贴吧，某巴巴的网站的搜索，发现这个js功能和其他大型网站相比，都是大同小异。无非是对服务器时间，鼠标位置，浏览器版本等进行加密后提交。服务器解密字符串后，对比一下时间，严格一点的对比浏览器版本，鼠标等信息，不符合情况则直接pass。结果发现某个js页面有变化，以原有的hexin-v生成方法，已经不能适用于最新的算法。搞定，漫长的调试过程终于结束了。苦逼的调试结束后，扣取核心代码。
同花顺数据获取思路及算法
qq_43704986的博客
04-14 2211
同花顺爬虫 js逆向经验分享 ob混淆 jsvm 控制流
python爬虫之js逆向案例教学
空城的博客
12-09 2640
本节主要围绕一个案例来对js逆向的深入了解，
JS逆向案例(allchips)
qq_42519299的博客
09-27 566
js加密
js逆向实战案例集目录
博客
08-12 2301
该篇为js逆向实战案例集目录
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值