影视链接解密爬虫实战：AES加密与反爬策略-代码聚汇网

影视链接解密爬虫实战：AES加密与反爬策略

网络爬虫AES加密反爬策略

|难度：普通|阅读约 18 分钟

1. 影视链接解密爬虫的核心挑战

当我们试图从影视网站抓取播放链接时，最常遇到的障碍就是各种形式的链接加密。不同于普通网页抓取，影视资源链接往往经过多重混淆处理，这是平台防止资源被批量爬取的技术手段。典型的加密方式包括：

时间戳验证：链接有效期通常只有几分钟
参数签名：必须携带动态生成的hash值
分段混淆：真实地址被拆分成多个JS变量
动态加载：通过AJAX二次请求获取真实地址
反调试检测：检测到开发者工具会自动跳转

最近在分析某影视站时，我发现他们的加密策略尤为复杂。播放页面的m3u8地址并非直接暴露在HTML中，而是通过以下流程生成：

页面加载时先请求一个初始化接口获取token
用token和当前时间戳拼接生成签名
将签名作为参数请求第二个接口
返回的JSON中包含经过AES加密的m3u8地址
前端用固定IV进行解密后播放

需要模型API调用？免费领10W Token，多模型网关一键接入 Claude、DeepSeek 等主流模型。

2. 逆向工程实战步骤

2.1 抓包定位关键接口

使用Chrome开发者工具的Network面板，过滤XHR请求后可以清晰看到两个关键接口：

javascript复制// 初始化接口
GET /api/v1/init?vid=123456 HTTP/1.1

// 返回示例
{
  "code": 200,
  "data": {
    "token": "7a89f3d2",
    "expire": 300
  }
}

// 播放地址接口  
GET /api/v1/play?token=7a89f3d2&t=1629091289&sign=80f3a9b7 HTTP/1.1

// 返回示例
{
  "code": 200,
  "data": {
    "cipher": "U2FsdGVkX1+ihJyJ5J5h5g==" 
  }
}

2.2 解析加密算法

通过调试前端JS代码，发现解密逻辑隐藏在player.min.js中。使用Chrome的Pretty-print功能格式化代码后，关键解密函数如下：

javascript复制function decrypt(cipherText) {
  const key = CryptoJS.enc.Utf8.parse('b3BlbnNlc3NhbWU=');
  const iv = CryptoJS.enc.Utf8.parse('1234567812345678');
  const decrypted = CryptoJS.AES.decrypt(
    cipherText,
    key,
    { iv: iv, mode: CryptoJS.mode.CBC }
  );
  return decrypted.toString(CryptoJS.enc.Utf8);
}

这显示网站使用CBC模式的AES加密，需要特别注意：

密钥是base64编码的字符串
IV固定为'1234567812345678'
密文需要先进行URL安全解码

2.3 Python实现解密

基于以上分析，我们可以用PyCryptodome库实现相同的解密逻辑：

python复制from Crypto.Cipher import AES
from Crypto.Util.Padding import unpad
import base64

def decrypt_url(cipher_text):
    key = base64.b64decode('b3BlbnNlc3NhbWU=')
    iv = b'1234567812345678'
    cipher = AES.new(key, AES.MODE_CBC, iv)
    
    # 先进行URL安全解码
    cipher_text = cipher_text.replace('-', '+').replace('_', '/')
    cipher_bytes = base64.b64decode(cipher_text)
    
    # 解密并去除padding
    plain_bytes = unpad(cipher.decrypt(cipher_bytes), AES.block_size)
    return plain_bytes.decode('utf-8')

3. 完整爬虫架构设计

3.1 请求流程编排

完整的爬取流程需要模拟浏览器行为：

获取视频ID（通常从列表页解析）
请求初始化接口获取token
生成当前时间戳（精确到秒）
计算签名（通常为md5(token+timestamp+secret)）
请求播放接口获取加密地址
解密得到真实m3u8地址
处理分片下载和合并

3.2 签名算法逆向

通过调试前端代码，发现签名算法实际上是：

javascript复制function genSign(token, timestamp) {
  const secret = 'd3d3LnlpbmdzaGlkYW8uY29t';
  const str = token + timestamp + secret;
  return md5(str).substr(8, 16);
}

对应的Python实现：

python复制import hashlib

def generate_sign(token, timestamp):
    secret = 'd3d3LnlpbmdzaGlkYW8uY29t'
    s = f"{token}{timestamp}{secret}".encode('utf-8')
    return hashlib.md5(s).hexdigest()[8:24]

3.3 反反爬策略

该网站采用了以下反爬机制：

User-Agent检测（必须模拟移动端）
IP频率限制（单个IP每分钟不超过20次）
请求间隔检测（连续请求需间隔1秒以上）
Cookie验证（需要维持会话）

