Python requests 考试宝爬虫js逆向分析

已于 2023-12-04 09:59:57 修改
阅读量1.1k 收藏 3
点赞数
文章标签： python 开发语言 爬虫
于 2023-11-24 17:06:29 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_51756940/article/details/134601552
版权

目录

说明

效果

登录接口

分析

实现

查询接口

分析

实现

说明

本文仅记录一次学习实验的过程。

效果

登录接口

分析

拿下登录接口是为了我们更方便的获取token 。之后搜题都是用token搜题，不再需要密码。

我们可以看到这个登录包的密码是被加密的，但是可以发现。如果密码相同，加密结果也一样，所以优先考虑对称加密。

一般情况下先尝试简单的md5这些，发现不是，只好开始抠源代码。

直接搜索关键字encrypt，出来一堆匹配结果。

凭经验点进去一个，看见ECB。百分之99就是它了，打断点。点击登录，果然断住。而且e就是输入的密码，t大家都猜到了吧，就是密钥，先复制下来。

var n = o.enc.Utf8.parse(t);通过进去分析，其实是将密钥转换为CryptoJS WordArray对象形式

而

return o.TripleDES.encrypt(e, n, {
                mode: o.mode.ECB,
                padding: o.pad.Pkcs7
            }).toString()
        }

就是加密函数了

再进去。

实现

所以可以用以下python代码复现这个过程

from Crypto.Cipher import DES3
from Crypto.Util.Padding import pad
import binascii

# 将密钥转换为CryptoJS WordArray对象形式
def string_to_word_array(s):
    utf8_encoded = s.encode('utf-8')  # 将字符串编码为 UTF-8 字节串
    words = []
    sig_bytes = len(utf8_encoded)

    for i in range(0, sig_bytes, 4):
        word = 0
        for j in range(4):
            if i + j < sig_bytes:
                word |= utf8_encoded[i + j] << (24 - j * 8)
        words.append(word)

    return {
        "words": words,
        "sigBytes": sig_bytes
    }

# TripleDES加密函数
def triple_des_encrypt(data, key):
    # 将密钥的word array转换为字节串
    key_bytes = binascii.unhexlify(''.join(f'{x:08x}' for x in key['words']))
    # 创建加密器，使用ECB模式和PKCS7填充
    cipher = DES3.new(key_bytes, DES3.MODE_ECB)
    # 对数据进行填充，并加密
    padded_data = pad(data.encode('utf-8'), DES3.block_size)
    encrypted_data = cipher.encrypt(padded_data)
    # 将加密后的数据转换为base64编码的字符串
    encrypted_data_b64 = binascii.b2a_base64(encrypted_data).decode('utf-8')
    return encrypted_data_b64.strip()

def password(data_to_encrypt):
    # 密钥字符串
    t = "AmrGowGCtUwd/2PgTyrJuV=="
    # 将密钥字符串转换为word array
    key_word_array = string_to_word_array(t)
    # 执行加密
    encrypted_data = triple_des_encrypt(data_to_encrypt, key_word_array)
    return encrypted_data

print(password("11111111"))

运行结果对比

逆向成功

查询接口

分析

首先查看查询问题的接口

请求头信息如下

Accept: xxx
Accept-Encoding: xxx
Accept-Language: xxx
Authorization: xxx
CLIENT-IDENTIFIER: xxx
Cache-Control: xxx
Connection: xxx
Content-Length: xxx
Content-Type: xxx
Cookie: xxx
Host: xxx
Origin: xxx
Pragma: xxx
Referer: xxx
Sec-Fetch-Dest: xxx
Sec-Fetch-Mode: xxx
Sec-Fetch-Site: xxx
Sign: xxx
TimeStamp: xxx
User-Agent: xxx
VERSION: xxx
platform: xxx
sec-ch-ua: xxx
sec-ch-ua-mobile: xxx
sec-ch-ua-platform: xxx

请求体信息如下

keyword: "mysql"
page: 1
paperid: ""
qtype: ""
size: 20

