某花顺登录滑块逆向

zzyzy · 发表于 2025-5-31 17:02

本文章中所有内容仅供学习交流，抓包内容、敏感网址、数据接口均已做脱敏处理，严禁用于商业用途和非法用途，否则由此产生的一切后果均与作者无关，若有侵权，请联系我立即删除！

目标：实现账号登录，滑块验证，python纯算。
网站：aHR0cHM6Ly91cGFzcy4xMGpxa2EuY29tLmNuL2xvZ2luP3JlZGlyPUhUVFBfUkVGRVJFUg==

1.老样子先分析登录过程中需要的所有请求，账号密码登录，触发滑块，先是寻找获得图片的接口，分上下两部分分析整个过程，该网站会禁用f12，所以在请求之前就先打开控制台。
我们根据验证码图片的url可以找到在getprehandle请求中有我们想要的参数，后面在分析。

2.验证码触发前，主要有两次请求，getGS和dologinreturnjson2，在getGS的请求参数中可以看到是验证账号，得到dsk dsv ssv ，这些后面都会用到。

2.2在dologinreturnjson2请求中可以看到参数有点多，结果触发验证码。需要分析的参数就是uname passwd passwdsalt dsk crnd。

3.先是定位到参数生成的地方，那我直接根据参数名直接搜索，passwdsalt，这个结果会少很多，可以快速定位。跳转过来之后，在其之上就是所有参数的生成啦，太好了，源码中还有注释，直接都打上断点逐步分析、

4.登录账号先定到uname，先看uname和passwd这两个参数，加密方式还备注上了，真好，可以看到，传入账号-密码，经过thsencrypt中encode方法加密，密码的参数多做了一步处理，经过hex_md5,看名字应该是md5编码，在控制台打印测试一下，找个网站测试一下是标准的md5，这就可以不用分析js源码了，主要进thsencrypt的encode方法里面看看。单步跳进去

5.在encode中是传入三个参数直接返回函数encryptencode的结果，其中b是账号，a是密钥，c是公钥指数，返回base64格式字符串。转换成python代码。

[Python] 纯文本查看 复制代码

def encrypt_encode(plaintext: str) -> str:
    modulus_hex = ""  # 这里填入十六进制模数字符串
    exponent_hex = "10001"  # 一般是 65537 的十六进制表示
    if not modulus_hex or not exponent_hex:
        raise ValueError("modulus and publicExponent could not be null")
    modulus = int(modulus_hex, 16)
    exponent = int(exponent_hex, 16)
    key = RSA.construct((modulus, exponent))
    cipher = PKCS1_v1_5.new(key)
    plaintext_bytes = plaintext.encode('utf-8')
    encrypted_bytes = cipher.encrypt(plaintext_bytes)
    if not encrypted_bytes:
        raise ValueError("encrypt failed")

    return b64encode(encrypted_bytes).decode('utf-8')

6.先验证代码是否能用，测试是不是标准rsa，因为加密结果每次都不一样，直接测试请求，在getGS中请求参数是uname rsa_version 和crnd ，现在看一下crnd怎么生成，继续往下走，进入getSaltGs中。

7.可以看到随机数转36进制取后八位，重复两边，生成的16位只包含数字和字母的字符串，那我直接从0到9和小写字母中随机取十六位，一样的效果。

8。用生成的uname和crnd测试getGS，若是uname参数为空，返回参数错误，若加密不对，返回的dsk ssv 等都是空。
测试完接着往下分析，相对dologinreturnjson2里面还有passwdsalt 和 dsk这两个参数没有分析，dsk是getGS中里面返回。
继续往下走， postData.passwdSalt = encodeDataSaltOnce(passwdVal,unameVal);，进入encodeDataSaltOnce中，分析生成过程。

9.先到第一生成n的地方，可以看到是拿crnd + dsk，传给r.hex,r在上面定义的有，可以看到是hash 256，往下走是先把ssv进行base64解码，在传入hash后的n，函数getStrXOR中转换。
可以看到是实现两个字符串的字符逐位异或操作（XOR 操作）。转化成python代码。

