响应头 · XB 现场笔记

Content-Type 告诉读它的人这是什么

Sat, 10 Oct 2026 00:00:00 +0000

Content-Type 描述发送方打算提供的表示，但它不会检查正文、转换字节，也不保证所有接收方都采取相同的处理方式。可靠的接口需要让序列化结果、媒体类型声明和消费者的预期相互吻合。这个要求不仅适用于成功响应，也适用于认证失败、代理报错和应用异常等不同的返回路径。

描述表示，而不是文件名

对于携带正文的普通响应，application/json 表示 JSON 数据，text/html 表示 HTML。类型描述的是解除内容编码之后的数据格式。因此，一份经过 gzip 压缩的 JSON 响应仍然声明 Content-Type: application/json，同时用 Content-Encoding: gzip 说明压缩。内容编码属于表示的属性，不等于 HTTP 消息如何分帧；例如分块传输编码处理的是另一层问题。修改文件扩展名或响应头都不会自动完成这些转换。

媒体类型由主类型、子类型以及可选参数构成。主类型和子类型不区分大小写，参数是否有意义则取决于对应媒体类型的定义。消费者应使用已有的头字段解析接口，不要把完整字段与一个固定字符串直接比较。同时必须单独检查字段是否存在，因为部分解析器会给缺失类型提供默认值，掩盖服务端漏发元数据的事实。多个相互冲突的类型字段也不是合法的候选列表，而是需要在源站或代理处修正的缺陷。

对于 UTF-8 编码的 HTML，text/html; charset=utf-8 同时描述格式与字符编码。但不能据此给每一种文本格式统一追加字符集参数。RFC 8259 要求非封闭生态系统之间交换的 JSON 使用 UTF-8，而 application/json 的媒体类型注册没有定义 charset 参数。接收方不能靠另加一个参数，就把不符合该交换约定的字节变成合规 JSON。类型参数必须服从格式本身的规定，而不是套用全站通用字符串。

坏掉的样子

常见故障是反向代理把 API 响应替换成 HTML 登录页，却仍返回成功状态码。客户端一上来就调用 JSON 解析器，只能看到语法错误，反而隐藏了“收到另一种表示”这个更有价值的线索。另一种情况恰好相反：应用错误处理器输出 HTML，却沿用了成功路径的 JSON 响应头。这时仅检查声明也会放行无效正文。所以，状态码、响应元数据和实际字节是三个需要一起检查的证据。

缺失类型并不意味着所有客户端都会拒绝响应。RFC 9110 允许接收方把它当作不透明二进制数据，也允许检查正文来确定类型；部分用户代理还会通过嗅探覆盖已有声明。浏览器的具体行为与处理上下文有关，不能用一个命令行 JSON 客户端来证明所有页面、脚本或其他资源都安全。正确媒体类型是必要的元数据，但既不能净化 HTML，也不能证明用户上传的文件适合公开提供。内容安全需要单独依据实际使用场景验证。

快速验证

使用 Python 3.11 或更新版本运行下面的完整程序。它在回环地址申请临时端口，发出四次真实 HTTP 请求，最后关闭连接与服务器，不访问外网，也不安装依赖。实验消费者明确只接受 application/json，然后按 UTF-8 解码并解析 JSON。这是一个范围明确的消费者契约，不是通用内容协商器，也没有模拟浏览器的完整处理规则。

import json
from http.client import HTTPConnection
from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
from threading import Thread

cases = {
 "/ok": ("application/json", b'{"ok":true}'),
 "/wrong-type": ("text/plain", b'{"ok":true}'),
 "/bad-body": ("application/json", b"not JSON"),
 "/missing-type": (None, b'{"ok":true}'),
}


class Handler(BaseHTTPRequestHandler):
 def do_GET(self):
 media, body = cases[self.path]
 self.send_response(200)
 if media is not None:
 self.send_header("Content-Type", media)
 self.send_header("Content-Length", str(len(body)))
 self.end_headers()
 self.wfile.write(body)

 def log_message(self, *args):
 pass


