目录

音视频开发·后端开发

FFmpeg HLS 切片与签名鉴权:别只保护 m3u8

为短剧播放页签一个index.m3u8地址,并不意味着视频片段受保护。如果播放列表里的seg000.ts可以直接访问,跳过播放页仍然能拿到内容。

本文从技术实现出发:先用FFmpeg生成HLS点播素材,再用最小HMAC服务验证播放列表和每个片段都要鉴权,并用自动化测试覆盖过期、签名错误和直连绕过。短剧只是这个访问控制问题的业务场景。

环境与边界

本次实际使用Linux、FFmpeg 7.1.5-0+deb13u1和Python 3.13.5。素材是6秒本地合成画面与测试音,单码率、MPEG-TS、点播,不涉及真实剧集、订单、模型调用或付费服务。

Python http.server官方明确不推荐用于生产。本例只监听127.0.0.1,用来观察协议和鉴权边界,不是可直接公网部署的付费播放平台。未测试Safari、hls.js、移动端、真实CDN或DRM。

1. 切片长度先与GOP对齐

HLS输出包括播放列表和它引用的媒体片段。-hls_time 2设置的是目标片长,FFmpeg通常在目标时间后的关键帧处切分,不保证任意输入都精确两秒。

本例固定25fps,设置50帧GOP、关闭场景切换插入关键帧,并使用closed GOP,让视频关键帧与2秒目标边界配合。independent_segments是独立分片的声明,不会替你把任意切片修成独立可解码;需要实际编码条件和验证支持。

保存为generate.sh,运行会新建一个临时目录,不覆盖已有媒体,也不删除目录:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
#!/usr/bin/env bash
set -euo pipefail
work=$(mktemp -d "${TMPDIR:-/tmp}/hls-auth-demo.XXXXXX")
printf '%s\n' "$work"
cd "$work"
ffmpeg -hide_banner -nostdin -f lavfi -i "testsrc2=size=320x180:rate=25:duration=6" \
  -f lavfi -i "sine=frequency=440:sample_rate=48000:duration=6" \
  -map 0:v:0 -map 1:a:0 -c:v libx264 -preset veryfast -crf 23 -pix_fmt yuv420p \
  -g 50 -keyint_min 50 -sc_threshold 0 -flags +cgop \
  -c:a aac -b:a 96k -t 6 -f hls -hls_time 2 -hls_list_size 0 \
  -hls_playlist_type vod -hls_flags independent_segments \
  -hls_segment_filename 'seg%03d.ts' index.m3u8 2>encode.log
ffmpeg -hide_banner -nostdin -v error -i index.m3u8 -f null - 2>decode-errors.log

运行并保存输出目录:

1
2
bash generate.sh > sandbox-path.txt
work=$(<sandbox-path.txt)

-hls_playlist_type vod输出点播类型,-hls_list_size 0保留全部条目。不要把直播滑动窗口参数不加区分地搬来做完整点播。

本次得到三段EXTINF=2.000000,播放列表带结束标记;逐段检查首个视频包为关键帧,合并播放列表后完整解码无错误。这是本次测试素材的结果,不是对所有上传视频的承诺。

2. 先画清授权发生的位置

1
2
3
4
5
6
7
用户会话 → 业务后端核验订单/观看权益 → 签发短时播放权限
                                         ↓
                            受保护的m3u8请求
                                         ↓
                       对列表中每个片段URI逐个附加签名
                                         ↓
                        每次片段请求验证签名与有效期

本例只实现后半段的签名验证和列表重写,不实现第一步的登录、订单与权益核验,也不提供任何人都能调用的签名接口。真实系统必须先判断这个用户是否有权看这部内容,再签发对应资源权限。

本例签名消息是“精确路径 + 换行 + 到期秒数”,用HMAC-SHA256计算摘要。验签同时绑定路径和时间,避免拿列表签名套到片段路径;摘要用compare_digest比较。

列表地址上的query不会自动附加到它引用的seg000.ts。因此本例重写每个片段URI,使其带自己的路径签名。不能只签列表,再期待播放器替片段继承token。

3. 可运行的本地鉴权服务

保存下面的auth_server.py。支持范围刻意收窄:一个媒体列表、固定格式TS文件名、GET、单段bytes=start-end或bytes=start-范围请求。多范围、后缀范围、HEAD、主播放列表、fMP4初始化段与密钥URI均未实现,不能直接复用于这些格式。