建议采用以下应对方案：

python复制headers = {
    'User-Agent': 'Mozilla/5.0 (iPhone; CPU iPhone OS 13_2_3 like Mac OS X)',
    'Referer': 'https://m.xxxx.com/',
    'X-Requested-With': 'XMLHttpRequest'
}

proxies = {
    'http': 'http://proxy_pool:5010/get/'
}

# 使用requests.Session保持会话
session = requests.Session()
session.headers.update(headers)

4. 进阶技巧与异常处理

4.1 动态密钥处理

某些高级影视站会定期更换密钥，可以通过以下方式应对：

建立密钥轮询机制，每小时检查一次
当解密失败时自动触发密钥更新
将密钥存储在Redis中并设置过期时间

python复制import redis

r = redis.Redis(host='localhost', port=6379)

def get_current_key():
    key = r.get('aes:key')
    if not key:
        key = fetch_new_key()  # 实现密钥获取逻辑
        r.setex('aes:key', 3600, key)
    return key

4.2 自动化调试技巧

使用Pyppeteer可以绕过大多数前端检测：

python复制from pyppeteer import launch

async def get_decrypted_url(page_url):
    browser = await launch(headless=True)
    page = await browser.newPage()
    
    # 伪装移动端环境
    await page.setUserAgent('Mozilla/5.0 (iPhone; CPU iPhone OS 13_2_3 like Mac OS X)')
    
    # 监听接口响应
    async def intercept_response(response):
        if '/api/v1/play' in response.url:
            json_data = await response.json()
            cipher = json_data['data']['cipher']
            return decrypt_url(cipher)
    
    page.on('response', intercept_response)
    
    await page.goto(page_url)
    await page.waitForSelector('.player-container')
    
    # 获取最终解密后的地址
    m3u8_url = await page.evaluate('''() => {
        return player.getCurrentSrc();
    }''')
    
    await browser.close()
    return m3u8_url

4.3 常见异常处理

在实际运行中可能会遇到：

403 Forbidden：通常因请求头不完整导致，需要检查：
- Referer是否正确
- 是否携带了必要的Cookie
- User-Agent是否为移动端
解密失败：可能原因包括：
- 密钥已更新（需重新获取）
- 密文未进行URL解码
- IV与加密时不一致
IP被封禁：解决方案：
- 使用代理IP池轮换
- 降低请求频率
- 添加随机延迟（0.5-3秒）

python复制import random
import time

def safe_request(url, retry=3):
    for i in range(retry):
        try:
            time.sleep(random.uniform(0.5, 2))
            resp = session.get(url, proxies=proxies, timeout=10)
            if resp.status_code == 200:
                return resp
            elif resp.status_code == 403:
                raise Exception('触发反爬')
        except Exception as e:
            if i == retry - 1:
                raise
            time.sleep(5 ** i)  # 指数退避

5. 性能优化方案

5.1 异步并发处理

使用aiohttp可以大幅提升爬取效率：

python复制import aiohttp
import asyncio

async def fetch_video(sem, vid):
    async with sem:
        async with aiohttp.ClientSession() as session:
            # 获取token
            init_url = f'https://api.xxx.com/init?vid={vid}'
            async with session.get(init_url) as resp:
                token = (await resp.json())['data']['token']
            
            # 获取播放地址
            ts = int(time.time())
            sign = generate_sign(token, ts)
            play_url = f'https://api.xxx.com/play?token={token}&t={ts}&sign={sign}'
            async with session.get(play_url) as resp:
                cipher = (await resp.json())['data']['cipher']
                return decrypt_url(cipher)

async def main(vids):
    sem = asyncio.Semaphore(10)  # 控制并发数
    tasks = [fetch_video(sem, vid) for vid in vids]
    return await asyncio.gather(*tasks)

5.2 缓存机制实现

为避免重复请求，可以建立两级缓存：

内存缓存（短期）
磁盘缓存（长期）

python复制from diskcache import Cache

cache = Cache('./video_cache')

@cache.memoize(expire=3600)
def get_video_url(vid):
    # 正常请求流程
    return decrypted_url

5.3 分布式扩展

对于大规模爬取，建议采用：

Redis任务队列
Celery分布式任务
多进程消费模式

典型架构：

code复制爬虫节点A → Redis任务队列 → 多个Worker节点
           ↑
爬虫节点B →

实现示例：

python复制# producer.py
import redis
r = redis.Redis()
for vid in video_list:
    r.lpush('video:task', vid)

# worker.py
while True:
    vid = r.brpop('video:task')[1]
    url = process_video(vid)
    r.hset('video:result', vid, url)