server = ThreadingHTTPServer(("127.0.0.1", 0), Handler)
worker = Thread(target=server.serve_forever)
worker.start()
try:
 outcomes = []
 for route in cases:
 connection = HTTPConnection("127.0.0.1", server.server_port, timeout=3)
 try:
 connection.request("GET", route)
 response = connection.getresponse()
 body = response.read()
 assert response.status == 200
 if response.headers.get("Content-Type") is None:
 outcome = "missing type"
 elif response.headers.get_content_type() != "application/json":
 outcome = "wrong type"
 else:
 try:
 value = json.loads(body.decode("utf-8"))
 except (UnicodeDecodeError, json.JSONDecodeError):
 outcome = "invalid body"
 else:
 assert value == {"ok": True}
 outcome = "accepted"
 outcomes.append(outcome)
 print(route, outcome)
 finally:
 connection.close()
 assert outcomes == ["accepted", "wrong type", "invalid body", "missing type"]
finally:
 server.shutdown()
 server.server_close()
 worker.join()

按路径顺序，结果应为 accepted、wrong type、invalid body、missing type，分别表示接收成功、类型错误、正文无效、缺失类型。第一、第二和第四条响应具有完全相同的正文，结果却不同，因此隔离出了声明检查的作用。第三条声明正确，但正文不能按 JSON 语法解析，证明标签检查无法替代内容验证。程序断言这些结果，出现不一致会直接失败；这些拒绝规则属于实验消费者，不是要求所有 HTTP 客户端必须作出相同选择。

排查实际故障时，应从真实失败的认证或匿名访问路径获取 GET 响应，但不要把凭据写进诊断输出。还要记录重定向后的最终地址，因为原本要访问的资源与登录页是不同端点。比较源站与代理的结果，既测成功路径，也测错误处理路径。仅查看 HEAD 元数据无法证明正文可以解析；仅在服务器本机打开文件，也无法证明公网经过代理后的响应仍然一致。找到第一次引入不一致的组件，在那里修复，然后沿完整交付路径再次请求并验证正文。不要用客户端猜类型来掩盖错误页面被当成 API 响应的问题。

来源

RFC 9110：Content-Type，媒体类型、字段缺失、嗅探以及相邻章节的内容编码定义，已核验 2026-09-07。
RFC 8259：JSON，UTF-8 交换要求与 application/json 注册，已核验 2026-09-07。

HSTS 让浏览器记住 HTTPS

Thu, 08 Oct 2026 00:00:00 +0000

HTTP 严格传输安全 HSTS 告诉支持它的客户端：以后访问记住的主机名时使用 HTTPS。它可以消除重定向之前的那次明文 HTTP 请求，但前提是客户端已经通过此前可信响应或受支持的预加载机制知道策略。只在服务器添加一个 Header，不能追溯保护未知客户端第一次发出的 HTTP 请求。

客户端记住的是主机名

客户端通过没有安全错误的 HTTPS 收到有效 Strict-Transport-Security 后，才建立或刷新策略。max-age 是从接收时刻起计算的秒数。明文 HTTP 上的同名 Header 不能建立这种信任；后来某次响应没有 Header，也不会删除尚未过期的记录。状态由各个客户端分别维护，浏览器之间不存在自动共享的统一缓存。

策略范围是 DNS 主机名，不是包含协议和端口的 HTTP origin。includeSubDomains 向下覆盖子域名，不覆盖父域或同级名称。升级 URL 时，显式的 80 端口会改为 443，其他显式端口保持不变。因此，原本在另一个端口上提供的 HTTP-only 服务，也可能在客户端学习策略后变得不可用。

这条规则改变的是客户端处理 URL 的方式，不会自动把服务器的明文监听器变成 TLS 监听器；升级后的目标必须事先具备 HTTPS 服务。下面的实验故意在 HTTP 响应中发送 HSTS，只作为反向测试，并不是部署建议。两个测试服务都不返回重定向，因此从 HTTP URL 进入 TLS handler，证明的是客户端主动升级，而非成功跟随了一串服务端跳转。

HSTS 是升级规则，不是绕过证书验证的开关。支持它的浏览器仍须验证 HTTPS，而且面对 HSTS 主机的证书错误，不提供通常的点击继续入口。它不能修复过期证书、恢复不可用的 TLS 服务，也不能证明认证连接背后的应用内容一定可信。

坏掉的样子

