Day 01 我们建了一个能跑的 Session 系统, 但当时没讲它的生命周期管理。 "什么时候发新 SID、什么时候失效、什么时候要换"—— 这些时机一旦做错, 会出现一个经典攻击: Session Fixation。 理解它的攻击链, 你就懂了为什么"登录后必须 regenerate session id"是写在所有安全清单第一条的铁律。

Session Fixation 攻击

Session 完整生命周期

Go 实战: 登录后 regenerate SID

// 用 alexedwards/scs · 沿用 Day 01 的设置
func login(w http.ResponseWriter, r *http.Request) {
    user, ok := verifyCredentials(r)
    if !ok {
        http.Error(w, "bad credentials", 401); return
    }

    if err := sm.RenewToken(r.Context()); err != nil {      // 关键一行
        http.Error(w, "renew failed", 500); return
    }

    sm.Put(r.Context(), "uid", user.ID)
    sm.Put(r.Context(), "login_at", time.Now().Unix())
    w.Write([]byte("ok"))
}

func logout(w http.ResponseWriter, r *http.Request) {
    // 服务端 Store 删 + 客户端 Cookie 过期
    _ = sm.Destroy(r.Context())
    w.Write([]byte("bye"))
}

CSRF 把"浏览器自动带 Cookie"这件设计原本是好事的特性,变成攻击面—— 只要受害者还登录着 your-bank.com, 攻击者在 evil.com 放一段 <img src="your-bank.com/transfer?to=attacker">, 浏览器就会自动带上 your-bank 的 Cookie 去发起请求。 防御不靠"加密 Cookie", 靠让伪造者无法构造完整请求。

CSRF 攻击流程

四种防御方案

Go 实战: gorilla/csrf 中间件

// go get github.com/gorilla/csrf
package main

import (
    "net/http"

    "github.com/gorilla/csrf"
)

func main() {
    mux := http.NewServeMux()
    mux.HandleFunc("/transfer", transferHandler)

    // CSRF 中间件包一层
    csrfMW := csrf.Protect(
        []byte("32-byte-long-auth-key-from-env!!"),
        csrf.Secure(true),                  // 生产必开
        csrf.HttpOnly(true),
        csrf.SameSite(csrf.SameSiteLaxMode),
        csrf.Path("/"),
    )

    _ = http.ListenAndServe(":8080", csrfMW(mux))
}

func transferHandler(w http.ResponseWriter, r *http.Request) {
    if r.Method == "GET" {
        // 把 token 塞进 form, 用户提交时浏览器会带回来
        token := csrf.Token(r)
        fmt.Fprintf(w, `<form method="POST">
            <input type="hidden" name="gorilla.csrf.Token" value="%s">
            <input name="to"> <input name="amt">
            <button>Transfer</button></form>`, token)
        return
    }
    // POST 走到这里, token 已经被中间件校验过
    w.Write([]byte("transfer ok"))
}

// SPA 场景 · Double Submit Cookie · 自己实现
func csrfMiddleware(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        // 写操作才校验
        if r.Method == "GET" || r.Method == "HEAD" {
            ensureCSRFCookie(w, r)
            next.ServeHTTP(w, r); return
        }

        // 取 Cookie 与 Header, 常量时间比较
        c, err := r.Cookie("csrf_token")
        h := r.Header.Get("X-CSRF-Token")
        if err != nil || h == "" ||
           subtle.ConstantTimeCompare([]byte(c.Value), []byte(h)) != 1 {
            http.Error(w, "csrf invalid", 403); return
        }

        // 兜底: Origin 校验
        origin := r.Header.Get("Origin")
        if origin != "" && origin != "https://app.example.com" {
            http.Error(w, "bad origin", 403); return
        }

        next.ServeHTTP(w, r)
    })
}

XSS 的本质是把数据当成代码执行—— 用户输入的字符串没有被正确转义就放进了 HTML, 浏览器把它当作 <script> 标签解析, 攻击者的代码因此在受害者的浏览器上下文中运行。 一旦得手, 攻击者能干HttpOnly 都防不住的事: 偷 token、操作 DOM、伪造点击、键盘记录, 因为他的脚本就在受害者的页面里——已经"成了"受害者本人。

三种 XSS 类型

防御层级

1. 输出编码 (第一道闸门)。 任何用户数据写进 HTML / JS / URL / CSS 时, 必须做对应上下文的转义。Go 用 html/template 自动转义, 不要用 text/template 输出 HTML。
2. 输入验证 (兜底)。 上传 / 注册的字段做白名单校验——比如手机号只允许数字, 用户名限制字符集。不要试图"黑名单过滤 <script>"——绕过方式太多。
3. CSP (现代护城河)。 Content Security Policy 在响应头里告诉浏览器"只允许从 https://example.com 加载脚本", 即使 XSS 注入了 <script>, 也被浏览器拒绝执行。
4. Cookie HttpOnly (止损)。 Day 01 强调过, 加这个属性 JS 偷不到 Cookie——XSS 即使得手, 至少 Session ID 拿不走。