[Python] 纯文本查看 复制代码

def get_str_xor(e: str, t: str) -> str:
    s = len(e)
    r = len(t)
    o = []
    for d in range(s):
        n = d % r
        xor_char = chr(ord(e[d]) ^ ord(t[n]))
        o.append(xor_char)
    return ''.join(o)

10.继续往下走，转换后的结果取等号后面作为n，作为HmacSHA256的key，r.hex_hmac是HmacSHA256，e是密码。

11.测试了一下r.hex_hmac，e先md5后在HmacSHA256，结果作为getStrXOR第一个参数，对dsv进行sha256作为第二个参数。经过getStrXOR后n的值在base64编码一下，就到了rsa加密的最终n了，函数encodeDataSaltOnce返回rsa加密的n，python慢慢一步步的还原，这样就的到了passwdSalt。

12.到现在参数都分析完啦，可以测试了，验证一下,接下来开始分析滑块的验证。

13.滑块验证的请求参数主要查看一下两个,signature是请求图片是返回的sign，可以发现，那phrase这个参数就是主要检验的了，直接搜索。

14.跳转进去可以看到url的生成规则后半部分是 (x) + ";" + inity + ";" + opt.width + ";" + opt.height;，其中opt的宽高都是定值，x是动的距离，需要看一下inity的生成，在当前js文件中搜索inity，不多很好定位。

15.可以看到inity的赋值 data.data.inity / 195 * opt.height的结果，data是getPreHandle的相应结果，opt.height写死。

16.图片的url在getPreHandle请求结果，其中请求参数都可以写死，来获得验证的图片和滑块，滑动距离的识别使用的是ddddocr，以下是python代码。

[Python] 纯文本查看 复制代码

def get_distance(bg, tp, save_path=None):
    det = DdddOcr(det=False, ocr=False, show_ad=False)
    res = det.slide_match(tp, bg, simple_target=True)
    if save_path is not None:
        # 将背景图片的二进制数据加载为Pillow Image对象
        left, top, right, bottom = res['target'][0], res['target'][1], res['target'][2], res['target'][3]
        bg_image = Image.open(io.BytesIO(bg))
        draw = ImageDraw.Draw(bg_image)
        draw.rectangle([left, top, right, bottom], outline="red", width=2)
        bg_image.save(save_path)
        logger.info(f"已保存标注后的图片到: {save_path}")
        return res
    return res

17.测试滑块验证结果，识别坐标标注的左上角和右下角，当取滑动距离时和浏览器需要的距离有一点偏差，测试一下减去个固定值就行，验证成功就可以拿到ticket了。

18.接下来就是最后一步了，来看下半部分，在验证的时候多了一些滑块验证成功后的一些参数，带上这些参数，再去验证登录，就可以啦。

验证了以下，至此结束啦，感谢观看哦，祝大家端午节快乐！！（选择甜粽子还是肉粽子呢，犒劳自己）

black8 · 发表于 2025-7-12 16:39

跟着写了一遍

[Python] 纯文本查看 复制代码

from Crypto.PublicKey import RSA
from Crypto.Cipher import PKCS1_v1_5
import base64
import binascii
import random
import string
import requests
import hashlib
import time
import os
import re
import json
import ddddocr

os.chdir(os.path.dirname(os.path.abspath(__file__)))