代码启动时从已生成列表建立文件白名单,不允许用任意URL拼接文件路径;媒体目录应由服务自己控制,不能让不可信进程在检查后替换文件。本例拒绝符号链接,但不把启动检查当成完整文件系统隔离方案。

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
import argparse
import hashlib
import hmac
import os
import re
import time
from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
from pathlib import Path
from urllib.parse import parse_qs, urlencode, urlsplit


def signature(secret, path, expiry):
    message = f"{path}\n{expiry}".encode()
    return hmac.new(secret, message, hashlib.sha256).hexdigest()


def signed_url(secret, path, expiry):
    return path + "?" + urlencode({"exp": expiry, "sig": signature(secret, path, expiry)})


def make_server(root, secret, port=0):
    root = Path(root).resolve()
    if len(secret) < 32:
        raise ValueError("use at least 32 random bytes")
    # Strict allowlist: no arbitrary path concatenation, no nested manifests.
    allowed = {"/media/index.m3u8": root / "index.m3u8"}
    manifest = (root / "index.m3u8").read_text()
    for line in manifest.splitlines():
        if line and not line.startswith("#"):
            if not re.fullmatch(r"seg[0-9]{3}\.ts", line):
                raise ValueError("unsupported manifest URI")
            file = root / line
            if file.is_symlink() or not file.is_file():
                raise ValueError("invalid segment")
            allowed["/media/" + line] = file
    if allowed["/media/index.m3u8"].is_symlink():
        raise ValueError("manifest symlink rejected")

    class Handler(BaseHTTPRequestHandler):
        def log_message(self, *args):
            pass  # Do not log signed query strings.

        def reject(self, status, total=None):
            self.send_response(status)
            self.send_header("Cache-Control", "private, no-store")
            if total is not None:
                self.send_header("Content-Range", f"bytes */{total}")
            self.send_header("Content-Length", "0")
            self.end_headers()

        def do_GET(self):
            parsed = urlsplit(self.path)
            if parsed.path not in allowed:
                return self.reject(404)
            query = parse_qs(parsed.query, keep_blank_values=True)
            if set(query) != {"exp", "sig"} or any(len(v) != 1 for v in query.values()):
                return self.reject(403)
            raw_exp, supplied = query["exp"][0], query["sig"][0]
            if not re.fullmatch(r"[0-9]{10}", raw_exp) or not re.fullmatch(r"[0-9a-f]{64}", supplied):
                return self.reject(403)
            expiry = int(raw_exp)
            now = int(time.time())
            if expiry <= now or expiry - now > 300:
                return self.reject(403)
            expected = signature(secret, parsed.path, expiry)
            if not hmac.compare_digest(expected, supplied):
                return self.reject(403)
            if parsed.path.endswith(".m3u8"):
                lines = [signed_url(secret, "/media/" + line, expiry)
                         if line and not line.startswith("#") else line
                         for line in manifest.splitlines()]
                body = ("\n".join(lines) + "\n").encode()
                content_type = "application/vnd.apple.mpegurl"
            else:
                body = allowed[parsed.path].read_bytes()
                content_type = "video/mp2t"
            total = len(body)
            content_range = None
            if "Range" in self.headers:
                match = re.fullmatch(r"bytes=([0-9]+)-([0-9]*)", self.headers["Range"])
                if not match:
                    return self.reject(416, total)
                start = int(match[1])
                end = min(int(match[2]), total - 1) if match[2] else total - 1
                if start >= total or end < start:
                    return self.reject(416, total)
                body = body[start:end + 1]
                content_range = f"bytes {start}-{end}/{total}"
            self.send_response(206 if content_range else 200)
            if content_range:
                self.send_header("Content-Range", content_range)
            self.send_header("Accept-Ranges", "bytes")
            self.send_header("Content-Type", content_type)
            self.send_header("Cache-Control", "private, no-store")
            self.send_header("Content-Length", str(len(body)))
            self.end_headers()
            self.wfile.write(body)

    return ThreadingHTTPServer(("127.0.0.1", port), Handler)