较长的有效期或 includeSubDomains 可能影响被遗忘的服务、委托给其他团队的子域和内部名称。扩大范围前，应先清点这些依赖，从较短策略开始，检查真实入口，并确认续期链路可靠。扫描器建议增加某个字段，并不等于所有受影响主机都已经能够履行承诺。

恢复时也要分清机制。客户端收到可信的 max-age=0 响应后，会移除该主机的动态策略，但不会删除子域独立保存的策略，也不能立刻更新尚未再次连接的离线客户端。仅删除响应头不够；浏览器预加载名单的分发和移除，又是独立流程，不会随着服务端切换字段马上完成。

仅验证 Header 存在，不能证明客户端真的按它行动。测试应使用独立状态库，同时检查初始访问和后续 HTTP URL，避免污染个人浏览器配置。也不要为了看到一次“升级成功”，就关闭证书验证。客户端实现或预加载配置不同，需要分别验收，不能把一个工具的结果套到所有浏览器上。

快速验证

保存为 hsts_probe.go，使用 Go 1.23 或更新版本，以及支持 –hsts 的 curl，运行 go run hsts_probe.go。程序建立两个回环服务并生成临时 P-256 CA，只把公开 CA 证书和 curl 缓存写进独立临时目录，退出时删除该目录。私钥始终留在内存中，不写入文件。

package main

import (
 "context"
 "crypto/ecdsa"
 "crypto/elliptic"
 "crypto/rand"
 "crypto/tls"
 "crypto/x509"
 "crypto/x509/pkix"
 "encoding/pem"
 "errors"
 "fmt"
 "io"
 "log"
 "math/big"
 "net/http"
 "net/http/httptest"
 "net/url"
 "os"
 "os/exec"
 "path/filepath"
 "runtime"
 "strings"
 "sync/atomic"
 "time"
)

func must(err error) {
 if err != nil {
 panic(err)
 }
}

func check(ok bool, message string) {
 if !ok {
 panic(message)
 }
}

func issue(template, parent *x509.Certificate, public any, signer *ecdsa.PrivateKey) *x509.Certificate {
 der, err := x509.CreateCertificate(rand.Reader, template, parent, public, signer)
 must(err)
 certificate, err := x509.ParseCertificate(der)
 must(err)
 return certificate
}