Go html/template 自动转义

// Go 的 html/template 默认就是安全的, 关键是不要绕过它
package main

import (
    "html/template"
    "net/http"
)

var tpl = template.Must(template.New("x").Parse(`
<h1>Hello, {{.Name}}</h1>
<p>Your bio: {{.Bio}}</p>
<a href="/profile?id={{.ID}}">Edit</a>
<script>var user = {{.JSData}};</script>
`))

func handler(w http.ResponseWriter, r *http.Request) {
    // 即使用户名是 <script>alert(1)</script>
    // html/template 会按上下文自动转义:
    //   - 在 HTML body  → &lt;script&gt;
    //   - 在 href 属性  → URL 编码
    //   - 在 <script> 内 → JSON 安全的字符串字面量
    _ = tpl.Execute(w, map[string]any{
        "Name":   r.URL.Query().Get("name"),
        "Bio":    r.URL.Query().Get("bio"),
        "ID":     r.URL.Query().Get("id"),
        "JSData": map[string]string{"name": "alice"},
    })
}

CSP 入门

# 最严格的 CSP — 只允许同源 + 显式列出的资源
Content-Security-Policy:
  default-src 'self';
  script-src 'self' 'nonce-{随机值}';
  style-src 'self' 'unsafe-inline';
  img-src 'self' data: https:;
  connect-src 'self' https://api.example.com;
  font-src 'self' https://fonts.gstatic.com;
  frame-ancestors 'none';
  base-uri 'self';
  form-action 'self';
  upgrade-insecure-requests;
  report-uri /csp-report

# 把 nonce 塞进 <script>: 只有带正确 nonce 的脚本能跑
# <script nonce="rA8s..."> ... </script>
# 注入的 <script> 没有 nonce → 浏览器拒绝执行

把前三节的所有点合并成一个 Go 中间件—— 安全 Cookie / CSRF / CSP / 浏览器加固头, 一次写好, 全站受益。 这一节也是 30 天里第一次给出"可以直接 copy 到生产"的样板代码。

必备的安全响应头

Go 综合安全中间件

// security.go · 一个 middleware 把所有头打齐
package middleware

import (
    "crypto/rand"
    "encoding/base64"
    "fmt"
    "net/http"
)

func SecurityHeaders(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        // 1) 每请求生成一个 CSP nonce, 放进 context 供模板使用
        b := make([]byte, 16)
        _, _ = rand.Read(b)
        nonce := base64.RawStdEncoding.EncodeToString(b)
        ctx := context.WithValue(r.Context(), "csp_nonce", nonce)

        h := w.Header()
        h.Set("Strict-Transport-Security", "max-age=31536000; includeSubDomains; preload")
        h.Set("Content-Security-Policy", fmt.Sprintf(
            "default-src 'self'; script-src 'self' 'nonce-%s'; " +
            "style-src 'self' 'unsafe-inline'; " +
            "img-src 'self' data: https:; " +
            "frame-ancestors 'none'; base-uri 'self'; form-action 'self'", nonce))
        h.Set("X-Frame-Options", "DENY")
        h.Set("X-Content-Type-Options", "nosniff")
        h.Set("Referrer-Policy", "strict-origin-when-cross-origin")
        h.Set("Permissions-Policy", "camera=(), microphone=(), geolocation=()")
        h.Set("Cross-Origin-Opener-Policy", "same-origin")

        next.ServeHTTP(w, r.WithContext(ctx))
    })
}

// 安全 Cookie helper · 一次写好不再思考
func SecureCookie(name, value string, maxAge int) *http.Cookie {
    return &http.Cookie{
        Name:     name,
        Value:    value,
        Path:     "/",
        MaxAge:   maxAge,
        HttpOnly: true,                  // 防 XSS 偷 Cookie
        Secure:   true,                  // 仅 HTTPS
        SameSite: http.SameSiteLaxMode,  // 防 CSRF
    }
}

// main.go · 串起来用
func main() {
    mux := http.NewServeMux()
    mux.HandleFunc("/login", login)
    mux.HandleFunc("/me", me)

    // 中间件栈: 安全头 → CSRF → Session → 业务
    handler := middleware.SecurityHeaders(
        csrf.Protect(secret, csrf.Secure(true))(
            sm.LoadAndSave(mux),
        ),
    )

    _ = http.ListenAndServeTLS(":443", "server.crt", "server.key", handler)
}

1. 用 60 秒讲清 Session Fixation 完整攻击链——攻击者预先做了什么 / 受害者做了什么 / 服务端漏了什么。
2. 列出 CSRF 的四种防御方案及它们的相对优缺点。2024 年的实战推荐组合是什么?
3. 区分 Stored / Reflected / DOM-based XSS——攻击位置、触发位置、传播范围各有什么不同?
4. 写一段 Go 代码: 实现一个安全的 Cookie helper, 接收 name/value/maxAge, 返回带全部安全属性的 *http.Cookie。
5. CSP 的 nonce 机制怎么工作? 为什么 'unsafe-inline' 几乎等于关闭了 CSP?