Python逆向爬虫入门教程03: 某千音乐加密参数 sign 逆向解析

最新推荐文章于 2025-04-16 11:44:01 发布
最新推荐文章于 2025-04-16 11:44:01 发布
阅读量1.3k 收藏 12
点赞数 7
CC 4.0 BY-SA版权
文章标签： python 爬虫 开发语言 逆向爬虫
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/fei347795790/article/details/135426792

前言💥

本文的文字及图片来源于网络,仅供学习、交流使用,不具有任何商业用途,如有问题请及时联系我们以作处理。

前文内容💥

Python逆向爬虫入门教程01: 某狗音乐加密参数signature逆向解析
Python逆向爬虫入门教程02: 某易音乐加密参数 params & encSecKey 逆向解析

数据来源分析💥

网站链接: aHR0cHM6Ly9tdXNpYy45MXEuY29tLw==

音乐数据包分析💥

  1. 正常流程抓包分析数据, 找到音频链接
    在这里插入图片描述
  2. 找到歌曲对应的数据包位置
    在这里插入图片描述
    在这里插入图片描述
  3. 找到 sign 加密位置

在这里插入图片描述
在这里插入图片描述
看到这里 MD5 又是 32位的 感觉是是正常的md5加密, 其实他不是的, 可以找一个MD5在线加密的测试一下, 发现好像不是, 那就只能去扣代码了, 这个代码还挺好扣的
在这里插入图片描述

JS代码💥

var commonjsGlobal = "undefined" != typeof globalThis ? globalThis : "undefined" != typeof window ? window : void 0 !== global ? global : "undefined" != typeof self ? self : {};

function createCommonjsModule(e, t) {
    return e(t = {
        exports: {}
    }, t.exports),
        t.exports
}

