爬虫&逆向--Day15--核心逆向案例2(Python逆向实现请求加密、请求堆栈、拦截器关键字)

一、逆向案例之Python逆向实现请求加密

//具体代码如下
function l(t, e) {
            return t.toString().toUpperCase() > e.toString().toUpperCase() ? 1 : t.toString().toUpperCase() == e.toString().toUpperCase() ? 0 : -1
        }
        function u(t) {
            for (var e = Object.keys(t).sort(l), n = "", a = 0; a < e.length; a++)
                if (void 0 !== t[e[a]])
                    if (t[e[a]] && t[e[a]]instanceof Object || t[e[a]]instanceof Array) {
                        var i = JSON.stringify(t[e[a]]);
                        n += e[a] + i
                    } else
                        n += e[a] + t[e[a]];
            return n
        }
        function d(t) {
            for (var e in t)
                "" !== t[e] && void 0 !== t[e] || delete t[e];
            var n = r["a"] + u(t);
            return s(n).toLocaleLowerCase()
        }

1.1、步骤1，通过https://curlconverter.com/ 生成基础爬虫代码

1.2、Python代码的结构调整

1.3、补充知识点1：0值的概念

在整型中，只有0是false 其他的不管是正数1 2 3...还是-1，-2，-3...都是true

在字符串中，只有"",是false ；其他的" "，"0"...等只要不是空字符串都是true

1.4、补充知识点2：与或非逻辑运算 短路运算

与 and(Pyhon) &&(JS) 全真为真，有假既假

或 or(Python) || (JS) 有真既真，全假为假

1.5、在对列表或字典进行便利的时候，不能直接对其进行操作(增删改)，需要用t.copy

"""  一、处理“零值”  【t是一个字典】
    for (var e in t)
        "" !== t[e] && void 0 !== t[e] || delete t[e];
    1、Python没===
    2、Python 的 or 后面不能使用del命令，所以只能使用t.pop进行删除操作
    3、在对列表或字典进行便利的时候，不能直接对其进行操作(增删改)，需要用t.copy
    t.copy()产生一个新的字典去循环便利，   t.pop()在对原始字典进行操作处理
    """
    # 方式1：
    for key in t.copy():
        print(key)  # 获取每一个key
        t[key] != "" and t[key] != 0 or t.pop(key)
    print(t)

1.6、列表和元组排序：sort() sorted()

l = [10, 2, 3, 1, 5]
l.sort()  # 从小到大
print(l)  # [1, 2, 3, 5, 10]

l = [10, 2, 3, 1, 5]
l.sort(reverse=True)  # 从大到小
print(l)  # [10, 5, 3, 2, 1]

l = ["2", "1", "10", "100", "5"]
l.sort()  # 字符串安装ASCII码字母表排序从小到大，所以结果有点乱七八糟
print(l)  # ['1', '10', '100', '2', '5']

# 补充知识点:sorted()
l = [10, 2, 3, 1, 5]
print(sorted(l))  # [1, 2, 3, 5, 10]


# sorted() 比sort()强大的多，sort()不管什么是什么元素直接就给你硬排，而且需要对象进行调用
# sorted() 有返回值，可以自定义排序规则

# 案例1
# my_sort函数是排序规则 只能有一个形参item，是l2中的每一个元素
def my_sort(item):
    # 然后根据每一个元素中的具体数据进行排序，根据什么排序，就返回什么，例如根据年龄就返回item[1]
    return item[1]


# l2必须是列表或者元组，不能是字典，字典是无序的没办法排序
l2 = [["yuan", 23, 175], ["rain", 18, 180], ["alvin", 45, 165]]
# 对谁进行排序l2  如何排序，排序规则  key
print(sorted(l2, key=my_sort))
# [['rain', 18, 180], ['yuan', 23, 175], ['alvin', 45, 165]]
print(sorted(l2, key=lambda item: item[1]))  # 使用lambda函数