if __name__ == "__main__":
    parser = argparse.ArgumentParser()
    parser.add_argument("root")
    parser.add_argument("--port", type=int, default=8088)
    args = parser.parse_args()
    secret = bytes.fromhex(os.environ["HLS_DEMO_SECRET"])
    server = make_server(args.root, secret, args.port)
    print(f"Listening on 127.0.0.1:{server.server_port}", flush=True)
    try:
        server.serve_forever()
    finally:
        server.server_close()

自动化测试会自己生成随机密钥、启动随机本地端口并结束服务,不需要你手工配置密钥。若仅在自己的隔离环境手动启动,代码入口从HLS_DEMO_SECRET环境变量读入32字节以上随机密钥的十六进制编码;不要把真实密钥、签名链接或带token的访问日志放到公开文章和工单里。

签名链接是短时持有者凭证,拿到链接的人在过期前仍能访问。这里没有绑定用户会话,也没有实现即刻撤销;时间校验并不等于完整用户授权。

4. 完整正反向测试

保存为test_hls.py,与auth_server.py放在同一目录。测试仅使用合成文件;不会访问真实订单或外部CDN。它最后会让FFmpeg通过本地HTTP读取签名列表和分片并解码,而不是只用Python检查几个200响应。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
import json
import secrets
import subprocess
import sys
import threading
import time
from pathlib import Path
from urllib.error import HTTPError
from urllib.request import Request, urlopen
from auth_server import make_server, signed_url

root = Path(sys.argv[1])
secret = secrets.token_bytes(32)
server = make_server(root, secret)
thread = threading.Thread(target=server.serve_forever, daemon=True)
thread.start()
origin = f"http://127.0.0.1:{server.server_port}"
expiry = int(time.time()) + 120
checks = []

def check(name, ok):
    assert ok, name
    checks.append(name)

def get(path, headers=None):
    try:
        with urlopen(Request(origin + path, headers=headers or {}), timeout=5) as response:
            return response.status, response.read(), dict(response.headers)
    except HTTPError as e:
        return e.code, e.read(), dict(e.headers)

try:
    local = (root / "index.m3u8").read_text()
    durations = [float(line.split(":", 1)[1].rstrip(",")) for line in local.splitlines() if line.startswith("#EXTINF:")]
    check("three two-second video segments", len(durations) == 3 and all(abs(d-2) < 0.05 for d in durations))
    check("VOD end marker", "#EXT-X-ENDLIST" in local)
    for i in range(3):
        packets = json.loads(subprocess.check_output(["ffprobe", "-v", "error", "-select_streams", "v:0",
            "-read_intervals", "%+#1", "-show_packets", "-show_entries", "packet=flags", "-of", "json",
            str(root / f"seg{i:03d}.ts")]))["packets"]
        check("segment starts with video keyframe " + str(i), bool(packets) and "K" in packets[0]["flags"])
    check("local decode has no error", (root / "decode-errors.log").stat().st_size == 0)
    playlist = signed_url(secret, "/media/index.m3u8", expiry)
    status, body, headers = get(playlist)
    check("signed playlist allowed", status == 200)
    check("private no-store playlist", headers["Cache-Control"] == "private, no-store")
    segments = [s for s in body.decode().splitlines() if s and not s.startswith("#")]
    check("every segment URI carries own token", len(segments) == 3 and all("?exp=" in s and "&sig=" in s for s in segments))
    for i, segment in enumerate(segments):
        status, data, hdr = get(segment)
        check("signed segment " + str(i), status == 200 and len(data) > 0 and hdr["Content-Type"] == "video/mp2t")
    check("unsigned playlist denied", get("/media/index.m3u8")[0] == 403)
    check("unsigned segment denied", get("/media/seg000.ts")[0] == 403)
    check("expired signature denied", get(signed_url(secret, "/media/seg000.ts", int(time.time())-1))[0] == 403)
    check("wrong secret denied", get(signed_url(secrets.token_bytes(32), "/media/seg000.ts", expiry))[0] == 403)
    wrong_path = "/media/seg000.ts?" + playlist.split("?", 1)[1]
    check("playlist token cannot authorize segment", get(wrong_path)[0] == 403)
    check("duplicate query denied", get(playlist + "&exp=" + str(expiry))[0] == 403)
    check("unexpected path denied", get("/media/%2e%2e/secret")[0] == 404)
    r_status, r_data, r_headers = get(segments[0], {"Range": "bytes=0-10"})
    check("single byte range supported", r_status == 206 and len(r_data) == 11 and r_headers["Content-Range"].startswith("bytes 0-10/"))
    check("unsatisfiable range rejected", get(segments[0], {"Range": "bytes=9999999999-"})[0] == 416)
    check("overlong validity denied", get(signed_url(secret, "/media/index.m3u8", int(time.time())+600))[0] == 403)
    # Output is discarded; authenticated manifest and each segment fetched over local HTTP.
    run = subprocess.run(["ffmpeg", "-nostdin", "-v", "error", "-i", origin + playlist, "-f", "null", "-"],
                         capture_output=True, timeout=30)
    check("FFmpeg HTTP decode with segment auth", run.returncode == 0 and run.stderr == b"")
    print(json.dumps({"sandbox": str(root), "checks": checks, "count": len(checks),
         "durations": durations,
         "scope": "local TS VOD and localhost HMAC auth; no browser/CDN/DRM/order system validation"}, ensure_ascii=False, indent=2))