可以看到请求体的内容是没有加密的，所以实现身份验证的部分在请求头中。可以推测请求头中身份校验的字段可能有Authorization、CLIENT-IDENTIFIER、Cookie、Sign、TimeStamp。具体他们有什么联系，这就需要进一步进行js逆向了。

一般来说Authorization存放的是token信息，查看浏览器的localstorage可以验证这个猜想，所以重点应该是sign怎么生成的。

全局搜索关键字Sign，可以看到Sign生成的地方。

很明显可以看到Sign的生成表达式是l = no()(o + t + c + n + o)，其中o、t、c、n的含义在这个函数中都有定义。重点是这个no()(o + t + c + n + o)函数的执行逻辑。打上断点进去查看。

经过第一个函数

随后执行createOutputMethod方法

经过第二个函数

经过第三个函数

经过第四个函数

经过第五个函数

实现

把这些用到的函数全部抄下来，放到一个js文件里面然后补齐一些变量。可以得到下面的加密js。

// 辅助变量和函数定义
const HEX_CHARS = '0123456789abcdef'.split('');
const EXTRA = [128, 32768, 8388608, -2147483648,];
const SHIFT = [0, 8, 16, 24];
const ARRAY_BUFFER = true;

function Md5(append) {
    var buffer = new ArrayBuffer(68);
    var buffer8 = new Uint8Array(buffer);
    var blocks = new Uint32Array(buffer);
    if (true)
        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;
    else if (ARRAY_BUFFER) {
        var t = new ArrayBuffer(68);
        this.buffer8 = new Uint8Array(t),
            this.blocks = new Uint32Array(t)
    } else
        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)
                ;
            if (null === e)
                ;
            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 code, i, r = 0, o = e.length, l = this.blocks, c = this.buffer8; r < o;) {
            if (this.hashed && (this.hashed = !1,
                l[0] = l[16],
                l[16] = l[1] = l[2] = l[3] = l[4] = l[5] = l[6] = l[7] = l[8] = l[9] = l[10] = l[11] = l[12] = l[13] = l[14] = l[15] = 0),
                t)
                if (ARRAY_BUFFER)
                    for (i = this.start; r < o && i < 64; ++r)
                        c[i++] = e[r];
                else
                    for (i = this.start; r < o && i < 64; ++r)
                        l[i >> 2] |= e[r] << SHIFT[3 & i++];
            else if (ARRAY_BUFFER)
                for (i = this.start; r < o && i < 64; ++r)
                    (code = e.charCodeAt(r)) < 128 ? c[i++] = code : code < 2048 ? (c[i++] = 192 | code >> 6,
                        c[i++] = 128 | 63 & code) : code < 55296 || code >= 57344 ? (c[i++] = 224 | code >> 12,
                        c[i++] = 128 | code >> 6 & 63,
                        c[i++] = 128 | 63 & code) : (code = 65536 + ((1023 & code) << 10 | 1023 & e.charCodeAt(++r)),
                        c[i++] = 240 | code >> 18,
                        c[i++] = 128 | code >> 12 & 63,
                        c[i++] = 128 | code >> 6 & 63,
                        c[i++] = 128 | 63 & code);
            else
                for (i = this.start; r < o && i < 64; ++r)
                    (code = e.charCodeAt(r)) < 128 ? l[i >> 2] |= code << SHIFT[3 & i++] : code < 2048 ? (l[i >> 2] |= (192 | code >> 6) << SHIFT[3 & i++],
                        l[i >> 2] |= (128 | 63 & code) << SHIFT[3 & i++]) : code < 55296 || code >= 57344 ? (l[i >> 2] |= (224 | code >> 12) << SHIFT[3 & i++],
                        l[i >> 2] |= (128 | code >> 6 & 63) << SHIFT[3 & i++],
                        l[i >> 2] |= (128 | 63 & code) << SHIFT[3 & i++]) : (code = 65536 + ((1023 & code) << 10 | 1023 & e.charCodeAt(++r)),
                        l[i >> 2] |= (240 | code >> 18) << SHIFT[3 & i++],
                        l[i >> 2] |= (128 | code >> 12 & 63) << SHIFT[3 & i++],
                        l[i >> 2] |= (128 | code >> 6 & 63) << SHIFT[3 & i++],
                        l[i >> 2] |= (128 | 63 & code) << SHIFT[3 & i++]);
            this.lastByteIndex = i,
                this.bytes += i - this.start,
                i >= 64 ? (this.start = i - 64,
                    this.hash(),
                    this.hashed = !0) : this.start = i
        }
        return this.bytes > 4294967295 && (this.hBytes += this.bytes / 4294967296 << 0,
            this.bytes = this.bytes % 4294967296),
            this
    }
}