# [['rain', 18, 180], ['yuan', 23, 175], ['alvin', 45, 165]]


# 案例2
def my_sort2(item):
    return item["height"]


l3 = [
    {
        "name": "yuan",
        "age": 23,
        "height": 175
    },
    {
        "name": "rain",
        "age": 18,
        "height": 180
    },
    {
        "name": "alvin",
        "age": 45,
        "height": 165
    },
]
print(sorted(l3, key=my_sort2))
# [{'name': 'alvin', 'age': 45, 'height': 165}, {'name': 'yuan', 'age': 23, 'height': 175}, {'name': 'rain', 'age': 18, 'height': 180}]


# 由以上案例1和案例2，总结如下
t = {
    "ts": 1754484535355,
    "pageNo": 4,
    "pageSize": 20,
    "total": 2749,
    "KIND": "GCJS",
    "GGTYPE": "1",
    "timeType": "6",
    "BeginTime": "2025-02-06 00:00:00",
    "EndTime": "2025-08-06 23:59:59"
}

# 由于字典没办法进行排序，所以只能先把字典转列表
t_list = t.items()
print("::::",t_list)
# [('ts', 1754484535355), ('pageNo', 4), ('pageSize', 20), ('total', 2749), ('KIND', 'GCJS'), ('GGTYPE', '1'), ('timeType', '6'), ('BeginTime', '2025-02-06 00:00:00'), ('EndTime', '2025-08-06 23:59:59')]

# 案例2
def my_sort3(item):
    return item[0]

print(sorted(t_list,key=my_sort3))
# [('BeginTime', '2025-02-06 00:00:00'), ('EndTime', '2025-08-06 23:59:59'), ('GGTYPE', '1'), ('KIND', 'GCJS'), ('pageNo', 4), ('pageSize', 20), ('timeType', '6'), ('total', 2749), ('ts', 1754484535355)]

1.7、最终代码：01逆向案例之Python逆向实现请求加密.py

import requests
from hashlib import md5
import time

headers = {
    'Accept': 'application/json, text/plain, */*',
    'Accept-Language': 'zh-CN,zh;q=0.9',
    'Connection': 'keep-alive',
    'Content-Type': 'application/json;charset=UTF-8',
    'Origin': 'https://ggzyfw.fujian.gov.cn',
    'Referer': 'https://ggzyfw.fujian.gov.cn/business/list/',
    'Sec-Fetch-Dest': 'empty',
    'Sec-Fetch-Mode': 'cors',
    'Sec-Fetch-Site': 'same-origin',
    'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/128.0.0.0 Safari/537.36',
    # 'portal-sign': 'af2344abf132bc8634f2fc0e28466209',    因为需要替换它，所以这个不需要了
    'sec-ch-ua': '"Chromium";v="128", "Not;A=Brand";v="24", "Google Chrome";v="128"',
    'sec-ch-ua-mobile': '?0',
    'sec-ch-ua-platform': '"Windows"',
}