class TongHuaShun:
    def __init__(self):

        self.cookies = {
            'PHPSESSID': 'h8bshbcd7th1db57jv68fkgv5egmccbs',
            'ta_random_userid': 'wn37oo0s6d',
            'u_ukey': 'A10702B8689642C6BE607730E11E6E4A',
            'u_uver': '1.0.0',
            'u_dpass': '%2FAb67r3hBk7KrlRaNRP8Fo8nOcW4o2xHRZTKixnRsSR4tV%2Fe%2FNt%2FB5gJaUXHqdv0Hi80LrSsTFH9a%2B6rtRvqGg%3D%3D',
            'u_did': '0958F6AFE0D343DBA6DB466F77465C3C',
            'u_ttype': 'WEB',
            'Hm_lvt_722143063e4892925903024537075d0d': '1752116124',
            'Hm_lpvt_722143063e4892925903024537075d0d': '1752116124',
            'HMACCOUNT': '9D394D4BCA744D57',
            'Hm_lvt_929f8b362150b1f77b477230541dbbc2': '1752116124',
            'Hm_lpvt_929f8b362150b1f77b477230541dbbc2': '1752116124',
            'Hm_lvt_78c58f01938e4d85eaf619eae71b4ed1': '1752116124',
            'Hm_lpvt_78c58f01938e4d85eaf619eae71b4ed1': '1752116124',
            'ttype': 'WEB',
            'v': 'Ayfk6qtnA0xHaYfA_cFMatawsFD0rPmWVYZ_jPmdQ3Pcb0kOAXyL3mVQD1QK',
        }

        self.headers = {
            'accept': 'application/json, text/javascript, */*; q=0.01',
            'accept-language': 'zh-CN,zh;q=0.9,az;q=0.8',
            'content-type': 'application/x-www-form-urlencoded; charset=UTF-8',
            'hexin-v': 'Ayfk6qtnA0xHaYfA_cFMatawsFD0rPmWVYZ_jPmdQ3Pcb0kOAXyL3mVQD1QK',
            'origin': 'https://upass.10jqka.com.cn',
            'priority': 'u=1, i',
            'referer': 'https://upass.10jqka.com.cn/login',
            'sec-ch-ua': '"Google Chrome";v="137", "Chromium";v="137", "Not/A)Brand";v="24"',
            'sec-ch-ua-mobile': '?0',
            'sec-ch-ua-platform': '"macOS"',
            'sec-fetch-dest': 'empty',
            'sec-fetch-mode': 'cors',
            'sec-fetch-site': 'same-origin',
            'user-agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/137.0.0.0 Safari/537.36',
            'x-requested-with': 'XMLHttpRequest',
            # 'cookie': 'PHPSESSID=h8bshbcd7th1db57jv68fkgv5egmccbs; ta_random_userid=wn37oo0s6d; u_ukey=A10702B8689642C6BE607730E11E6E4A; u_uver=1.0.0; u_dpass=%2FAb67r3hBk7KrlRaNRP8Fo8nOcW4o2xHRZTKixnRsSR4tV%2Fe%2FNt%2FB5gJaUXHqdv0Hi80LrSsTFH9a%2B6rtRvqGg%3D%3D; u_did=0958F6AFE0D343DBA6DB466F77465C3C; u_ttype=WEB; Hm_lvt_722143063e4892925903024537075d0d=1752116124; Hm_lpvt_722143063e4892925903024537075d0d=1752116124; HMACCOUNT=9D394D4BCA744D57; Hm_lvt_929f8b362150b1f77b477230541dbbc2=1752116124; Hm_lpvt_929f8b362150b1f77b477230541dbbc2=1752116124; Hm_lvt_78c58f01938e4d85eaf619eae71b4ed1=1752116124; Hm_lpvt_78c58f01938e4d85eaf619eae71b4ed1=1752116124; ttype=WEB; v=Ayfk6qtnA0xHaYfA_cFMatawsFD0rPmWVYZ_jPmdQ3Pcb0kOAXyL3mVQD1QK',
        }
        self.uname = "xxx"  # 用户名
        self.passwd = "123456"  # 密码

    # 初始化时获取登录所需的参数
    def req_getGS(self):
        """
        获取登录所需的参数
        :return:
        """
        crnd = self.get_crnd()
        self.crnd = crnd  # 保存crnd以供后续使用
        data = {
            "uname": self.ras_encrypt_encode(self.uname),
            "rsa_version": "default_5",
            "crnd": crnd,
        }
        response = requests.post(
            "https://upass.10jqka.com.cn/user/getGS",
            cookies=self.cookies,
            headers=self.headers,
            data=data,
        )
        if response.status_code == 200:
            json_data = response.json()
            self.dsk = json_data.get("dsk", "")
            self.dsv = json_data.get("dsv", "")
            self.ssv = json_data.get("ssv", "")
            # print(f"getGS请求成功: dsk={self.dsk}, dsv={self.dsv}, ssv={self.ssv}, crnd={self.crnd}")
        else:
            print(f"getGS请求Error: {response.status_code} - {response.text}")

    # 执行登录请求
    def req_login(self):
        """
        登录请求
        :return:
        """
        data = {
            "uname": self.ras_encrypt_encode(self.uname),
            "passwd": self.ras_encrypt_encode(self.hex_md5(self.passwd)),
            "saltLoginTimes": "1",
            "longLogin": "on",
            "rsa_version": "default_5",
            "source": "pc_web",
            "request_type": "login",
            "captcha_type": "4",
            "upwd_score": "30",
            "ignore_upwd_score": "",
            "passwdSalt": self.encode_data_salt_once(self.passwd, self.uname),
            "dsk": self.dsk,
            "crnd": self.crnd,
            "ttype": "WEB",
            "sdtis": "C22",
            "timestamp": int(time.time() * 1000),  # 当前时间戳（毫秒）
        }
        # print(data)
        response = requests.post(
            "https://upass.10jqka.com.cn/login/dologinreturnjson2",
            cookies=self.cookies,
            headers=self.headers,
            data=data,
        )
        print("==============执行登录请求==============")
        self.print_response("登录 response", response)

        if response.status_code == 200:
            try:
                json_data = response.json()
            except Exception:
                print("返回内容不是JSON 可能是被重定向或未授权。请检查cookies和headers是否有效。")
                return
            if json_data.get("status") == "success":
                print("登录成功")
            elif json_data.get("errorcode") == -11400:
                self.captcha_solve()
            else:
                print(f"登录失败: {json_data.get('msg', '未知错误')}")
        else:
            print(f"登录请求失败，状态码: {response.status_code} 请检查cookies和headers是否有效。")

    def relogin(self):
        data = {
            "uname": self.ras_encrypt_encode(self.uname),
            "passwd": self.ras_encrypt_encode(self.hex_md5(self.passwd)),
            "saltLoginTimes": "1",
            "longLogin": "on",
            "rsa_version": "default_5",
            "source": "pc_web",
            "request_type": "login",
            "captcha_type": "4",
            'captcha_phrase': self.captcha_phrase,
            'captcha_ticket': self.captcha_tiket,
            'captcha_signature': self.captcha_sign,
            "upwd_score": "30",
            "ignore_upwd_score": "",
            "passwdSalt": self.encode_data_salt_once(self.passwd, self.uname),
            "dsk": self.dsk,
            "crnd": self.crnd,
            "ttype": "WEB",
            "sdtis": "C22",
            "timestamp": int(time.time() * 1000)  # 当前时间戳（毫秒）   
        }

        response = requests.post('https://upass.10jqka.com.cn/login/dologinreturnjson2', cookies=self.cookies, headers=self.headers, data=data)
        print("==============重新登录请求==============")
        self.print_response("重新登录 response", response)

    # 获取验证码
    def captcha_solve(self):

        params = {
            "captcha_type": "4",
            "appid": "registernew",
            "random": random.random() * int(time.time() * 1000),
            "callback": "PreHandle",
        }

        print("==============需要滑块验证码 开始识别验证码图片==============")
        response = requests.get(
            "https://captcha.10jqka.com.cn/getPreHandle",
            params=params,
            cookies=self.cookies,
            headers=self.headers,
        )
        # self.print_response("Captcha Response", response)

        if response.status_code != 200:
            print(f"获取验证码失败: {response.status_code} - {response.text}")
            return

        # 匹配 PreHandle(xxx) 并提取 xxx 内容
        match = re.search(r"PreHandle\((.*)\)", response.text)
        if match:
            json_str = match.group(1)
            try:
                data = json.loads(json_str).get("data", {})
            except Exception as e:
                print(f"解析PreHandle内容失败: {e}\n内容为: {json_str}")
                return
        else:
            print("未找到 PreHandle(xxx) 格式内容")
            return

        # 保存验证码参数到实例变量
        self.captcha_src1 = data.get("src1")
        self.captcha_src2 = data.get("src2")
        self.captcha_sign = data.get("sign")
        self.captcha_urlParams = data.get("urlParams")
        # 解析urlParams为字典
        self.captcha_urlParams_dict = (
            dict(item.split("=", 1) for item in self.captcha_urlParams.split("&"))
            if self.captcha_urlParams
            else {}
        )

        self.captcha_imgs = data.get("imgs")
        self.captcha_initx = data.get("initx")
        self.captcha_inity = data.get("inity")

        self.get_captcha_img_dis(data)
        self.captcha_verfiy()


    # 计算距离
    def get_captcha_img_dis(self, data):
        bg_url = "https://captcha.10jqka.com.cn/getImg?"+ data.get("urlParams")+ "&iuk="+ data.get("imgs", [])[0]
        slice_url = "https://captcha.10jqka.com.cn/getImg?"+ data.get("urlParams")+ "&iuk="+ data.get("imgs", [])[1]
        slide = ddddocr.DdddOcr(det=False, ocr=False, show_ad=False)
        slice_image = requests.get(slice_url).content
        bg_image = requests.get(bg_url).content
        result = slide.slide_match(slice_image, bg_image, simple_target=True)
        print(f"滑块验证码识别结果: {result}")
        self.x = result['target'][0]


    # 模拟验证码识别
    def captcha_verfiy(self):

        height = 177.22058823529412
        inity = self.captcha_inity / 195 * height

        self.captcha_phrase = str(self.x-15) + ";" + str(inity) + ";309;177.22058823529412"
        
        params = {
            "rand": self.captcha_urlParams_dict.get("rand", ""),
            "time": self.captcha_urlParams_dict.get("time", ""),
            "appid": "registernew",
            "captcha_type": "4",
            "signature": self.captcha_sign,
            "phrase": self.captcha_phrase,
            "callback": "verify",
        }
        # print(json.dumps({"滑块验证码参数": params}, ensure_ascii=False, indent=2))
        response = requests.get(
            "https://captcha.10jqka.com.cn/getTicket",
            params=params,
            cookies=self.cookies,
            headers=self.headers,
        )
        print("==============开始模拟滑动验证==============")
        self.print_response("滑块验证 Response", response)
        match = re.search(r"verify\((.*)\)", response.text)
        json_str = match.group(1)
        data = json.loads(json_str)
        if data.get("msg") == "ok":
            print(f"滑块验证成功 ticket:{data.get('ticket')}")
            # 保存验证码票据 并重新登录
            self.captcha_tiket = data.get("ticket")
            self.relogin()
        else:
            print(f"滑块验证失败: {data.get('msg', '未知错误')}")

    def encode_data_salt_once(self, e, t):
        # e: password, t: uname
        if not (self.dsk and self.dsv and self.ssv):
            return ""
        crnd = self.crnd
        sha256 = hashlib.sha256()
        sha256.update((crnd + self.dsk).encode("utf-8"))
        n = sha256.hexdigest()
        ssv_decoded = base64.b64decode(self.ssv)

        # getStrXOR: XOR two byte arrays
        def get_str_xor(a, b):
            if isinstance(a, str):
                a = a.encode()
            if isinstance(b, str):
                b = b.encode()
            return bytes([x ^ y for x, y in zip(a, b)])

        n_xor = get_str_xor(ssv_decoded, n)
        n_xor_str = n_xor.decode(errors="ignore")
        n_split = n_xor_str.split("$")
        if len(n_split) < 2:
            return ""
        n_eq = n_split[1].split("=")
        if len(n_eq) < 2:
            return ""
        n_val = n_eq[1]
        # r.hex_hmac(n_val, hex_md5(e))
        hmac_sha256 = hashlib.pbkdf2_hmac(
            "sha256", self.hex_md5(e).encode(), n_val.encode(), 1
        )
        dsv_hex = hashlib.sha256(self.dsv.encode()).hexdigest()
        n2 = get_str_xor(hmac_sha256.hex(), dsv_hex)
        n2_b64 = base64.b64encode(n2).decode()
        # thsencrypt.encode: just return as is, unless you have a custom function
        return n2_b64

    def ras_encrypt_encode(self, b):
        modulus_hex = "D90F4DD5BF444916913F7B434F192587C354387FA531F2964725B5188FB9D5B40FDDD2B34F61B5560468D1F5C568796EB15F7799F03E4A3301EAF8B79B655F1B2B7DC6FFE1084E4C14A05DD9C6D0C72C5ED75890DC5D11AB5990A3C7DEBA0D68EFFD8C619B2A21AEFA3E7FF902CDAE0502025901EE2D42B76A0D7AD389F0BF69"
        exponent_hex = "10001"
        if not modulus_hex or not exponent_hex:
            raise ValueError("modulus and publicExponent could not be null")
        modulus = int(modulus_hex, 16)
        exponent = int(exponent_hex, 16)
        rsa_key = RSA.construct((modulus, exponent))
        cipher = PKCS1_v1_5.new(rsa_key)
        encrypted = cipher.encrypt(b.encode("utf-8"))
        if not encrypted:
            raise ValueError("encrypt failed")
        hex_encrypted = binascii.hexlify(encrypted).decode("utf-8")
        b64_encrypted = base64.b64encode(binascii.unhexlify(hex_encrypted)).decode(
            "utf-8"
        )
        return b64_encrypted

    def hex_md5(self, s):
        """
        计算字符串的MD5值并返回16进制字符串
        """
        m = hashlib.md5()
        m.update(s.encode("utf-8"))
        return m.hexdigest()

    def get_crnd(self):
        crnd = "".join(
            random.choices(string.ascii_lowercase + string.digits, k=8)
        ) + "".join(random.choices(string.ascii_lowercase + string.digits, k=8))
        return crnd

    def print_response(self, prefix, response):
        """
        标准输出response结果 兼容unicode解码
        """
        try:
            text = response.text.encode("utf-8").decode("unicode_escape")
        except Exception:
            text = response.text
        print(f"{prefix}: {response.status_code} - {text}")