var md5 = createCommonjsModule((function (module) {
        !function () {
            var ERROR = "input is invalid type"
                , WINDOW = "object" == typeof window
                , root = WINDOW ? window : {};
            root.JS_MD5_NO_WINDOW && (WINDOW = !1);
            var WEB_WORKER = !WINDOW && "object" == typeof self
                ,
                NODE_JS = !root.JS_MD5_NO_NODE_JS && "object" == typeof process && process.versions && process.versions.node;
            NODE_JS ? root = commonjsGlobal : WEB_WORKER && (root = self);
            var COMMON_JS = !root.JS_MD5_NO_COMMON_JS && module.exports,
                ARRAY_BUFFER = !root.JS_MD5_NO_ARRAY_BUFFER && "undefined" != typeof ArrayBuffer,
                HEX_CHARS = "0123456789abcdef".split(""), EXTRA = [128, 32768, 8388608, -2147483648],
                SHIFT = [0, 8, 16, 24], OUTPUT_TYPES = ["hex", "array", "digest", "buffer", "arrayBuffer", "base64"],
                BASE64_ENCODE_CHAR = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/".split(""),
                blocks = [], buffer8, buffer, buffer8, blocks;
            ARRAY_BUFFER && (buffer = new ArrayBuffer(68),
                buffer8 = new Uint8Array(buffer),
                blocks = new Uint32Array(buffer)),
            !root.JS_MD5_NO_NODE_JS && Array.isArray || (Array.isArray = function (e) {
                    return "[object Array]" === Object.prototype.toString.call(e)
                }
            ),
            !ARRAY_BUFFER || !root.JS_MD5_NO_ARRAY_BUFFER_IS_VIEW && ArrayBuffer.isView || (ArrayBuffer.isView = function (e) {
                    return "object" == typeof e && e.buffer && e.buffer.constructor === ArrayBuffer
                }
            );
            var createOutputMethod = function (e) {
                return function (t) {
                    return new Md5(!0).update(t)[e]()
                }
            }
                , createMethod = function () {
                var e = createOutputMethod("hex");
                NODE_JS && (e = nodeWrap(e)),
                    e.create = function () {
                        return new Md5
                    }
                    ,
                    e.update = function (t) {
                        return e.create().update(t)
                    }
                ;
                for (var t = 0; t < OUTPUT_TYPES.length; ++t) {
                    var n = OUTPUT_TYPES[t];
                    e[n] = createOutputMethod(n)
                }
                return e
            }
                , nodeWrap = function (method) {
                var crypto = eval("require('crypto')")
                    , Buffer = eval("require('buffer').Buffer")
                    , nodeMethod = function (e) {
                    if ("string" == typeof e)
                        return crypto.createHash("md5").update(e, "utf8").digest("hex");
                    if (null == e)
                        throw ERROR;
                    return e.constructor === ArrayBuffer && (e = new Uint8Array(e)),
                        Array.isArray(e) || ArrayBuffer.isView(e) || e.constructor === Buffer ? crypto.createHash("md5").update(new Buffer(e)).digest("hex") : method(e)
                };
                return nodeMethod
            };

            function Md5(e) {
                var t;
                e ? (blocks[0] = blocks[16] = blocks[1] = blocks[2] = blocks[3] = blocks[4] = blocks[5] = blocks[6] = blocks[7] = blocks[8] = blocks[9] = blocks[10] = blocks[11] = blocks[12] = blocks[13] = blocks[14] = blocks[15] = 0,
                    this.blocks = blocks,
                    this.buffer8 = buffer8) : ARRAY_BUFFER ? (t = new ArrayBuffer(68),
                    this.buffer8 = new Uint8Array(t),
                    this.blocks = new Uint32Array(t)) : this.blocks = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
                    this.h0 = this.h1 = this.h2 = this.h3 = this.start = this.bytes = this.hBytes = 0,
                    this.finalized = this.hashed = !1,
                    this.first = !0
            }

            Md5.prototype.update = function (e) {
                if (!this.finalized) {
                    var t, n = typeof e;
                    if ("string" != n) {
                        if ("object" != n)
                            throw ERROR;
                        if (null === e)
                            throw ERROR;
                        if (ARRAY_BUFFER && e.constructor === ArrayBuffer)
                            e = new Uint8Array(e);
                        else if (!(Array.isArray(e) || ARRAY_BUFFER && ArrayBuffer.isView(e)))
                            throw ERROR;
                        t = !0
                    }
                    for (var r, i, s = 0, o = e.length, a = this.blocks, u = this.buffer8; s < o;) {
                        if (this.hashed && (this.hashed = !1,
                            a[0] = a[16],
                            a[16] = a[1] = a[2] = a[3] = a[4] = a[5] = a[6] = a[7] = a[8] = a[9] = a[10] = a[11] = a[12] = a[13] = a[14] = a[15] = 0),
                            t)
                            if (ARRAY_BUFFER)
                                for (i = this.start; s < o && i < 64; ++s)
                                    u[i++] = e[s];
                            else
                                for (i = this.start; s < o && i < 64; ++s)
                                    a[i >> 2] |= e[s] << SHIFT[3 & i++];
                        else if (ARRAY_BUFFER)
                            for (i = this.start; s < o && i < 64; ++s)
                                (r = e.charCodeAt(s)) < 128 ? u[i++] = r : (r < 2048 ? u[i++] = 192 | r >> 6 : (r < 55296 || 57344 <= r ? u[i++] = 224 | r >> 12 : (r = 65536 + ((1023 & r) << 10 | 1023 & e.charCodeAt(++s)),
                                    u[i++] = 240 | r >> 18,
                                    u[i++] = 128 | r >> 12 & 63),
                                    u[i++] = 128 | r >> 6 & 63),
                                    u[i++] = 128 | 63 & r);
                        else
                            for (i = this.start; s < o && i < 64; ++s)
                                (r = e.charCodeAt(s)) < 128 ? a[i >> 2] |= r << SHIFT[3 & i++] : (r < 2048 ? a[i >> 2] |= (192 | r >> 6) << SHIFT[3 & i++] : (r < 55296 || 57344 <= r ? a[i >> 2] |= (224 | r >> 12) << SHIFT[3 & i++] : (r = 65536 + ((1023 & r) << 10 | 1023 & e.charCodeAt(++s)),
                                    a[i >> 2] |= (240 | r >> 18) << SHIFT[3 & i++],
                                    a[i >> 2] |= (128 | r >> 12 & 63) << SHIFT[3 & i++]),
                                    a[i >> 2] |= (128 | r >> 6 & 63) << SHIFT[3 & i++]),
                                    a[i >> 2] |= (128 | 63 & r) << SHIFT[3 & i++]);
                        this.lastByteIndex = i,
                            this.bytes += i - this.start,
                            64 <= i ? (this.start = i - 64,
                                this.hash(),
                                this.hashed = !0) : this.start = i
                    }
                    return 4294967295 < this.bytes && (this.hBytes += this.bytes / 4294967296 << 0,
                        this.bytes = this.bytes % 4294967296),
                        this
                }
            }
                ,
                Md5.prototype.finalize = function () {
                    var e, t;
                    this.finalized || (this.finalized = !0,
                        (e = this.blocks)[(t = this.lastByteIndex) >> 2] |= EXTRA[3 & t],
                    56 <= t && (this.hashed || this.hash(),
                        e[0] = e[16],
                        e[16] = e[1] = e[2] = e[3] = e[4] = e[5] = e[6] = e[7] = e[8] = e[9] = e[10] = e[11] = e[12] = e[13] = e[14] = e[15] = 0),
                        e[14] = this.bytes << 3,
                        e[15] = this.hBytes << 3 | this.bytes >>> 29,
                        this.hash())
                }
                ,
                Md5.prototype.hash = function () {
                    var e, t, n, r, i, s = this.blocks,
                        o = this.first ? ((o = ((e = ((e = s[0] - 680876937) << 7 | e >>> 25) - 271733879 << 0) ^ (t = ((t = (-271733879 ^ (n = ((n = (-1732584194 ^ 2004318071 & e) + s[1] - 117830708) << 12 | n >>> 20) + e << 0) & (-271733879 ^ e)) + s[2] - 1126478375) << 17 | t >>> 15) + n << 0) & (n ^ e)) + s[3] - 1316259209) << 22 | o >>> 10) + t << 0 : (e = this.h0,
                            o = this.h1,
                            t = this.h2,
                        ((o += ((e = ((e += ((n = this.h3) ^ o & (t ^ n)) + s[0] - 680876936) << 7 | e >>> 25) + o << 0) ^ (t = ((t += (o ^ (n = ((n += (t ^ e & (o ^ t)) + s[1] - 389564586) << 12 | n >>> 20) + e << 0) & (e ^ o)) + s[2] + 606105819) << 17 | t >>> 15) + n << 0) & (n ^ e)) + s[3] - 1044525330) << 22 | o >>> 10) + t << 0);
                    o = ((o += ((e = ((e += (n ^ o & (t ^ n)) + s[4] - 176418897) << 7 | e >>> 25) + o << 0) ^ (t = ((t += (o ^ (n = ((n += (t ^ e & (o ^ t)) + s[5] + 1200080426) << 12 | n >>> 20) + e << 0) & (e ^ o)) + s[6] - 1473231341) << 17 | t >>> 15) + n << 0) & (n ^ e)) + s[7] - 45705983) << 22 | o >>> 10) + t << 0,
                        o = ((o += ((e = ((e += (n ^ o & (t ^ n)) + s[8] + 1770035416) << 7 | e >>> 25) + o << 0) ^ (t = ((t += (o ^ (n = ((n += (t ^ e & (o ^ t)) + s[9] - 1958414417) << 12 | n >>> 20) + e << 0) & (e ^ o)) + s[10] - 42063) << 17 | t >>> 15) + n << 0) & (n ^ e)) + s[11] - 1990404162) << 22 | o >>> 10) + t << 0,
                        o = ((o += ((e = ((e += (n ^ o & (t ^ n)) + s[12] + 1804603682) << 7 | e >>> 25) + o << 0) ^ (t = ((t += (o ^ (n = ((n += (t ^ e & (o ^ t)) + s[13] - 40341101) << 12 | n >>> 20) + e << 0) & (e ^ o)) + s[14] - 1502002290) << 17 | t >>> 15) + n << 0) & (n ^ e)) + s[15] + 1236535329) << 22 | o >>> 10) + t << 0,
                        o = ((o += ((n = ((n += (o ^ t & ((e = ((e += (t ^ n & (o ^ t)) + s[1] - 165796510) << 5 | e >>> 27) + o << 0) ^ o)) + s[6] - 1069501632) << 9 | n >>> 23) + e << 0) ^ e & ((t = ((t += (e ^ o & (n ^ e)) + s[11] + 643717713) << 14 | t >>> 18) + n << 0) ^ n)) + s[0] - 373897302) << 20 | o >>> 12) + t << 0,
                        o = ((o += ((n = ((n += (o ^ t & ((e = ((e += (t ^ n & (o ^ t)) + s[5] - 701558691) << 5 | e >>> 27) + o << 0) ^ o)) + s[10] + 38016083) << 9 | n >>> 23) + e << 0) ^ e & ((t = ((t += (e ^ o & (n ^ e)) + s[15] - 660478335) << 14 | t >>> 18) + n << 0) ^ n)) + s[4] - 405537848) << 20 | o >>> 12) + t << 0,
                        o = ((o += ((n = ((n += (o ^ t & ((e = ((e += (t ^ n & (o ^ t)) + s[9] + 568446438) << 5 | e >>> 27) + o << 0) ^ o)) + s[14] - 1019803690) << 9 | n >>> 23) + e << 0) ^ e & ((t = ((t += (e ^ o & (n ^ e)) + s[3] - 187363961) << 14 | t >>> 18) + n << 0) ^ n)) + s[8] + 1163531501) << 20 | o >>> 12) + t << 0,
                        o = ((o += ((n = ((n += (o ^ t & ((e = ((e += (t ^ n & (o ^ t)) + s[13] - 1444681467) << 5 | e >>> 27) + o << 0) ^ o)) + s[2] - 51403784) << 9 | n >>> 23) + e << 0) ^ e & ((t = ((t += (e ^ o & (n ^ e)) + s[7] + 1735328473) << 14 | t >>> 18) + n << 0) ^ n)) + s[12] - 1926607734) << 20 | o >>> 12) + t << 0,
                        o = ((o += ((i = (n = ((n += ((r = o ^ t) ^ (e = ((e += (r ^ n) + s[5] - 378558) << 4 | e >>> 28) + o << 0)) + s[8] - 2022574463) << 11 | n >>> 21) + e << 0) ^ e) ^ (t = ((t += (i ^ o) + s[11] + 1839030562) << 16 | t >>> 16) + n << 0)) + s[14] - 35309556) << 23 | o >>> 9) + t << 0,
                        o = ((o += ((i = (n = ((n += ((r = o ^ t) ^ (e = ((e += (r ^ n) + s[1] - 1530992060) << 4 | e >>> 28) + o << 0)) + s[4] + 1272893353) << 11 | n >>> 21) + e << 0) ^ e) ^ (t = ((t += (i ^ o) + s[7] - 155497632) << 16 | t >>> 16) + n << 0)) + s[10] - 1094730640) << 23 | o >>> 9) + t << 0,
                        o = ((o += ((i = (n = ((n += ((r = o ^ t) ^ (e = ((e += (r ^ n) + s[13] + 681279174) << 4 | e >>> 28) + o << 0)) + s[0] - 358537222) << 11 | n >>> 21) + e << 0) ^ e) ^ (t = ((t += (i ^ o) + s[3] - 722521979) << 16 | t >>> 16) + n << 0)) + s[6] + 76029189) << 23 | o >>> 9) + t << 0,
                        o = ((o += ((i = (n = ((n += ((r = o ^ t) ^ (e = ((e += (r ^ n) + s[9] - 640364487) << 4 | e >>> 28) + o << 0)) + s[12] - 421815835) << 11 | n >>> 21) + e << 0) ^ e) ^ (t = ((t += (i ^ o) + s[15] + 530742520) << 16 | t >>> 16) + n << 0)) + s[2] - 995338651) << 23 | o >>> 9) + t << 0,
                        o = ((o += ((n = ((n += (o ^ ((e = ((e += (t ^ (o | ~n)) + s[0] - 198630844) << 6 | e >>> 26) + o << 0) | ~t)) + s[7] + 1126891415) << 10 | n >>> 22) + e << 0) ^ ((t = ((t += (e ^ (n | ~o)) + s[14] - 1416354905) << 15 | t >>> 17) + n << 0) | ~e)) + s[5] - 57434055) << 21 | o >>> 11) + t << 0,
                        o = ((o += ((n = ((n += (o ^ ((e = ((e += (t ^ (o | ~n)) + s[12] + 1700485571) << 6 | e >>> 26) + o << 0) | ~t)) + s[3] - 1894986606) << 10 | n >>> 22) + e << 0) ^ ((t = ((t += (e ^ (n | ~o)) + s[10] - 1051523) << 15 | t >>> 17) + n << 0) | ~e)) + s[1] - 2054922799) << 21 | o >>> 11) + t << 0,
                        o = ((o += ((n = ((n += (o ^ ((e = ((e += (t ^ (o | ~n)) + s[8] + 1873313359) << 6 | e >>> 26) + o << 0) | ~t)) + s[15] - 30611744) << 10 | n >>> 22) + e << 0) ^ ((t = ((t += (e ^ (n | ~o)) + s[6] - 1560198380) << 15 | t >>> 17) + n << 0) | ~e)) + s[13] + 1309151649) << 21 | o >>> 11) + t << 0,
                        o = ((o += ((n = ((n += (o ^ ((e = ((e += (t ^ (o | ~n)) + s[4] - 145523070) << 6 | e >>> 26) + o << 0) | ~t)) + s[11] - 1120210379) << 10 | n >>> 22) + e << 0) ^ ((t = ((t += (e ^ (n | ~o)) + s[2] + 718787259) << 15 | t >>> 17) + n << 0) | ~e)) + s[9] - 343485551) << 21 | o >>> 11) + t << 0,
                        this.first ? (this.h0 = e + 1732584193 << 0,
                            this.h1 = o - 271733879 << 0,
                            this.h2 = t - 1732584194 << 0,
                            this.h3 = n + 271733878 << 0,
                            this.first = !1) : (this.h0 = this.h0 + e << 0,
                            this.h1 = this.h1 + o << 0,
                            this.h2 = this.h2 + t << 0,
                            this.h3 = this.h3 + n << 0)
                }
                ,
                Md5.prototype.hex = function () {
                    this.finalize();
                    var e = this.h0
                        , t = this.h1
                        , n = this.h2
                        , r = this.h3;
                    return HEX_CHARS[e >> 4 & 15] + HEX_CHARS[15 & e] + HEX_CHARS[e >> 12 & 15] + HEX_CHARS[e >> 8 & 15] + HEX_CHARS[e >> 20 & 15] + HEX_CHARS[e >> 16 & 15] + HEX_CHARS[e >> 28 & 15] + HEX_CHARS[e >> 24 & 15] + HEX_CHARS[t >> 4 & 15] + HEX_CHARS[15 & t] + HEX_CHARS[t >> 12 & 15] + HEX_CHARS[t >> 8 & 15] + HEX_CHARS[t >> 20 & 15] + HEX_CHARS[t >> 16 & 15] + HEX_CHARS[t >> 28 & 15] + HEX_CHARS[t >> 24 & 15] + HEX_CHARS[n >> 4 & 15] + HEX_CHARS[15 & n] + HEX_CHARS[n >> 12 & 15] + HEX_CHARS[n >> 8 & 15] + HEX_CHARS[n >> 20 & 15] + HEX_CHARS[n >> 16 & 15] + HEX_CHARS[n >> 28 & 15] + HEX_CHARS[n >> 24 & 15] + HEX_CHARS[r >> 4 & 15] + HEX_CHARS[15 & r] + HEX_CHARS[r >> 12 & 15] + HEX_CHARS[r >> 8 & 15] + HEX_CHARS[r >> 20 & 15] + HEX_CHARS[r >> 16 & 15] + HEX_CHARS[r >> 28 & 15] + HEX_CHARS[r >> 24 & 15]
                }
                ,
                Md5.prototype.toString = Md5.prototype.hex,
                Md5.prototype.digest = function () {
                    this.finalize();
                    var e = this.h0
                        , t = this.h1
                        , n = this.h2
                        , r = this.h3;
                    return [255 & e, e >> 8 & 255, e >> 16 & 255, e >> 24 & 255, 255 & t, t >> 8 & 255, t >> 16 & 255, t >> 24 & 255, 255 & n, n >> 8 & 255, n >> 16 & 255, n >> 24 & 255, 255 & r, r >> 8 & 255, r >> 16 & 255, r >> 24 & 255]
                }
                ,
                Md5.prototype.array = Md5.prototype.digest,
                Md5.prototype.arrayBuffer = function () {
                    this.finalize();
                    var e = new ArrayBuffer(16)
                        , t = new Uint32Array(e);
                    return t[0] = this.h0,
                        t[1] = this.h1,
                        t[2] = this.h2,
                        t[3] = this.h3,
                        e
                }
                ,
                Md5.prototype.buffer = Md5.prototype.arrayBuffer,
                Md5.prototype.base64 = function () {
                    for (var e, t, n, r = "", i = this.array(), s = 0; s < 15;)
                        e = i[s++],
                            t = i[s++],
                            n = i[s++],
                            r += BASE64_ENCODE_CHAR[e >>> 2] + BASE64_ENCODE_CHAR[63 & (e << 4 | t >>> 4)] + BASE64_ENCODE_CHAR[63 & (t << 2 | n >>> 6)] + BASE64_ENCODE_CHAR[63 & n];
                    return e = i[s],
                    r + (BASE64_ENCODE_CHAR[e >>> 2] + BASE64_ENCODE_CHAR[e << 4 & 63] + "==")
                }
            ;
            var exports = createMethod();
            COMMON_JS ? module.exports = exports : root.md5 = exports
        }()
    }
))
    , secret = "0b50b02fd0d73a9c4c8c3a781c30845f";