func main() {
 curl, err := exec.LookPath("curl")
 must(err)
 versionCommand := exec.Command(curl, "--disable", "--version")
 versionCommand.Env = append(os.Environ(), "SSLKEYLOGFILE=")
 version, err := versionCommand.Output()
 must(err)
 check(strings.Contains(string(version), "HSTS"), "curl must support HSTS")
 caKey, err := ecdsa.GenerateKey(elliptic.P256(), rand.Reader)
 must(err)
 leafKey, err := ecdsa.GenerateKey(elliptic.P256(), rand.Reader)
 must(err)
 now := time.Now()
 template := &x509.Certificate{
 SerialNumber: big.NewInt(1), Subject: pkix.Name{CommonName: "HSTS fixture CA"},
 NotBefore: now.Add(-time.Minute), NotAfter: now.Add(time.Hour),
 IsCA: true, BasicConstraintsValid: true, KeyUsage: x509.KeyUsageCertSign,
 }
 ca := issue(template, template, caKey.Public(), caKey)
 host, child := "hsts.example.test", "child.hsts.example.test"
 leaf := issue(&x509.Certificate{
 SerialNumber: big.NewInt(2), DNSNames: []string{host, child},
 NotBefore: now.Add(-time.Minute), NotAfter: now.Add(time.Hour),
 KeyUsage: x509.KeyUsageDigitalSignature, ExtKeyUsage: []x509.ExtKeyUsage{x509.ExtKeyUsageServerAuth},
 }, ca, leafKey.Public(), caKey)
 folder, err := os.MkdirTemp("", "hsts-probe-")
 must(err)
 defer func() { must(os.RemoveAll(folder)) }()
 caFile, cacheFile := filepath.Join(folder, "ca.pem"), filepath.Join(folder, "hsts.txt")
 must(os.WriteFile(caFile, pem.EncodeToMemory(&pem.Block{Type: "CERTIFICATE", Bytes: ca.Raw}), 0600))

 var plainCount, secureCount atomic.Int64
 plain := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 plainCount.Add(1)
 if r.URL.Path == "/learn" {
 w.Header().Set("Strict-Transport-Security", "max-age=3600; includeSubDomains")
 }
 fmt.Fprint(w, "plain")
 }))
 defer plain.Close()
 secure := httptest.NewUnstartedServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 secureCount.Add(1)
 check(r.TLS != nil, "secure handler requires TLS")
 switch r.URL.Path {
 case "/learn":
 w.Header().Set("Strict-Transport-Security", "max-age=3600; includeSubDomains")
 case "/clear":
 w.Header().Set("Strict-Transport-Security", "max-age=0")
 }
 fmt.Fprint(w, "secure")
 }))
 secure.Config.ErrorLog = log.New(io.Discard, "", 0)
 secure.TLS = &tls.Config{
 MinVersion: tls.VersionTLS12,
 Certificates: []tls.Certificate{{Certificate: [][]byte{leaf.Raw}, PrivateKey: leafKey, Leaf: leaf}},
 }
 secure.StartTLS()
 defer secure.Close()
 plainURL, err := url.Parse(plain.URL)
 must(err)
 secureURL, err := url.Parse(secure.URL)
 must(err)
 check(plainURL.Hostname() == "127.0.0.1" && secureURL.Hostname() == "127.0.0.1", "IPv4 loopback fixtures required")
 request := func(scheme, name, port, route string, trust bool) (string, error) {
 ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
 defer cancel()
 args := []string{
 "--disable", "--noproxy", "*", "--silent", "--show-error", "--fail",
 "--max-time", "3", "--hsts", cacheFile, "--resolve", name + ":" + port + ":127.0.0.1",
 }
 if trust {
 args = append(args, "--cacert", caFile)
 }
 args = append(args, scheme+"://"+name+":"+port+route)
 command := exec.CommandContext(ctx, curl, args...)
 command.Env = append(os.Environ(), "SSLKEYLOGFILE=")
 output, err := command.CombinedOutput()
 return string(output), err
 }
 _, err = request("https", host, secureURL.Port(), "/learn", false)
 var exit *exec.ExitError
 check(errors.As(err, &exit) && exit.ExitCode() == 60, "untrusted HTTPS must fail certificate verification")
 for _, test := range []struct {
 label, scheme, name, port, route, expected string
 }{
 {"HTTP cannot seed HSTS", "http", host, plainURL.Port(), "/learn", "plain"},
 {"still HTTP", "http", host, plainURL.Port(), "/probe", "plain"},
 {"trusted HTTPS seeds HSTS", "https", host, secureURL.Port(), "/learn", "secure"},
 {"HTTP URL upgrades", "http", host, secureURL.Port(), "/probe", "secure"},
 {"child inherits upgrade", "http", child, secureURL.Port(), "/probe", "secure"},
 {"authenticated removal", "https", host, secureURL.Port(), "/clear", "secure"},
 {"parent HTTP restored", "http", host, plainURL.Port(), "/probe", "plain"},
 {"child HTTP restored", "http", child, plainURL.Port(), "/probe", "plain"},
 } {
 output, err := request(test.scheme, test.name, test.port, test.route, true)
 check(err == nil, fmt.Sprintf("curl failed: %v: %s", err, output))
 check(output == test.expected, "wrong transport result")
 fmt.Println(test.label, "->", output)
 }
 check(plainCount.Load() == 4 && secureCount.Load() == 4, "expected four plaintext and four authenticated TLS requests")
 fmt.Println(strings.SplitN(string(version), "\n", 2)[0])
 fmt.Println(runtime.Version())
}

所有测试主机名都通过 –resolve 显式指向回环地址，不访问公共 DNS 或外部站点。–disable 放在 curl 参数最前面，避免加载个人配置；–noproxy 排除代理干扰。所有 curl 子进程都清空 SSLKEYLOGFILE，禁用从环境继承的 TLS 密钥日志。每次传输限时三秒，外层进程还有五秒截止时间。测试 CA 按请求传入，不安装到系统信任库。