Md5.prototype.finalize = function () {
    if (!this.finalized) {
        this.finalized = !0;
        var e = this.blocks
            , i = this.lastByteIndex;
        e[i >> 2] |= EXTRA[3 & i],
        i >= 56 && (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 a, b, e, t, n, r, o = this.blocks;
    this.first ? b = ((b = ((a = ((a = o[0] - 680876937) << 7 | a >>> 25) - 271733879 << 0) ^ (e = ((e = (-271733879 ^ (t = ((t = (-1732584194 ^ 2004318071 & a) + o[1] - 117830708) << 12 | t >>> 20) + a << 0) & (-271733879 ^ a)) + o[2] - 1126478375) << 17 | e >>> 15) + t << 0) & (t ^ a)) + o[3] - 1316259209) << 22 | b >>> 10) + e << 0 : (a = this.h0,
        b = this.h1,
        e = this.h2,
        b = ((b += ((a = ((a += ((t = this.h3) ^ b & (e ^ t)) + o[0] - 680876936) << 7 | a >>> 25) + b << 0) ^ (e = ((e += (b ^ (t = ((t += (e ^ a & (b ^ e)) + o[1] - 389564586) << 12 | t >>> 20) + a << 0) & (a ^ b)) + o[2] + 606105819) << 17 | e >>> 15) + t << 0) & (t ^ a)) + o[3] - 1044525330) << 22 | b >>> 10) + e << 0),
        b = ((b += ((a = ((a += (t ^ b & (e ^ t)) + o[4] - 176418897) << 7 | a >>> 25) + b << 0) ^ (e = ((e += (b ^ (t = ((t += (e ^ a & (b ^ e)) + o[5] + 1200080426) << 12 | t >>> 20) + a << 0) & (a ^ b)) + o[6] - 1473231341) << 17 | e >>> 15) + t << 0) & (t ^ a)) + o[7] - 45705983) << 22 | b >>> 10) + e << 0,
        b = ((b += ((a = ((a += (t ^ b & (e ^ t)) + o[8] + 1770035416) << 7 | a >>> 25) + b << 0) ^ (e = ((e += (b ^ (t = ((t += (e ^ a & (b ^ e)) + o[9] - 1958414417) << 12 | t >>> 20) + a << 0) & (a ^ b)) + o[10] - 42063) << 17 | e >>> 15) + t << 0) & (t ^ a)) + o[11] - 1990404162) << 22 | b >>> 10) + e << 0,
        b = ((b += ((a = ((a += (t ^ b & (e ^ t)) + o[12] + 1804603682) << 7 | a >>> 25) + b << 0) ^ (e = ((e += (b ^ (t = ((t += (e ^ a & (b ^ e)) + o[13] - 40341101) << 12 | t >>> 20) + a << 0) & (a ^ b)) + o[14] - 1502002290) << 17 | e >>> 15) + t << 0) & (t ^ a)) + o[15] + 1236535329) << 22 | b >>> 10) + e << 0,
        b = ((b += ((t = ((t += (b ^ e & ((a = ((a += (e ^ t & (b ^ e)) + o[1] - 165796510) << 5 | a >>> 27) + b << 0) ^ b)) + o[6] - 1069501632) << 9 | t >>> 23) + a << 0) ^ a & ((e = ((e += (a ^ b & (t ^ a)) + o[11] + 643717713) << 14 | e >>> 18) + t << 0) ^ t)) + o[0] - 373897302) << 20 | b >>> 12) + e << 0,
        b = ((b += ((t = ((t += (b ^ e & ((a = ((a += (e ^ t & (b ^ e)) + o[5] - 701558691) << 5 | a >>> 27) + b << 0) ^ b)) + o[10] + 38016083) << 9 | t >>> 23) + a << 0) ^ a & ((e = ((e += (a ^ b & (t ^ a)) + o[15] - 660478335) << 14 | e >>> 18) + t << 0) ^ t)) + o[4] - 405537848) << 20 | b >>> 12) + e << 0,
        b = ((b += ((t = ((t += (b ^ e & ((a = ((a += (e ^ t & (b ^ e)) + o[9] + 568446438) << 5 | a >>> 27) + b << 0) ^ b)) + o[14] - 1019803690) << 9 | t >>> 23) + a << 0) ^ a & ((e = ((e += (a ^ b & (t ^ a)) + o[3] - 187363961) << 14 | e >>> 18) + t << 0) ^ t)) + o[8] + 1163531501) << 20 | b >>> 12) + e << 0,
        b = ((b += ((t = ((t += (b ^ e & ((a = ((a += (e ^ t & (b ^ e)) + o[13] - 1444681467) << 5 | a >>> 27) + b << 0) ^ b)) + o[2] - 51403784) << 9 | t >>> 23) + a << 0) ^ a & ((e = ((e += (a ^ b & (t ^ a)) + o[7] + 1735328473) << 14 | e >>> 18) + t << 0) ^ t)) + o[12] - 1926607734) << 20 | b >>> 12) + e << 0,
        b = ((b += ((r = (t = ((t += ((n = b ^ e) ^ (a = ((a += (n ^ t) + o[5] - 378558) << 4 | a >>> 28) + b << 0)) + o[8] - 2022574463) << 11 | t >>> 21) + a << 0) ^ a) ^ (e = ((e += (r ^ b) + o[11] + 1839030562) << 16 | e >>> 16) + t << 0)) + o[14] - 35309556) << 23 | b >>> 9) + e << 0,
        b = ((b += ((r = (t = ((t += ((n = b ^ e) ^ (a = ((a += (n ^ t) + o[1] - 1530992060) << 4 | a >>> 28) + b << 0)) + o[4] + 1272893353) << 11 | t >>> 21) + a << 0) ^ a) ^ (e = ((e += (r ^ b) + o[7] - 155497632) << 16 | e >>> 16) + t << 0)) + o[10] - 1094730640) << 23 | b >>> 9) + e << 0,
        b = ((b += ((r = (t = ((t += ((n = b ^ e) ^ (a = ((a += (n ^ t) + o[13] + 681279174) << 4 | a >>> 28) + b << 0)) + o[0] - 358537222) << 11 | t >>> 21) + a << 0) ^ a) ^ (e = ((e += (r ^ b) + o[3] - 722521979) << 16 | e >>> 16) + t << 0)) + o[6] + 76029189) << 23 | b >>> 9) + e << 0,
        b = ((b += ((r = (t = ((t += ((n = b ^ e) ^ (a = ((a += (n ^ t) + o[9] - 640364487) << 4 | a >>> 28) + b << 0)) + o[12] - 421815835) << 11 | t >>> 21) + a << 0) ^ a) ^ (e = ((e += (r ^ b) + o[15] + 530742520) << 16 | e >>> 16) + t << 0)) + o[2] - 995338651) << 23 | b >>> 9) + e << 0,
        b = ((b += ((t = ((t += (b ^ ((a = ((a += (e ^ (b | ~t)) + o[0] - 198630844) << 6 | a >>> 26) + b << 0) | ~e)) + o[7] + 1126891415) << 10 | t >>> 22) + a << 0) ^ ((e = ((e += (a ^ (t | ~b)) + o[14] - 1416354905) << 15 | e >>> 17) + t << 0) | ~a)) + o[5] - 57434055) << 21 | b >>> 11) + e << 0,
        b = ((b += ((t = ((t += (b ^ ((a = ((a += (e ^ (b | ~t)) + o[12] + 1700485571) << 6 | a >>> 26) + b << 0) | ~e)) + o[3] - 1894986606) << 10 | t >>> 22) + a << 0) ^ ((e = ((e += (a ^ (t | ~b)) + o[10] - 1051523) << 15 | e >>> 17) + t << 0) | ~a)) + o[1] - 2054922799) << 21 | b >>> 11) + e << 0,
        b = ((b += ((t = ((t += (b ^ ((a = ((a += (e ^ (b | ~t)) + o[8] + 1873313359) << 6 | a >>> 26) + b << 0) | ~e)) + o[15] - 30611744) << 10 | t >>> 22) + a << 0) ^ ((e = ((e += (a ^ (t | ~b)) + o[6] - 1560198380) << 15 | e >>> 17) + t << 0) | ~a)) + o[13] + 1309151649) << 21 | b >>> 11) + e << 0,
        b = ((b += ((t = ((t += (b ^ ((a = ((a += (e ^ (b | ~t)) + o[4] - 145523070) << 6 | a >>> 26) + b << 0) | ~e)) + o[11] - 1120210379) << 10 | t >>> 22) + a << 0) ^ ((e = ((e += (a ^ (t | ~b)) + o[2] + 718787259) << 15 | e >>> 17) + t << 0) | ~a)) + o[9] - 343485551) << 21 | b >>> 11) + e << 0,
        this.first ? (this.h0 = a + 1732584193 << 0,
            this.h1 = b - 271733879 << 0,
            this.h2 = e - 1732584194 << 0,
            this.h3 = t + 271733878 << 0,
            this.first = !1) : (this.h0 = this.h0 + a << 0,
            this.h1 = this.h1 + b << 0,
            this.h2 = this.h2 + e << 0,
            this.h3 = this.h3 + t << 0)
}

Md5.prototype.hex = function () {
    this.finalize();
    var e = this.h0
        , h1 = this.h1
        , h2 = this.h2
        , h3 = 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[h1 >> 4 & 15] + HEX_CHARS[15 & h1] + HEX_CHARS[h1 >> 12 & 15] + HEX_CHARS[h1 >> 8 & 15] + HEX_CHARS[h1 >> 20 & 15] + HEX_CHARS[h1 >> 16 & 15] + HEX_CHARS[h1 >> 28 & 15] + HEX_CHARS[h1 >> 24 & 15] + HEX_CHARS[h2 >> 4 & 15] + HEX_CHARS[15 & h2] + HEX_CHARS[h2 >> 12 & 15] + HEX_CHARS[h2 >> 8 & 15] + HEX_CHARS[h2 >> 20 & 15] + HEX_CHARS[h2 >> 16 & 15] + HEX_CHARS[h2 >> 28 & 15] + HEX_CHARS[h2 >> 24 & 15] + HEX_CHARS[h3 >> 4 & 15] + HEX_CHARS[15 & h3] + HEX_CHARS[h3 >> 12 & 15] + HEX_CHARS[h3 >> 8 & 15] + HEX_CHARS[h3 >> 20 & 15] + HEX_CHARS[h3 >> 16 & 15] + HEX_CHARS[h3 >> 28 & 15] + HEX_CHARS[h3 >> 24 & 15]
}


function md5Hex(msg) {
    const md5 = new Md5();
    md5.update(msg);
    return md5.hex();
}

const input = process.argv[2];
const result = md5Hex(input);
console.log(result);

最终查询问题的主函数代码如下

import requests
import json
import time
import Getsign
import Login
import uuid


def getToken(phone, password):
    try:
        token = Login.getLoginToken(phone, password)
        return token
    except:
        print("Failed to retrieve token")
        return None


def search(question, token, time):

    url = "https://www.kaoshibao.com/api/search/questions"
    cookie = str(uuid.uuid4())
    sign = Getsign.sign(t=cookie, n=time, c=url)
    proxies = {"http": "http://127.0.0.1:10809", "https": "http://127.0.0.1:10809"}



    headers = {
        "Authorization": "%22" + token + "=%22",
        "Cookie": "uu=" + cookie + "; token=" + token,
        "Sign": sign,
        "TimeStamp": time,
    }

    data = {
        "keyword": "\"" + question + "\"",
        "page": "1",
        "paperid": "\"\"",
        "qtype": "\"\"",
        "size": "20"
    }

    response = requests.post(url=url, headers=headers, data=data, proxies=proxies)

    # 将响应文本转换为JSON格式
    data_json = json.loads(response.text)

    # 转换Unicode编码并打印结果
    print(json.dumps(data_json, indent=4, ensure_ascii=False))


if __name__ == '__main__':
    time = str(time.time())
    search("mysql", "", time)

可以配合用户名密码登录获取token

import requests
import json
import PasswordEncrypt
import uuid
import time
import Getsign


def getLoginToken(phone, password):
    proxies = {"http": "http://127.0.0.1:10809", "https": "http://127.0.0.1:10809"}

    url = "https://www.kaoshibao.com/api/user/login"

    IDENTIFIER = str(uuid.uuid4())
    time1 = str(time.time())

    headers = {
        "CLIENT-IDENTIFIER": IDENTIFIER,
        "Sign": Getsign.sign(t=IDENTIFIER, n=time1, c=url),
        "TimeStamp": time1,
    }

    password = PasswordEncrypt.password(password)

    data = {
        "password": password,
        "phone": phone,
    }

    response = requests.post(url=url, headers=headers, data=data, proxies=proxies)

    # 检查响应状态码
    if response.status_code == 200:
        json_data = json.loads(response.text)
        print(json_data)
        if json_data["code"] == '200':
            print(json_data["data"]["token"])
            return json_data["data"]["token"]
        else:
            print("Failed to retrieve token: Code", json_data["code"])
            return "Failed to retrieve token: Code", json_data["code"]

    else:
        print("Failed to retrieve cookies: Status code", response.status_code)

getLoginToken("12222222222", "123456")

最终获得的数据如下，对其处理一下即可。

完整代码地址

https://github.com/incredibleeeeee/kaoshibao/tree/master/PythonTest/kaoshibao

無糖加冰
关注
使用Selenium爬取考试宝题库
m0_49072901的博客
09-23 2765
考试宝题库获取
通过python的selenium框架爬取考试宝典题目
03-30
1,先获取题目的分类及每个分类的练习题页面的url,并存入csv文件中 2,轮询url通过点击获得每个题标题,选项及答案
自-Python-试卷题目有答案-测题库答案.doc
06-14
自测题库参考答案 自测试卷1 一、选择题答案 1．B 2．C 3．B 4．D 5．B 6．A 7．A 8.．B 9．C 10．D 二、填空题答案 1、lambda表达式 2、索引，0 3、封装、继承、多态 4、除数为0 5、urllib、urllib3、requests 三、简答题答案 1、Python提供了哪几种读取文件的方法？ 答： θ 文件对象提供了read()方法，用于读取指定个数的字符； θ 文件对象提供了readline()方法，用于每次读取一行数据； θ 文件对象提供了readlines()方法，用于可以读取全部行。 2、请简述网络爬虫的基本工作流程。 答：网络爬虫的基本工作流程如下： （1）获取初始的URL，该URL地址是用户自己制定的初始爬取的网页。 （2）爬取对应URL地址的网页时，获取新的URL地址。 （3）将新的URL地址放入URL队列中。 （4）从URL队列中读取新的URL，然后依据新的URL爬取网页，同时从新的网页中获取 新的URL地址，重复上述的爬取过程。 （5）设置停止条件，如果没有设置停止条件时，爬虫会一直爬取下去，直到无法获 取新的URL地址为止。设
考试宝导出文件
weixin_44864919的博客
11-16 2057
【代码】考试宝导出文件。
python使用selenium获取某通章节测试题
Error的博客
05-18 718
使用selenium效率很低，而且不是通用的，爬取其他课程要对代码进行修改，建议使用下方文章： python爬虫笔记（学习T）_星空的你的博客-CSDN博客 爬取的网站不是某通原网，可能是内部网站，分析网站源码抓包发现的，此网站目前没有字体加密。 下方代码： import time from lxml import etree from bs4 import BeautifulSoup import os from selenium import webdriver from selenium.w
考试宝-网络题库爬虫python实现
weixin_38383877的博客
06-08 3596
【代码】考试宝-网络题库爬虫python实现。
考试宝 逆向 分析
最新发布
ff2766958292的博客
10-09 693
考试宝、sign、web、小程序
Python爬虫学习第五天---requests模块实现JS解密（有道翻译）
热门推荐
lufei0920的博客
05-31 4万+
#爬虫学习2—requests模块post方式实现有道翻译 一、抓包分析 1、网页查看 2、分析此处发送的数据是预设值还是固定值还是程序获取方式。 这里需要我们多抓包几次分析，如下图中。 通过多次抓包分析得出 1、相同浏览器不同页面其salt,sign,lts的值不同。 2、不同浏览器，其四个值都不同 所以我们需要继续分析获取此处的数据。 二、简单实现有道翻译并破解加密数据 1、实现源码 import requests url = "https://fanyi.youdao.c
python爬虫，requests+beautifulsoup+selenium+phantomJS
heshao20的专栏
07-08 431
...
python爬取考试网_Python爬虫抓取收集考试大纲
weixin_39574943的博客
12-09 390
今天做了个小玩意，但觉得挺有意思的，分享给大家。主要是这样的，因为帮妹子寻找考试资料，发现同一本书不同的章节分别在不同的链接中，复制起来实在要命，所以就在想能不能用爬虫实现。下图是我们要爬取得页面，注意看下面叫讲义的表格​欢迎加入我的QQ群`923414804`与我一起学习，群里有我学习过程中整理的大量学习资料。加群即可免费获取首先结合Request和BeautifulSoup来对这个主页进行处理...
UiPath考试宝典.zip
06-07
其它一些学习资源 UiPath开发手册（UiPathIDE，官方英文） UiPathAPI手册（UiPathAPI手册，官方英文） UiPathOrchestrator文档（Orchestrator相当于服务管理平台，官方英文） UiPathRobot文档（UiPath机器人，官方英文） 在开发人员Level1课程中有少量课程带有中文字幕。 考前： 在UiPath Academy在线学习系统中完成开发人员Level1 - 3的所有课程，因为基本大部分题都是在该3们课程中出现过的，L1课程耗时最长，总共13个单元，每个单元都有在线测试和课后作业，课后作业不强制，但是最终认证考试中会有实际项目测试，测试内容基本是3个课程中所有讲过的组件，功能，和一些基础操作等等。到了L2是教你如何部署UiPath Robot，L3课程是教你完成一个小项目，在最终认证时有可能会考到。 跟着官方课程学习整个过程官方预计时间为4周，实际完成再加上自己练习2周左右就能完成。
Python爬虫必备： 爬虫基础+js逆向+app逆向+案例
01-18
本资源包"Python爬虫必备：爬虫基础+js逆向+app逆向+案例"涵盖了Python爬虫的基础知识，JavaScript逆向工程以及移动应用（App）的逆向分析，旨在提供一套完整的爬虫学习路径。 首先，让我们深入探讨Python爬虫基础...
Python JS逆向爬虫作业
02-29
Python 和 JavaScript 在网络爬虫...通过这个“Python JS逆向爬虫作业”，你将深入学习到如何结合Python和JavaScript处理复杂的网络爬虫问题，提高数据获取能力，同时也需要关注如何在实际操作中保持合法性和道德性。
Python爬虫进阶 JS 解密逆向实战.zip
03-23
这通常通过HTTP请求库实现，如Python中的Requests库。 解析内容： 爬虫对获取的HTML进行解析，提取有用的信息。常用的解析工具有正则表达式、XPath、Beautiful Soup等。这些工具帮助爬虫定位和提取目标数据，如文本...
某二手车爬虫逆向完整项目+python+爬虫+逆向研究+爬虫实战
05-28
某二手车爬虫逆向完整项目+python+爬虫+逆向研究+爬虫实战 使用人群：Python编程者+爬虫+逆向研究+数据需求者+对爬虫感兴趣的小白 其他说明：代码看不懂的可与本人沟通，提供技术支持
Python爬虫最强项目案例之——JS逆向。这波学到就是赚到。
爬遍所有网站
01-22 1万+
前言 前段时间看到有人js逆向了某手机的反馈专区，我也第一时间学习了一下，学完后一直想着凭借自己的能力，看能不能单独完成一次，拿下js逆向真正第一血，所以就有了今天的受害者，某蓝厂手机圈子的逆向。 网站分析 既然选定了目标，那就开始抓包，分析网页。 这是抓包后的情况，通过对多个包进行比较发现，实际变化的参数只有lastId、nonce、timestamp、pageNum。具体分析了一下，lastId：前一页最后一个发言用户的tid；pageNum：当前页码；timestamp：13位时间戳；no
python requests 最新抓取百度翻译内容，js逆向，亲测有效
weixin_44275079的博客
03-10 2823
python requests 抓取百度翻译 js破解 最新版 上一篇文章写了有道翻译抓取，朋友圈的大佬说试试抓取百度翻译！，于是我就抱着试一试的心态开始写了 目标网站：https://fanyi.baidu.com/?aldtype=16047 1.寻找数据 F12进去NetWork 调试多次，发现翻译后的数据放在json里 2.找出接口区别 下图(中翻英)接口下 下图是（日翻英)的接口 接口为: https://fanyi.baidu.com/v2transapi?from={需要翻译的文字语言}
Python requests抓取有道翻译 最新版破解js加密
weixin_44275079的博客
03-10 591
Python requests抓取有道翻译 最新版破解js加密 目标网站：http://fanyi.youdao.com/ 1.寻找数据 F12 进去Network 调试多次，翻译后的数据放在 json里 数据放在接口下 2.找出js加密的数据 调试多次 发现这三个参数会发生变化， 3.破解js加密 观察initiator发现加载的js代码，分析代码发现加密的参数在这里 ‘ts’:就是Form Data里的’lts’, 不难发现 r获取的是当前时间的毫秒数并字符串化，i获取的是 r 拼接一个随机的（0，
python爬虫笔记（学习T）
Error的博客
05-18 627
代码在下方，运行一下就知道了，此篇文章不可多说，望理解。 courseId在学习T课程页面上方的网页地址中可以获取。 如果还不清楚去下面看思路讲解。 代码如下： import os import requests from bs4 import BeautifulSoup import threading import time from queue import Queue import json ''' 第一步，获取所有KnowledgeId ''' print('获取所有Knowledg.
python爬虫js逆向模拟登录
10-21
Python爬虫JS逆向模拟登录是一种有效的方式，可以解决JS解密反爬措施。在进行JS逆向爬虫时，我们需要分析JS和页面的结构，遵守爬虫规则，保证程序的效率和数据的准确性。下面是Python爬虫JS逆向模拟登录的步骤： 1. 分析登录页面的JS代码，找到加密算法和参数位置。 2. 使用Python的Requests库发送登录请求，并获取登录页面的HTML代码。 3. 从HTML代码中提取出需要的参数值，并使用加密算法对其进行加密。 4. 将加密后的参数值和其他必要参数一起发送给服务器，完成模拟登录。 需要注意的是，在进行JS逆向爬虫时，我们需要遵守网站的爬虫规则，不要频繁发送请求，以免对网站造成影响。同时，我们也需要注意反爬机制，如设置请求头、使用代理IP等方式来规避反爬虫机制。
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值