finally:
    server.shutdown()
    thread.join(timeout=5)
    server.server_close()

执行:

1
python3 test_hls.py "$work"

本次23项断言通过,覆盖三段2秒切片、逐片关键帧、本地解码、合法列表和片段、每个URI自己的签名、过期拒绝、错误密钥拒绝、列表签名不能用于片段、重复参数拒绝、未知路径拒绝、单段Range和越界Range、超长有效期拒绝,以及FFmpeg真实走本地HTTP的完整解码。

这仍然只是本地HTTP客户端验证,不能写成“浏览器播放兼容已通过”或“线上付费鉴权已完成”。

测试暴露的一处实际问题

第一版仅实现完整文件GET,拒绝了所有Range请求;FFmpeg的HTTP解码测试没有通过。补充单段Range、返回正确206和Content-Range后,才通过上述链路验证。

这说明签名正确和文件存在还不够:媒体客户端的实际请求方式也属于交付契约。但本例只支持已列出的Range子集,不能宣称实现完整HTTP服务器。

5. 缓存和有效期不能留到最后考虑

示例用Cache-Control: private, no-store,故意优先展示鉴权,不做共享缓存优化。生产CDN如果缓存绕过了验签,或者缓存命中时不检查权限,源站签名再严也可能失效。

生产设计应确认:边缘还是源站验签;缓存键是否包含token;从缓存命中时如何仍保证访问控制;对象存储与源站是否有未鉴权的直连地址。仅移除query参数以提高缓存命中,不是完整方案。

本例沿用同一个到期时刻签每个片段。六秒测试可以完成,真实长视频在中途过期会失败;应设计权益检查、刷新播放权限、播放器重新加载的流程。不要单纯把有效期拉长到数天来掩盖刷新缺失。

自适应多码率会增加主列表、子列表及多个资源路径。fMP4还可能引用初始化段,带加密的HLS会引用密钥地址。它们也应在同一保护边界内,但不在本次代码与实测范围。

6. 这不是DRM,也不是防录屏

签名URL控制谁能在何时请求资源,不是媒体加密;HLS AES-128加密也不自动等于DRM,更不保证阻止有权限用户录屏或下载。不要把“链接过期”写成“内容无法复制”。

真实播放系统还要处理HTTPS、业务认证、权益撤销、速率与并发限制、密钥轮换、安全日志、跨域、监控和异常账单。短剧试看可设计独立试看资产或受控播放区间,但仅让前端隐藏后续集数不能替代后端鉴权。

发布和回滚

把新切片作为新版本上传,先检查列表里每个资源均存在、均受相同鉴权边界保护,再切换引用;不要原地覆盖仍被客户端缓存的分片。

本例没有清理线上资源、配置CDN或修改对象存储权限。生产回滚要同时考虑列表、分片与token策略:恢复到有直连漏洞的旧配置,并不算安全回滚。

官方参考

在线手册会更新,本例还核对了实际安装版本的ffmpeg -h muxer=hls输出。没有把合成样例的成功推断为真实CDN成本、首屏时间、抗盗链强度或高并发能力。

同专题

这三篇可以单独阅读。说明见 视频任务与交付:三个可独立复现的技术示例。上一篇是 FFmpeg 合成字幕与音轨:显式选流、中文字体和时长对齐。