第一次 HTTPS 请求没有携带测试 CA，必须以 curl 证书验证错误码 60 失败。随后即使明文 HTTP 响应发送了 HSTS，下一次访问仍然是明文。经过验证的 HTTPS 响应才会写入共享测试缓存；此后父域和子域的 HTTP URL 都进入 TLS handler。

可信的 max-age=0 响应移除父域记录后，父域和子域的 HTTP 请求又能进入明文 handler，因为本例从未给子域设置独立策略。最终两个 handler 各处理四次请求，证书验证失败的那次不进入任何应用 handler。升级过程中，URL 中显式给出的非标准 TLS 端口保持不变。

已核验的 macOS、Go 1.27.0、curl 8.7.1 运行通过全部断言。这验证的是 curl 真实的 HSTS 行为，不是浏览器策略验收。实验没有检查浏览器预加载名单、子域独立策略、等待到期、80 到 443 的端口映射、证书错误界面或生产发布。临时缓存随后被删除，不改变用户已有的持久 HSTS 状态。

来源

RFC 6797：HTTP 严格传输安全，经过认证的策略处理、主机范围和端口映射，已核验 2026-09-09。
MDN：Strict-Transport-Security，子域策略、移除和预加载边界，已核验 2026-09-09。
curl 手册，–hsts、显式名称解析、CA 选择与配置隔离，已核验 2026-09-09。

安全响应头需要可观察的浏览器行为

Wed, 30 Sep 2026 00:00:00 +0000

安全响应头让支持它们的浏览器执行具体规则，价值来自这些规则改变了什么行为，而不是检查清单有多长。即使是静态站点，也涉及文档加载、脚本或样式、页面嵌入、导航和传输等边界。应根据真实页面及交付路径选择策略，同时验证预期限制和合法功能。不能把响应里出现一串熟悉字段，当成已经证明页面完整、安全且不会破坏正常集成。

内容安全策略可以限制资源加载与脚本执行，嵌入祖先指令规定哪些祖先能够包含受保护文档，引用来源策略控制适用请求携带多少源地址信息，权限策略则约束选定的浏览器功能。CSP 的 frame-ancestors 必须通过 HTTP 响应头交付；写在 meta 元素里不会建立这个嵌入策略。这些控制相互关联，但没有哪一个只凭字段存在，就能建立经过认证的业务权限。适合某类响应的规则，放到另一类响应上可能毫无意义，也可能妨碍页面原本需要的行为。

理解每个响应头负责的边界

严格传输安全策略告诉浏览器，对适用的主机使用 HTTPS。浏览器从有效的 HTTPS 响应学习该策略，普通 HTTP 响应不能建立它。包含子域名的设置还会影响当前应用之外的主机，因此这些主机需要支持预期的安全传输方式。这个响应头不会签发证书，也不会修复已经过期的证书；在依赖浏览器长期记住的策略之前，传输配置本身必须已经可靠。

跨源开启者策略影响浏览上下文和开启者隔离，跨源资源策略则限制某些跨源资源加载。把二者统称为隔离所有窗口的通用开关，会混淆各自约定。CORS 响应暴露又是另一套机制。修改相关策略时，应验证依赖弹出窗口、嵌入资源或跨源访问的实际集成，而不是把能找到的所有响应头复制到同一条规则中，再期待它们自动组合成正确结果。

坏掉的样子

nosniff 让浏览器处理资源时尊重声明的内容类型。对于脚本和样式表目标，如果响应的 MIME 类型不适合该目标，浏览器会拒绝它。因此，一个把 JavaScript 当成纯文本交付的部署，可能在启用该响应头后停止工作。应修复实际交付的字节、类型和状态，不能只删除限制，直到现象消失。策略暴露了交付错误，并不说明策略本身就是错误的。

另一种常见问题，是脚本或样式路径实际返回了 HTML 错误页。正确策略可能让这个原本存在的路由错误更容易被发现。应检查经过重定向、缓存和路由之后真正收到的响应，包括状态与内容类型。只验证安全头是否存在，无法知道收到的是不是目标资源；首页请求成功，也不能证明错误响应和静态文件都遵循了各自的交付约定。

快速验证

