# 本次逆向是shopee的请求头反爬参数的第一部分

### 参数定位
shopee是反爬届中参数复杂程度较高的，我们可以看到复杂的参数生成以及代码混淆，在请求头中，比较重要的参数是下面这些：

![coffee01.jpg](https://xsblog.site/static/img/d219fab7a4c92a88bb7485fda5e6eb61.coffee01.webp)
![coffee02.jpg](https://xsblog.site/static/img/4df572f11f9e8266323d723791d33891.coffee02.webp)

我们这次先解决比较简单的两个，一个是x-sap-ri，另外一个是af-ac-enc-dat这两个参数。
#### af-ac-enc-dat
在以前的版本中，例如211001这类的版本，这个参数是十分复杂的，但是在现在这个版本下，这个参数就很简单了，以及不是风控的关键。我们全局搜索参数关键字即可获取数据。
```js
function y() {
    var e, t = function (e) {
        for (var t = "", n = 0; n < e.length; n++)
            t += e[n].toString(16).padStart(2, "0");
        return t
    }(function () {
        for (var e = new Uint8Array(8), t = 0; t < 8; t++)
            e[t] = Math.floor(256 * Math.random());
        return e
    }());
    return (e = {})["af-ac-enc-dat"] = t,
        e
}
```
简单分析一下代码就知道，这个是一个随机数。

#### x-sap-ri
这个参数就不像上一个参数这么简单了，我们首先需要定位到参数生成的关键位置，通过请求链我们可以发现这个参数是在一个sap-hook-latest.js中生成的，通过名字我们可以发现，这个应该就是参数生成的文件了。

我们点进文件可以发现，这是一个巨大的webpack，然后外加超强混淆，我们需要耐心一点，一步一步去跟一下，找到他的核心代码位置。


![image.png](https://xsblog.site/static/img/a2e1d851d0d3cac560d4d0761d0a37ad.image.webp)

在这里，他对许多结果进行拼接以及计算，我们在他的下方打上日志点
```js
'rrt:', r[rt], '\nnt:', nt, '\nit:', it, '\not:', ot
```
就可以发现一大堆有用的信息了。

![image.png](https://xsblog.site/static/img/f9b47521f7bd2be734d278ee98e7b189.image.webp)

这里，我们已经找到了x-sap-ri的生成位置，下面进行分析。
### x-sap-ri参数逆向
我们通过日志可以发现，这个参数是一个26位的unit8Array通过下面这个函数变成的16进制字符串：
```js
// 还原前
e.QXw = function (t) {
    for (var e = O0QUD, r = "", n = 0; n < t.length; n++) {
        var i = t[n] >> 4 & 15
            , o = 15 & t[n];
        r = (r += i[e(253)](16)) + o[e(253)](16)
    }
    return r
}
// 还原后
function to_hex_string(t) {
    for (var r = "", e = 0; e < t.length; e++) {
        var o = t[e] >> 4 & 15
            , i = 15 & t[e];
        r = (r += o["toString"](16)) + i["toString"](16)
    }
    return r
}
```
我们再往上追溯，可以发现这个26位的uint8Array是通过时间戳拼接随机数生成的：
```js
const timestamp = Math.ceil(Date.now() / 1e3);
const buffer = new ArrayBuffer(26);
const view = new DataView(buffer);
view.setUint32.apply(view, [0, timestamp, true]);
const randomArray = window.crypto.getRandomValues(new Uint8Array(22));
let array = new Uint8Array(view.buffer)
array.set.apply(array, [randomArray, 4])
```
但是我们发现，如果我们按照他的这个方法生成的参数，总有3位和浏览器上生成的不一样，特别是第12位和第13位，浏览器上会固定时3和1，但是我们代码生成的参数却不是这样的，这是为什么呢？

带着这个疑问我们追栈，一步一步跟下去发现，在后续的流程中，他对这个unit8Array进行了修改。他取出来数组中的第11位，进行几步操作，然后把第12和第13位设置为固定的数字，直到这里，我们就把参数完全逆向完毕。

整理成函数就是这个样子：

```js
function get_x_sap_ri() {
    const timestamp = Math.ceil(Date.now() / 1e3);

    const buffer = new ArrayBuffer(26);
    const view = new DataView(buffer);
    view.setUint32.apply(view, [0, timestamp, true]);
    const randomArray = window.crypto.getRandomValues(new Uint8Array(22));

    let array = new Uint8Array(view.buffer)
    array.set.apply(array, [randomArray, 4])
    let magic = array[11]
    magic = (3 << 4) + (15 & magic)
    array[11] = magic
    array[12] = 3
    array[13] = 1
    const hexString = utils.to_hex_string(array);
    return {
        'x-sap-ri': hexString,
        'timestamp': timestamp,
        'b1x': randomArray.at(0)
    }
}
```
参数里面的时间戳以及随机数组的第一位都在后续的流程中有应用～

### 后记
这个参数其实也是很简单的，主要就是中间有点变化，他把随机数变成伪随机的了，我后端检测的时候只需要简单检测一下就可以干掉一大批纯算用户。

shopee x-sap-ri逆向 版本号215011

# temu参数破解 _bee参数

> 本次逆向接口为：L2FwaS9waGFudG9tL3hnL3BmYi9hNA==

### 前情提要
经常爬数据的同学都知道，电商一向是令人头疼的存在，而作为电商头部行业，风控更是强的一批。我们在获取数据的时候，发现如果请求头里面不带上某些特定的ck是获取不到数据的，下面是某个api的携带ck情况



![temuck.jpg](https://xsblog.site/static/img/20b221eb0c3a35afe96867b35e8544a8.temuck.webp)

里面很多参数都是网站所谓的风控参数，其中verifyAuthToken是验证码通过后的凭证，本次我们暂时不讨论这个值，**_nano_fp** 参数大家是不是很眼熟，做过**anti-content**参数逆向的同学也一定知道，这个参数也参与了这个值的计算，这些ck都是比较重要的ck，但是，要想获取商品的数据，**_bee** 才是问题的重点！

本文我们将讨论这个参数是如何生成的，并且在本地进行纯算计算。
### 参数定位
我们首先要知道这个ck是在什么地方给我们设置起来的，方法有很多，你也可以hook setCookie这个方法，也可以做其他很好的操作。

在这里，我们采用全局搜索方法，搜索这个参数在哪获取的：

![temu定位.jpg](https://xsblog.site/static/img/ebcb4284938f94475838358cf9d23b6d.temu%C3%A5%C2%AE%C2%9A%C3%A4%C2%BD%C2%8D.webp)

不搜不知道，这个结果居然是接口返回的，这个时候我们就要去看一看这个接口是怎么请求的了。


![temu接口.jpg](https://xsblog.site/static/img/e2b103cc1ce409ba5b34a259664113da.temu%C3%A6%C2%8E%C2%A5%C3%A5%C2%8F%C2%A3.webp)

通过查看数据包我们可以发现，这个接口需要我们传一些奇奇怪怪的值，一个巨长无比的data，一个sign，一个时间戳，这个时候我们通过追栈，查看到参数生成的位置。


![temuhook1.jpg](https://xsblog.site/static/img/3cb79405f357dc17abdbf27d438240fd.temuhook1.webp)

很显然，是在这里发包的，可以很明显看到每个参数的生成。
### sign值逆向
柿子先调软的捏，我们首先看这个短小的sign值，这里括号里面的操作明显就是做一些加法，把fe拼接一个参数然后凭借时间戳和data，做一个签名（"HJ6793TJDI86DLS9D"）。

现在我们需要知道的就是这个签名算法是什么。我们观察这个参数的长度，嗯，是40位，常见的40位的hash算法有什么呢，显然是sha1，在这里，我们猜测是不是标准算法，我们传入一个特定的值去计算，看他的结果和官方的结果是不是一样的：

![temusha1.jpg](https://xsblog.site/static/img/0d9b2d6c88fba70168542493fc6cf1c4.temusha1.webp)


![temusha.jpg](https://xsblog.site/static/img/1bc4c3eff8ea87fcb29b3618d5e6759e.temusha.webp)

很明显，这个参数的值是一样的，好了，这就是一个标准版的sha1.
```js
const crypto = require('crypto');

function sha1(input) {
    return crypto.createHash('sha1').update(input).digest('hex');
}
```

### data参数破解

破解完sign值后，我们可以查看data是怎么生成的了。

我们在代码中可以看到，data这个值是他在用Ne.es这个方法，把字符串变成数组，我们可以选取一个查看一下：

![image.png](https://xsblog.site/static/img/095704e2d7f717ca9c69da5ae7428a4f.image.webp)

可以看到，这个方法是问题的关键之一，我们进入这个方法查看：

![image.png](https://xsblog.site/static/img/18517a188786dd92171c7fb6a8dda3e8.image.webp)

可以看到这个方法是在一个巨大的对象里面，这个对象是不是很眼熟，没错，这个和anti-content计算过程中的那个对象是同一个对象，我们可以用同一套方案把它抠出来：
```js
const zlib = require('zlib');

let zli = {
    deflate: zlib.deflateSync,
}

let De = {
    pako: function (t) {
        return zli.deflate(Buffer.from(t))
    },
    base64: function (t) {
        for (var e, n, r, o = "", i = t.length, a = 0, u = 3 * parseInt(i / 3); a < u;)
            e = t[a++],
                n = t[a++],
                r = t[a++],
                o += Me[e >>> 2] + Me[63 & (e << 4 | n >>> 4)] + Me[63 & (n << 2 | r >>> 6)] + Me[63 & r];
        var c = i - u;
        return 1 === c ? (e = t[a],
            o += Me[e >>> 2] + Me[e << 4 & 63] + "==") : 2 === c && (e = t[a++],
            n = t[a],
            o += Me[e >>> 2] + Me[63 & (e << 4 | n >>> 4)] + Me[n << 2 & 63] + "="),
            o.replace(/[+\/=]/g, (function (t) {
                    return Ie[t]
                }
            ))
    },
    charCode: function (t) {
        for (var n = [], r = 0, o = 0; o < t.length; o += 1) {
            var i = t.charCodeAt(o);
            i >= 0 && i <= 127 ? (n.push(i),
                r += 1) : (i >= 2048 && i <= 55295 || i >= 57344 && i <= 65535) && (r += 3,
                n.push(224 | 15 & i >> 12),
                n.push(128 | 63 & i >> 6),
                n.push(128 | 63 & i))
        }
        for (var a = 0; a < n.length; a += 1)
            n[a] &= 255;
        return r <= 255 ? [0, r].concat(n) : [r >> 8, 255 & r].concat(n)
    },
    es: function (t) {
        t || (t = "undefined");
        var n = []
            , r = this.charCode(t).slice(2)
            , o = this.enn(r.length);
        return n = n.concat(this.enn(241), o, r)
    },
    enn: function (t) {
        t || (t = 0);
        for (
            var n = parseInt(t),
                r = n << 1 ^ n >> 31,
                o = r.toString(2),
                i = [],
                a = (o = Te(o, 7 * Math.ceil(o.length / 7), "0")).length;
            a >= 0;
            a -= 7
        ) {
            var u = o.substring(a - 7, a);
            if (!(-128 & r)) {
                i.push("0" + u);
                break
            }
            i.push("1" + u),
                r >>>= 7
        }
        return i.map((function (t) {
                return parseInt(t, 2)
            }
        ))
    },
}
```
把这个对象扣好之后，我们可以去进一步改写一下丑陋的原始代码，把恶心的三元表达式给替换掉：
```js
function get_a4_payload(fp, header_catch, config) {
    const c = config.collectEvent;
    const x = config.isInterval || false;
    const l = fp.rawData || {};
    const v = fp.localIp || 'undefined';
    const p = an;
    const g = fp.app || 'h5Market';
    const b = fp.FKGJ || 'undefined';
    const S = fp.uid || 'undefined';
    const A = fp.moveData || [];
    const T = fp.clickData || [];
    const C = fp.inputData || [];
    const M = fp.blurData || [];
    const D = fp.pasteData || "0";
    const N = fp.hasSensor;
    const H = fp.isFront;
    const B = fp.webGLInfos;
    const P = fp.windowSize;
    const k = fp.winSelenium;
    const X = fp.chromium;
    const L = fp.headlessByProperties;
    const F = fp.languages;
    const j = fp.consoleLied;
    const U = fp.chromeExtensionScripts;
    const G = fp.extensionImgs;
    const W = fp.hookFuncs;
    const J = fp.frontReferer;
    const V = fp.elements || {};
    const q = fp.clientIp;
    const Z = fp.outterJs || JSON.stringify({});
    const Q = fp.cssFeatures;
    const $ = fp.webglFt;
    const tt = fp.performanceTime;
    const et = fp.emptyEvalLength;
    const nt = fp.errorFF;
    const rt = header_catch;
    const ot = fp.fonts;
    const it = fp.h5Features;
    const at = String(Date.now());

    const ut = [
        ...De.es("isInterval"), ...De.es(String(!!x)),
        ...De.es('rawData'), ...De.es(JSON.stringify(l)),
        ...De.es('localIp'), ...De.es(v),
        ...De.es("reportTimestamp"), ...De.es(at),
        ...De.es('version'), ...De.es(p),
        ...De.es('app'), ...De.es(g),
        ...De.es('FKGJ'), ...De.es(b),
        ...De.es("uid"), ...De.es(S),
        ...De.es('hasCdc'), ...De.es('false'),
        ...De.es('electronCef'),
        ...De.es(Dn()),
        ...De.es('frontReferer'), ...De.es(J)
    ];
    const ct = c ? [
        ...De.es("moveData"), ...De.es(JSON.stringify(A)),
        ...De.es('clickData'), ...De.es(JSON.stringify(T)),
        ...De.es('inputData'), ...De.es(JSON.stringify(C)),
        ...De.es('blurData'), ...De.es(JSON.stringify(M)),
        ...De.es('pasteData'), ...De.es(D)
    ] : [];

    const xt = N ? [...De.es('hasSensor'), ...De.es(N)] : [];
    const st = H ? [...De.es("isFront"), ...De.es(H)] : [];
    const ft = B ? [...De.es("webGLInfos"), ...De.es(B)] : [];
    const lt = P ? [...De.es('windowSize'), ...De.es(P)] : [];
    const dt = X ? [...De.es('chromium'), ...De.es(X)] : [];
    const vt = L ? [...De.es('headlessByProperties'), ...De.es(L)] : [];
    const ht = k ? [...De.es("winSelenium"), ...De.es(k)] : [];
    const pt = F ? [...De.es('languages'), ...De.es(F)] : [];
    const mt = j ? [...De.es("consoleLied"), ...De.es(j)] : [];
    const gt = U ? [...De.es('injectScripts'), ...De.es(U)] : [];
    const Et = G ? [...De.es("extensionImgs"), ...De.es(G)] : [];
    const bt = W ? [...De.es("hookFuncs"), ...De.es(W)] : [];
    const yt = V ? [...De.es('elements'), ...De.es(JSON.stringify(V))] : [];
    const St = q ? [...De.es('frontClientIp'), ...De.es(q)] : [];
    const _t = [...De.es('outterJs'), ...De.es(Z)];
    const At = Q ? [...De.es('cssFeatures'), ...De.es(Q)] : [];
    const wt = $ ? [...De.es("webglFt"), ...De.es($)] : [];
    const Tt = tt ? [...De.es('performanceTime'), ...De.es(tt)] : [];
    const Ot = et ? [...De.es("emptyEvalLength"), ...De.es(et)] : [];
    const Ct = nt ? [...De.es("errorFF"), ...De.es(nt)] : [];
    const Rt = rt ? [...De.es('headerCache'), ...De.es(rt)] : [];
    const Mt = ot ? [...De.es('fonts'), ...De.es(ot)] : [];
    const It = it ? [...De.es('h5Features'), ...De.es(it)] : [];

    const Dt = [
        ...ut,
        ...ct,
        ...xt,
        ...st,
        ...ft,
        ...lt,
        ...dt,
        ...vt,
        ...ht,
        ...pt,
        ...mt,
        ...gt,
        ...Et,
        ...bt,
        ...yt,
        ...St,
        ..._t,
        ...At,
        ...wt,
        ...Tt,
        ...Ot,
        ...Ct,
        ...Rt,
        ...Mt,
        ...It
    ];

    const result = {
        timeStamp: at,
        result: "0a" + De.base64(De.pako(Dt))
    };

    const sign = sha1('feHJ6793TJDI86DLS9D' + at + result.result)

    return {
        data: result.result,
        timestamp: at,
        appKey: "fe",
        sign: sign
    }
}
```

这样，代码一下子就清晰很多了，我们可以看到就是对一个巨大的Ki对象的值进行处理，现在问题的关键就到了如何获取这些对象的值，经过分析我们可以得知这些值是我们浏览器的一些环境值，我们拿到他就可以进行参数生产然后获取ck。

当然，这里还有一个header_catch，这个是其他接口返回的一个缓存key，可以很轻松的获取到，这里就不再赘述。

里面还有些小的函数，也是很简单就可以扣下来的，篇幅原因就不带着大家去扣代码了，an是版本号
```js
let an = "2.4.7"
```

### 后记
temu的风控是很厉害的，就算我们一套逻辑全部都对，可能也过不了他的风控，而且风控点经常会变，所以呀，这是一个长期对抗的过程～

temu风控破解之_bee参数纯算破解思路

## Django

### 创建项目初配置

#### 更改setting

****

删除pycharm自带的templates文件夹，删除setting中的TEMPLATES中的DIRS中的内容

更改setting中的语言以及配置项，配置端口，安装包

``` bash
pip install django-cors-headers
```


在注册app中添加，在中间件中添加

``` python
注册app：
"corsheaders"
中间件：
'corsheaders.middleware.CorsMiddleware'
```

在设置中配置端口信息

``` python
CORS_ALLOWED_ORIGINS = [
    'http://localhost:5173',
]

CORS_ALLOWED_METHODS = [
    'GET',
    'POST',
    'OPTIONS',
]

CORS_ALLOWED_HEADERS = [
    'Content-Type',
]
```

安装app

``` bash
python .\manage.py startapp webServer
```

注册app

``` python
"Server01.apps.Server01Config",
```

修改数据库配置，见后文

### 数据库篇

#### 连接数据库以及配置模型

***

* 首先在settings中配置好数据库的相关信息， _注：需要安装好mysqlclient_

  ``` python
  DATABASES = {
      'default': {
          'ENGINE': 'django.db.backends.mysql',  # 数据库的连接类型
          'NAME': 'app01',					   # 数据库的名字
          'USER': 'root',						   # 数据库的登录账号
          'PASSWORD': 'dxs666dxs',               # 密码
          'HOST': '127.0.0.1',                   # ip
          'PORT': '3306',						   # 端口
      }
  }
  ```

* 在对应app的models.py文件中编写对应的表结构

  _下面展示简单的表结构以及外键约束_

  ``` python
  class Department(models.Model):
      """ 部门表 """
      title = models.CharField(max_length=32, verbose_name='部门名称')
      
  
  class Employee(models.Model):
      """ 员工表 """
      name = models.CharField(max_length=16, verbose_name='姓名')
      password = models.CharField(max_length=64, verbose_name='密码')
      age = models.IntegerField(verbose_name='年龄')
      account = models.DecimalField(max_digits=10, decimal_places=2, default=0, verbose_name='账户余额')
      created_at = models.DateTimeField(verbose_name='入职事件')
      # 外键约束
      # 设置级联删除
      department = models.ForeignKey(to="Department", to_field="id", on_delete=models.CASCADE)
      # 设置置空
      # department = models.ForeignKey(to="Department", to_field="id", null=True, blank=True, on_delete=models.SET_NULL)
      
      # 设置选择，即确立简单的对应关系，由Django自动匹配
      gender_choices = (
          (1, "男"),
          (2, "女"),
      )
      gender = models.SmallIntegerField(verbose_name='性别', choices=gender_choices)
  ```

#### 将编写好的表结构注册进数据库
***
  * 首先将数据库在MySQL中创建好
    ``` sql
    create database your_database_name
    ```
  * 执行下列命令
    ``` bash
    python manage.py makemigrations
    python manage.py migrate
    ```
  * 创建完成

#### 获取数据

***

##### 获取全部

如果是普通的数据，我们使用下面的语言即可

``` python
queryset = models.UserInfo.objects.all()
for obj in queryset:
    print(obj.id, obj.name, ...)
    # 如果是时间类型
    print(obj.create_time.strftime("%Y-%M-%D"))
    # 如果是简单的对应关系
    print(obj.get_gender_display())
```

简单解释一下，简单对应关系就是

``` python
get_名称_display()
```

##### 查询数据

``` python
department = models.Department.objects.filter(id=1).first()
```

##### 通过外键拿数据

``` python
queryset = models.UserInfo.objects.all()
for obj in queryset:
    obj.depart # 拿到部门
```

#### 新建数据

***

##### 原始方式

``` python
models.UserInfo.objects.create(user=user, ..., ...)
```

##### Django组件

ModelForm

``` python
class UserModelForm(forms.ModelForm):
    class Meta:
        model = models.Employee
        fields = ['name', 'password', 'age']
        # widgets = {
        #     "name": forms.TextInput(attrs={'class': 'form-control'}),
        #     'password': forms.PasswordInput(attrs={'class': 'form-control'}),
        #     'age': forms.TextInput(attrs={'class': 'form-control'}),
        # }

    def __init__(self, *args, **kwargs):
        super().__init__()
        # 循环找到所有插件添加样式
        for filed in self.fields:
            filed.widget.attrs['class'] = 'form-control'
```

###### 表单校验

``` python
def user_modelForm_add(request):
    if request.method == 'GET':
        form = UserModelForm()
        return render(request, 'home.html', {"form": form})

    form = UserModelForm(data=request.POST)
    if form.is_valid():
        print(form.cleaned_data)
        form.save()
    else:
        print(form.errors)
```

![](D:\md笔记\python笔记\01.png)

#### 查询数据

***

##### 查询是否存在

``` python
exists = models.PrettyNum.objects.filter(mobile=text).exists()
```

##### 排除自己查询

``` python
class PrettyNumModel(ModelForm):
    ...
    
    def clean_mobile(self):
        id = self.instence.pk
		models.PrettyNum.objects.fileter(mobile=text).exclude(id=id).exists()
        ...
   	...
```

##### 查询条件

![02.png](https://www.xsblog.site/static/img/1dd9b9d12d06ce38995e7385fe3d1af2.02.webp)
##### 分页查询


![03.png](https://www.xsblog.site/static/img/9521ce9917d3a77612bdfeaee417e1e5.03.webp)

#### 登录

***

session生成和flask的一致

cookie也是随之自动生成

#### 常见的添加操作

你可以使用 Django ORM 提供的方法来创建新的用户、帖子、评论以及相关的关系。下面是一个简单的示例：

1. 新建用户：
```python
user = User.objects.create(username='John', password='password', avatar='avatar.jpg', signature='Hello')
```

2. 新建帖子：
```python
user = User.objects.get(id=user_id)  # 获取已存在的用户对象
post = Post.objects.create(user=user, title='My Post', content='Hello, world!')
```

3. 新建评论：
```python
post = Post.objects.get(id=post_id)  # 获取已存在的帖子对象
comment = Comment.objects.create(post=post, content='Great post!')
```

4. 新建用户关注：
```python
user1 = User.objects.get(id=user1_id)  # 获取已存在的用户对象
user2 = User.objects.get(id=user2_id)
user1.following.add(user2)  # user1 关注 user2
```

5. 新建用户收藏：
```python
user = User.objects.get(id=user_id)  # 获取已存在的用户对象
post = Post.objects.get(id=post_id)  # 获取已存在的帖子对象
user.favorites.add(post)  # 用户收藏帖子
```

6. 新建帖子回复：
```python
parent_comment = Comment.objects.get(id=parent_comment_id)  # 获取已存在的父级评论对象
post = parent_comment.post  # 获取父级评论所属的帖子对象
reply_comment = Comment.objects.create(post=post, parent_comment=parent_comment, content='Reply')
```

请根据你的具体需求和数据模型来适配这些示例代码，并确保在创建关联关系时使用正确的对象和字段。

### 中间件

#### 登录拦截

***



### 配置用户登录口令

#### 安装依赖

``` bash
pip install pyjwt
```

#### 配置

``` python
INSTALLED_APPS = [
    ...
    'rest_framework',
    'rest_framework_simplejwt',
    ...
]

REST_FRAMEWORK = {
    'DEFAULT_AUTHENTICATION_CLASSES': [
        'rest_framework_simplejwt.authentication.JWTAuthentication',
    ],
}

SIMPLE_JWT = {
    'AUTH_HEADER_TYPES': ('JWT',),
    'ACCESS_TOKEN_LIFETIME': timedelta(minutes=60),
    'REFRESH_TOKEN_LIFETIME': timedelta(days=1),
}
```

#### 创建登录视图，在登录成功后生成 JWT 并返回给前端：

``` python
import datetime

import jwt
from django.http import JsonResponse
from jwt import exceptions

from webServer.settings import SECRET_KEY


def authenticate_request(view_func):
    def wrapper(request, *args, **kwargs):
        # 从请求中获取 JWT 令牌
        try:
            token = request.headers.get('Authorization').split(' ')[1]
            verify_payload = jwt.decode(token, SECRET_KEY, ['HS256'], verify=True)
            return view_func(request, verify_payload, *args, **kwargs)
        except exceptions.ExpiredSignatureError:
            error_message = {'error': '登录身份过期'}
            return JsonResponse(error_message, status=401)
        except jwt.DecodeError:
            error_message = {'error': 'jwt认证失败'}
            return JsonResponse(error_message, status=401)
        except jwt.InvalidTokenError:
            error_message = {'error': '非法的token'}
            return JsonResponse(error_message, status=401)
        except AttributeError:
            error_message = {'error': '非法的访问'}
            return JsonResponse(error_message, status=401)

    return wrapper


def create_token(user):
    # 构造头部
    headers = {
        'typ': 'jwt',
        'alg': 'HS256',
    }
    # 构造payload
    payload = {
        'user_id': user.id,
        'username': user.username,
        'exp': datetime.datetime.utcnow() + datetime.timedelta(minutes=10)
    }
    result = jwt.encode(payload=payload, key=SECRET_KEY, algorithm='HS256', headers=headers)
    return result

```

Django入门可以看看哦～

flask入门，看这一篇就够了

此方法是playwright与本地浏览器以ws方式通信

可以绕过基本上大部分浏览器检测，因为这就是一个真正的浏览器

两种使用方式:

1. 每次运行程序之后先打开浏览器

> 1. 找到自己桌面chrome的快捷方式键
> 2. 点击属性
> 3. 在目标一栏的最后添加 --remote-debugging-port=9999 端口可自定义
> 4. ```
>    with sync_playwright() as p:
>    # 创建一个连接
>    browser = p.chromium.connect_over_cdp("http://localhost:9999")
>    content = browser.contexts[0]
>    page = content.new_page()
>    ```
> 5. 在上述page下进行浏览器操作即可

2. 不打开浏览器，自行打开
> 在程序中添加下面的代码即可
>```
>import subprocess
># 这个路径可以是Google浏览器的exe路径，也可以是快捷方式的路径
>chrome_path = r'"C:\Program Files\Google\Chrome\Application\chrome.exe"'
>debugging_port = "--remote-debugging-port=9999"
>
>command = f"{chrome_path} {debugging_port}"
>subprocess.Popen(command, shell=True)
>```
>之后就是
> ```
>    with sync_playwright() as p:
>    # 创建一个连接
>    browser = p.chromium.connect_over_cdp("http://localhost:9999")
>    content = browser.contexts[0]
>    page = content.new_page()
>    ```
> 在上述page下进行浏览器操作即可
> 
> __注意__:
> 此方法不可以在打开了普通版(非第一种情况)的浏览器使用

更多爬虫与反爬虫可见GitHub仓库：
[https://github.com/xishandong/crawlProject](https://github.com/xishandong/crawlProject)
```mermaid
graph TD;
    基础篇-->request篇;
    基础篇-->解析html以及正则篇;
    基础篇-->scrapy篇;
    基础篇 -->高性能异步爬虫;
    自动化篇-->selenium
    自动化篇-->playwright;
    进阶篇-->综合案例;
    进阶篇-->js逆向专题;
    js逆向专题-->请求头或响应数据加密;
    js逆向专题-->浏览器指纹检测;
    js逆向专题-->webPack篇;
    js逆向专题-->环境检测篇;
    js逆向专题-->wasm篇;
    验证码篇-->滑块篇;
```

本次逆向是shopee的请求头反爬参数的第一部分

参数定位

temu参数破解 _bee参数

前情提要

Django

创建项目初配置

更改setting

python笔记

Flask

路由配置篇

基本使用

综合案例——音乐网站