function createSign(e) {
    if ("[object Object]" !== Object.prototype.toString.call(e))
        throw new Error("The parameter of query must be a Object.");
    var t = Math.floor(Date.now() / 1e3);
    Object.assign(e, {
        timestamp: t
    });
    var n = Object.keys(e);
    n.sort();
    for (var r = "", i = 0; i < n.length; i++) {
        var s = n[i];
        r += (0 == i ? "" : "&") + s + "=" + e[s]
    }
    return {
        sign: md5(r += secret),
        timestamp: t,
        md5: md5
    }
}

e = {
    "TSID": "T10049736422",
    "appid": 16073360
}
console.log(createSign(e))

在这里插入图片描述

Python实现代码💥

import pprint
import requests
import execjs
import time
date_time = int(time.time())
f = open('demo.js', encoding='utf-8').read()
js_code = execjs.compile(f)
link_e = {
    "word": "许嵩",
    "type": 1,
    "pageNo": 3,
    "pageSize": 20,
    "appid": 16073360,
    "timestamp": date_time
}
link_sign = js_code.call('createSign', link_e)
print(link_sign)
link = f'https://music.91q.com/v1/search?sign={link_sign["sign"]}&word=%E8%AE%B8%E5%B5%A9&type=1&pageNo=3&pageSize=20&appid=16073360&timestamp={date_time}'
headers = {
    'User-Agent':'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/119.0.0.0 Safari/537.36'
}
response = requests.get(url=link, headers=headers)
for index in response.json()['data']['typeTrack']:
    TSID = index['TSID']
    e = {
        "TSID": TSID,
        "appid": 16073360,
        "timestamp": date_time
    }
    sign = js_code.call('createSign', e)['sign']
    url = f'https://music.91q.com/v1/song/tracklink?sign={sign}&appid=16073360&TSID={TSID}&timestamp={date_time}'
    json_data = requests.get(url=url, headers=headers).json()
    pprint.pprint(json_data)
    break