保存代码为 nosniff.py，执行 python3 nosniff.py –serve。先打开打印出的地址并加上 ?mode=correct，再分别测试 ?mode=strict 和 ?mode=loose。此前记录使用 Python 3.14.4 与 Chrome 152；本轮没有重跑浏览器实验。临时回环服务在三种情况下返回完全相同的经典脚本字节，只改变内容类型及 nosniff 响应头。页面报告脚本是否执行、加载是否失败，结束后按控制键加 C 关闭服务。

import json
import sys
from http.server import BaseHTTPRequestHandler, HTTPServer
from threading import Event, Thread
from urllib.parse import parse_qs, urlsplit
from urllib.request import urlopen


class Handler(BaseHTTPRequestHandler):
 def log_message(self, *args):
 pass

 def do_GET(self):
 url = urlsplit(self.path)
 mode = parse_qs(url.query).get("mode", ["correct"])[0]
 assert mode in {"correct", "strict", "loose"}
 headers = {"Cache-Control": "no-store"}
 if url.path == "/payload.js":
 body = b"window.payloadExecuted = true;"
 headers["Content-Type"] = "application/javascript" if mode == "correct" else "text/plain"
 if mode != "loose":
 headers["X-Content-Type-Options"] = "nosniff"
 else:
 body = ("""<!doctype html><meta charset="utf-8"><title>MIME policy lab</title>
<h1>Script MIME policy</h1><pre id="result">Running...</pre><script>
const mode=""" + json.dumps(mode) + """;
const script=document.createElement('script');
script.src='/payload.js?mode='+mode;
function done(failed) {
 window.labResult={mode,executed:window.payloadExecuted===true,loadFailed:failed};
 document.getElementById('result').textContent=JSON.stringify(window.labResult,null,2);
}
script.onload=()=>done(false);script.onerror=()=>done(true);document.head.append(script);
</script>""").encode()
 headers["Content-Type"] = "text/html; charset=utf-8"
 self.send_response(200)
 self.send_header("Content-Length", str(len(body)))
 for key, value in headers.items():
 self.send_header(key, value)
 self.end_headers()
 self.wfile.write(body)


server = HTTPServer(("127.0.0.1", 0), Handler)
thread = Thread(target=server.serve_forever, daemon=True)
thread.start()
origin = f"http://127.0.0.1:{server.server_port}"
try:
 for mode in ("correct", "strict", "loose"):
 with urlopen(origin + "/payload.js?mode=" + mode, timeout=5) as response:
 assert response.read() == b"window.payloadExecuted = true;"
 assert response.headers["Content-Type"] == ("application/javascript" if mode == "correct" else "text/plain")
 assert response.headers.get("X-Content-Type-Options") == (None if mode == "loose" else "nosniff")
 print(json.dumps({"app_url": origin, "wire_mime_checks": "PASS"}), flush=True)
 if "--serve" in sys.argv:
 Event().wait()
except KeyboardInterrupt:
 pass
finally:
 server.shutdown()
 thread.join(timeout=5)
 server.server_close()

正确模式使用有效的 JavaScript MIME 类型并携带 nosniff，脚本应正常执行。严格模式把同样的字节标为纯文本，同时保留 nosniff，因此执行标志为假，加载错误标志为真。宽松模式去掉纯文本响应上的 nosniff，此前被测浏览器执行了该经典脚本。线上响应探针还分别检查了字节内容确实一致，以及相关响应字段按预期变化，避免把不同代码的执行结果误当成类型策略差异。

这组浏览器对照只验证一个具体的 MIME 边界，没有测试严格传输策略的持久化、所有资源类型、开启者隔离或其他浏览器，也不意味着任何环境中删除 nosniff 都能保证执行。对于实际站点，应把有针对性的拒绝案例与真实页面、资源的功能检查一起保留。核对最终服务层真正交付的响应头，并把每个预期字段值与它准备保留或禁止的浏览器行为对应起来，才能形成可解释、可复核的验证证据。

来源

MDN X-Content-Type-Options，针对脚本与样式目标的 MIME 类型检查，已核验 2026-09-13。
OWASP HTTP Headers Cheat Sheet，不同安全响应头的用途与部署取舍，已核验 2026-10-15。
MDN Strict-Transport-Security，通过 HTTPS 交付、主机范围与传输策略行为，已核验 2026-09-13。
WHATWG Fetch，脚本与样式目标的 nosniff 检查，已核验 2026-10-15。
W3C Content Security Policy，通过 meta 交付时忽略 frame-ancestors，已核验 2026-10-15。
RFC 6797，通过安全传输学习 HSTS 策略，已核验 2026-10-15。