# 构建一个函数，用来生成sign，并且放到请求头中
def get_sign(t):
    """  一、处理“零值”
    for (var e in t)
        "" !== t[e] && void 0 !== t[e] || delete t[e];
    1、Python没===
    2、Python 的 or 后面不能使用del命令，所以只能使用t.pop进行删除操作
    3、在对列表或字典进行便利的时候，不能直接对其进行操作(增删改)，需要用t.copy
    t.copy()产生一个新的字典去循环便利，   t.pop()在对原始字典进行操作处理
    """
    # 方式1：
    # for key in t.copy():
    #     print(key)  # 获取每一个key
    #     t[key] != "" and t[key] != 0 or t.pop(key)
    # print(t)

    # 方式2：
    # 创建一个新的字典，保存更新后的数据
    new_t = {}
    for key, val in t.items():
        if val == "" or val == 0:
            continue
        new_t[key] = val
    # print(new_t)
    # {'pageNo': 1, 'pageSize': 20, 'total': 2810, 'KIND': 'GCJS', 'GGTYPE': '1', 'timeType': '6', 'BeginTime': '2025-02-13 00:00:00', 'EndTime': '2025-08-13 23:59:59', 'ts': 1755068622063}

    # 二、排序
    new_t_list = new_t.items()  # 把字典转换为列表

    def my_sort3(item):
        return item[0]

    # 使用sorted() 对列表进行排序
    ret = sorted(new_t_list, key=my_sort3)

    s1 = ""
    # 便利列表  并把列表中的每个元组的key和val进行拼接，最后在拼接成一个字符串
    for key, val in ret:
        s1 += key + str(val)  # key先和val拼接，val有可能是数字所以需要转字符串

    print(s1)
    # BeginTime2025-02-13 00:00:00EndTime2025-08-13 23:59:59GGTYPE1KINDGCJSpageNo1pageSize20timeType6total2810ts1755068622063

    # 三、拼接参数字符串
    s2 = "B3978D054A72A7002063637CCDF6B2E5"
    s = s2 + s1

    # 四、md5值计算
    md5_obj = md5()  #

    md5_obj.update(s.encode())  # 使用s的二进制字节串，所以.encode

    return md5_obj.hexdigest()  # 返回32位的值


# 创建一个main函数，把所有的业务流程放到该处
def main():
    json_data = {
        'pageNo': 1,
        'pageSize': 20,
        'total': 2810,
        'AREACODE': '',
        'M_PROJECT_TYPE': '',
        'KIND': 'GCJS',
        'GGTYPE': '1',
        'PROTYPE': '',
        'timeType': '6',
        'BeginTime': '2025-02-13 00:00:00',
        'EndTime': '2025-08-13 23:59:59',
        'createTime': '',
        'ts': int(time.time() * 1000),    # 获取当前的时间戳
    }

    # 把Python实现的加密字段替换到请求头中
    sign = get_sign(json_data)
    print(sign)
    headers["portal-sign"] = sign

    response = requests.post('https://ggzyfw.fujian.gov.cn/FwPortalApi/Trade/TradeInfo', headers=headers,
                             json=json_data)

    print(response.text)


main()

二、入口定位：请求堆栈&&拦截器关键字

入口定位

   -- 关键字搜索
      -- 方法关键字
         -- encrypt
         -- decrypt
      -- key关键字(最高频)

      -- headers关键字
      -- 路径关键字
      -- 拦截器关键字 如果把加密的内容放到了拦截器了，就直接用这个方式搜索
         interceptors.request.use(func)
         interceptors.response.use(func)

   -- 请求堆栈--主要关注请求,响应无关

      请求入口定位，与响应无关

   -- hook

2.1、请求堆栈

2.1.1、什么是堆栈，堆栈如何操作

2.1.2、堆栈中的参数传递

备注：由此我们可以推出，如果当我们不知道如何定位加密参数portal_sign找不到这个字段的时候，我们只要定位到最后的一个调用，根据堆栈的请求顺序，倒序的去寻找portal_sign字段是在那个函数中产生的，然后在进行解析和代码的处理

2.1.3、如何准确搞笑的定位入口

方式一：这种方式不好用，有其他的一些接口经常干扰

方式二：经常使用这种方式

补充：

2.2、拦截器关键字：n.then(t.shift()， t.shift())

类似以上的多个接口都是一样的加密方式，都有portal_sign

n = n.then(t.shift()， t.shift())；拦截器

-- 拦截器关键字 如果把加密的内容放到了拦截器了，就直接用这个方式搜索
   interceptors.request.use(func)
   interceptors.response.use(func)

当我们判断这个网站把接口请求解密的动作放到了拦截器中，就不要用别的关键字搜索了

直接搜索

这是前端人员固定语法，调用的一个库，所以直接进行搜索 拦截器关键词，就可以定位到入口