在这里插入图片描述
歌曲列表获取音乐ID同样也有一个sign加密参数, 加密方式是一样的, 改一下传入的参数就可以了

嗨学编程
关注
深度解析：用 Python 爬虫逆向破解 cielo 请求头加密参数 Api-Key
小鸿的博客
09-08 1362
逆向是爬虫工程师进阶必备技能，当我们遇到一个问题时可能会有多种解决途径，而如何做出最高效的抉择又需要经验的积累。本期文章将以实战的方式，带你详细地逆向分析 cielo 请求头加密参数 Api-Key 和 Authorization 的构造逻辑，包括如何逆向分析、如何准确地找到加密入口、如何原生还原JS加密以及使用 Python 构造加密算法等
2024某Q音乐平台歌曲列表查询参数 “sign” 逆向全解析：从抓包到模拟生成
代码简单说 Vue、JAVA、PHP、Node.js 熟练运用，接口、架构、性能全搞定。
11-23 469
在当今数字化时代，音乐平台众多，每个平台都有其独特的接口和数据交互方式。逆向工程技术在理解和利用这些平台功能方面发挥着重要作用。本次逆向分析聚焦于一个音乐平台的歌曲列表查询参数“sign”，旨在揭示其生成逻辑，为可能的应用开发或数据获取提供技术支持。
qq音乐sign逆向
bboysteed的博客
05-29 1091
qq音乐sign参数逆向 1.概览
QQ音乐JS逆向爬虫，获取调皮的sign参数，我用python全都爬！
Blog沙漏在下雨
09-26 1万+
爬虫高级必然JS逆向，QQ音乐爬虫就是一个很好的练手，读完学会了直接在你女朋友面前装一手，读完你将收获到，QQ音乐JS逆向，sign参数获取，songmid参数获取，vkey参数获取，selenium自动化解析，用python解析执行js代码。
QQ音乐sign逆向分析,补环境
最新发布
qq_45703821的博客
04-16 388
获取歌曲数据接口如下测试一下，这个接口是否能返回数据这里是 POST 请求，请求的载荷在 data 中这里需要解析的是 sign，其余的可以保持不变。
某Q音乐sign逆向以及参数构造
2301_77189077的博客
12-14 2002
​ 这是第二个关于webpack的例子，现在网站确实有很多通过webpack进行打包编译的，所以这种例子也比较多，逆向的流程也比较明晰，不追求纯算的话，直接抠出加载器代码以及加密模块对应的模块代码即可。测试如果和浏览器环境生成的值不一致的话，多半是因为算法校验环境了，返回了一个错误的内容，补全一下所需环境即可。
某Q音乐sign参数逆向
m0_61046960的博客
07-27 684
声明：该文章涉及的所有案例均为学习使用，严禁用于商业用途和非法用途，否则由此产生的一切后果均与作者无关！如有侵权，请私信联系本人删帖！[21, 4, 9, 26, 16, 20, 27, 30] 然后map -> charAt -> join。[18, 11, 3, 2, 1, 7, 6, 25] 然后map -> charAt -> join。主要对call调用，fromCharCode拼接后的，*，+，^运算进行后的打印日志。1. 对data的加密由MD5加密改为了sha1加密。
js逆向分析某音乐sign参数 QQmusic
学习交流Q群：450297392
11-21 953
注意：文章仅供学习用途，请用用作其他非法盈利等商业用途！
Python逆向爬虫入门: 音乐加密参数 sign 逆向解析
weixin_45866698的博客
08-19 892
入门级逆向爬虫教程
Python爬虫入门之淘宝JS逆向解析请求参数Sign加密(一)
m0_63341362的博客
11-04 3766
关于JS逆向，相信这是很多小伙伴学习爬虫的一个门槛之一，如果你是初学者入门，开发一款爬虫，要以思路为主，代码是其次的 这里所说的思路指两个方面，一，分析观察目标站点思路，二，代码开发思路，二者缺一不可 我们来看一个需求 需求：根据用户输入任意商品或店铺名称，采集搜索结果，保存到excel表格中 是的，需求就是这么一句话，那么你能从这句话中，读到哪些有价值的信息呢？ 在我看来 如下： 用户输入任意商品 采集搜索结果(提取哪些信息数据呢？<每一种类型的数据，我们用字段表示>) .
使用Python实现阿里系某购物网站Sign参数加密
吴秋霖的博客
12-12 4900
某购物网站Sign签名参数加密分析与爬虫实战
逆向，qq音乐sign
m0_71635568的博客
10-05 1362
qq音乐sign逆向
python最新QQ音乐sign参数加密分析
qq_40718364的博客
12-20 1294
最近正在学习python爬虫，刚好拿QQ音乐练手。想要看懂文章前建议学习js逆向知识，其中断点和webpack包知识是基本。
QQ音乐评论数据JS逆向（含源码）
switch616的博客
07-11 1452
QQ音乐评论数据JS逆向解析（Webpack加密案例 含源码）
qq音乐js逆向
m0_62945506的博客
07-29 2152
最后发现同样的参数出来的结果却不一样，只能补环境了，这里一定要记得document和navigator。发现他是通过调用这个o函数，传t.data，进去生成的，那么直接扣js就可以了。顺着堆栈往上爬，找加密的位置 ，发现找了几个都不是，那么直接搜搜sign试试，昨天试了网易的js，今天就想着把qq音乐的也看看，OK，下面直接开始。发现一下就能看到，sign的赋值，那么直接进去下断点。是在window里面的，而不是单一定义的。首先抓包找接口，发现有一个sign加密。下面附上对应的Python代码。
web逆向笔记：js逆向案例四 QQ音乐 sign值（webpack打包代码如何扣取）
qq_49268524的博客
03-18 3066
webpack。
QQ音乐sign分析
记录一些web逆向的过程
11-04 1101
qq音乐sign
QQ音乐API分析之-加密参数分析(sign计算)
热门推荐
qq_23594799的博客
12-21 1万+
QQ音乐API加密参数分析1、背景2、QQ音乐sign计算3、Java代码实现4、总结 1、背景 不知道什么时候开始，各家音乐APP都开始对API进行加密，最近一段时间对六大音乐平台的加密算法进行了研究，逆向了网页端、安卓端等等，已经掌握了各家的加密算法。 平台 加密算法 非加密接口 专属资源 海外IP支持 QQ MD5 存在，可完全替代加密接口 需要绿钻Cookie 不支持，需要国内IP代理 KW DES 存在，可完全替代加密接口 不需要额外信息 支持 KG MD5 存在，不能完全
QQ音乐JS逆向分析参数,爬它,多图预警
weixin_50847719的博客
03-28 1774
昨天看一个哥们的文章说是MD5加密,自己试了试,不知道怎么出错了,所以就老老实实JS逆向了,但真的是MD5加密 分析一下要获得的参数 这次用逆推的方式,应该好理解 1.开发者模式,媒体C40000开头的就是mp3文件 或者打开全部找那个2mb以上的文件 文件点进去 guid是固定的,就只有vkey是区别每首歌的 现在找vkey在那个文件里面 轻车熟路,直接搜索vkey,下图第一个文件点开 这样,sip里面的vkey或者purl注意一下,是不是和刚刚mp3文件的网址很相似 怕你们看不清,我打印出来 ht
深入解析有道翻译sign加密与JavaScript逆向工程
总结以上知识点，我们可以看出，有道翻译sign解密和js逆向资源是网络信息安全和爬虫开发中的重要技能。掌握JavaScript逆向工程可以帮助我们深入理解web应用的工作机制，而逆向工程的技巧则是我们在面对各种加密和...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值