CSP 明确浏览器中的执行规则

Thu, 10 Sep 2026 00:00:00 +0000

内容安全策略告诉支持它的浏览器，一个文档允许哪些动作。获取资源类指令分别控制脚本、样式、图片等类别，其他指令则负责不同边界。策略通常通过文档响应头提供，为浏览器行为增加约束，但不会修复注入漏洞、认证应用用户，也不会保证所有可能的脚本执行方式都已消失。应把它理解为具有具体作用范围的一层防护，而不是只要字段存在就获得完整安全保证。

缺失某个指令并不统一表示禁止。一些获取资源类指令会回退到默认来源指令，而嵌入父级、基础地址和表单目标等边界需要分别考虑。只包含脚本限制的策略，并不会自动完整限制图片加载、页面嵌入和表单提交。审阅时要逐项理解指令范围，尤其不能把默认来源写成全部拒绝后，就假定那些不继承该默认值的功能也被关闭。

为真正需要运行的脚本授权

随机数策略为经过明确选择的脚本元素附加不可预测的值，并在响应策略中声明同一个值。每次响应应生成新的随机数，只把它写到服务端确实准备授权的脚本上。如果自动给发现的每一个脚本元素都补上随机数，被注入的脚本也可能同时得到许可。构建时生成一次、以后持续复用的固定值，也失去了这种设计所依赖的逐响应不可预测性。

同一条来源指令中的表达式通常表示多个可选条件。把允许的主机与随机数写在一起，并不意味着脚本必须同时满足这两个条件。对于内容固定的静态页面，可以使用经过批准脚本的内容哈希，脚本精确内容发生变化时同步更新策略。需要根据页面怎样生成来选择方案；随意加入宽泛的内联执行许可，可能直接撤销原本希望通过随机数建立的限制。

坏掉的样子

开始强制执行后，合法的内联脚本、事件处理器、动态生成内容或此前没有注意到的依赖，都可能突然失效。仅报告模式能够在允许动作继续发生的同时观察违规，所以页面在该模式下正常运行，并不能证明强制策略也会允许它。报告还需要按含义解释：某条图片违规不能证明目标内联脚本被拦截，报告数量少也不能替代对关键页面功能的实际检查。

多份强制策略会共同生效。代理新增一份较宽松的响应头，并不会放宽已经存在的严格策略，因为动作必须满足每一份适用的强制策略。这可以解释为什么一个看起来正确的随机数仍然无法让脚本执行。应该检查最终交付的全部策略头和浏览器报告的有效指令，再修正真正需要的边界或合法资源用法，不能假定最后出现的字段自然覆盖此前所有限制。

快速验证

保存代码为 csp-nonce.py，执行 python3 csp-nonce.py –serve，在打印出的地址后加上 ?mode=enforce 并打开。本次检查使用 Python 3.14.4 和 Chrome 152。服务端为每份文档生成新的随机数，并故意让一个脚本没有该值。本机回环报告接收端只接收并丢弃正文，页面展示的证据来自浏览器违规事件。结束后按控制键加 C 关闭服务，不需要连接任何外部报告平台。

import base64
import json
import secrets
import sys
from http.server import BaseHTTPRequestHandler, HTTPServer
from threading import Event, Thread
from urllib.parse import parse_qs, urlsplit
from urllib.request import urlopen