if __name__ == "__main__":
    t = TongHuaShun()
    t.req_getGS()  # 获取登录所需的参数
    t.req_login()  # 执行登录请求
    # 这里可以添加更多的逻辑，比如处理验证码等

星期天放假 · 发表于 2025-6-10 17:27

楼主请教一个问题，在宿主机锁屏的情况下，虚拟机用浏览器模拟浏览+鼠标模拟的方式来进行滑块验证。老是失败，但如果不锁屏，并把虚拟机系统置顶展示，就可以。。。这个应该怎么处理

天空宫阙 · 发表于 2025-5-31 18:36

暂不支持手机号密码登录[狗头]

zzyzy · 发表于 2025-5-31 19:14

天空宫阙发表于 2025-5-31 18:36
暂不支持手机号密码登录[狗头]

啊哈，这我倒是没测试

qqycra · 发表于 2025-5-31 20:54

感谢分享。十几年前开户，那时候要是买茅台我就发了，可惜啊

superzg · 发表于 2025-5-31 20:56

学习了。但没学明白。

massagebox · 发表于 2025-5-31 22:19

学习啦, 最近在学这玩意

altlife001 · 发表于 2025-6-1 00:49

这是干嘛的

williammei · 发表于 2025-6-1 11:11

老师优秀，谢谢分享

auto19 · 发表于 2025-6-1 12:26

跟到第六步就跟不下去了

fanqie8 · 发表于 2025-6-1 12:42

有时间了跟着一步步走一次

帐号		自动登录	找回密码
密码			注册[Register]

[Web逆向] 某花顺登录滑块逆向

免费评分