class Handler(BaseHTTPRequestHandler):
 def log_message(self, *args):
 pass

 def do_POST(self):
 self.rfile.read(int(self.headers.get("Content-Length", "0")))
 self.send_response(204)
 self.send_header("Content-Length", "0")
 self.end_headers()

 def do_GET(self):
 mode = parse_qs(urlsplit(self.path).query).get("mode", ["enforce"])[0]
 assert mode in {"enforce", "report", "intersect"}
 nonce = base64.b64encode(secrets.token_bytes(18)).decode()
 policy = ("default-src 'none'; script-src 'nonce-" + nonce + "'; "
 "base-uri 'none'; object-src 'none'; report-uri /reports")
 body = ("""<!doctype html><meta charset="utf-8"><title>CSP nonce lab</title>
<h1>Nonce, report-only, and policy intersection</h1>
<pre id="result">If both scripts are blocked, this text stays unchanged.</pre>
<script nonce=""" + '"' + nonce + '"' + """>
window.allowed=true; window.violations=[];
document.addEventListener('securitypolicyviolation',event=>{
 window.violations.push({directive:event.effectiveDirective,disposition:event.disposition,blocked:event.blockedURI});
});
</script>
<script>window.unapproved=true;</script>
<script nonce=""" + '"' + nonce + '"' + """>
setTimeout(()=>{
 window.labResult={allowed:window.allowed===true,unapproved:window.unapproved===true,violations:window.violations};
 document.getElementById('result').textContent=JSON.stringify(window.labResult,null,2);
},100);
</script>""").encode()
 self.send_response(200)
 self.send_header("Content-Type", "text/html; charset=utf-8")
 self.send_header("Content-Length", str(len(body)))
 self.send_header("Cache-Control", "no-store")
 self.send_header("Content-Security-Policy-Report-Only" if mode == "report" else "Content-Security-Policy", policy)
 if mode == "intersect":
 self.send_header("Content-Security-Policy", "script-src 'none'")
 self.end_headers()
 self.wfile.write(body)


server = HTTPServer(("127.0.0.1", 0), Handler)
thread = Thread(target=server.serve_forever, daemon=True)
thread.start()
origin = f"http://127.0.0.1:{server.server_port}"
try:
 policies = []
 for mode in ("enforce", "enforce", "report", "intersect"):
 with urlopen(origin + "/?mode=" + mode, timeout=5) as response:
 key = "Content-Security-Policy-Report-Only" if mode == "report" else "Content-Security-Policy"
 values = response.headers.get_all(key)
 assert len(values) == (2 if mode == "intersect" else 1)
 assert "'nonce-" in values[0]
 policies.append(values[0])
 response.read()
 assert policies[0] != policies[1]
 print(json.dumps({"app_url": origin, "nonce_changes_per_response": True,
 "wire_policy_checks": "PASS"}), flush=True)
 if "--serve" in sys.argv:
 Event().wait()
except KeyboardInterrupt:
 pass
finally:
 server.shutdown()
 thread.join(timeout=5)
 server.server_close()

强制模式中，获准脚本应把 allowed 设为真，unapproved 则保持为假。相关违规事件的有效指令是 script-src-elem，被阻止的对象是内联脚本，处置方式是强制执行。将地址改为 ?mode=report 后，两个脚本标志都变为真，而违规处置方式变成报告。浏览器还可能记录其他资源违规，因此应按事件字段定位目标问题，不应把报告总数固定为一条，再据此误判执行结果。

最后打开 ?mode=intersect，第二份强制响应头会声明禁止脚本，三个脚本元素全部被阻止，包括带有正确随机数的脚本。页面说明文字保持不变，浏览器检查确认两个全局标志都不存在。Python 探针另外验证了随机数确实变化，以及响应中确实存在两个策略字段。本例为本地接收端使用较早的 report-uri 报告传输方式，没有实现生产报告服务；它证明的是这些文档中的授权、报告与策略交集行为，实际应用改变强制策略前仍需验证有代表性的页面功能。

来源

MDN Content Security Policy guide，随机数及哈希策略、指令作用范围与部署方式，已核验 2026-09-13。
MDN CSP script-src，脚本来源与内联脚本授权，已核验 2026-09-13。
W3C Content Security Policy Level 3，强制策略、报告策略及多策略交集，已核验 2026-09-13。

响应头 · XB 现场笔记

Content-Type 告诉读它的人这是什么

描述表示，而不是文件名

坏掉的样子

快速验证

延伸阅读

来源

HSTS 让浏览器记住 HTTPS

客户端记住的是主机名

坏掉的样子

快速验证

延伸阅读

来源

安全响应头需要可观察的浏览器行为

理解每个响应头负责的边界

坏掉的样子

快速验证

延伸阅读

来源

CSP 明确浏览器中的执行规则

为真正需要运行的脚本授权

坏掉的样子

快速验证

延伸阅读

来源