Go / 系统课时

传播认证身份

传播认证身份

认证中间件完成凭据校验后,后续处理器需要知道“谁在请求”以及“允许做什么”,但不应继续传递原始令牌。本节用 context.Context 写入最小身份对象,让处理器读取主体与权限,并统一 401、403 与敏感日志边界。

学习目标

  • 在认证成功后用私有类型的 context key 写入最小身份信息。
  • 区分认证失败的 401 与权限不足的 403,并让失败请求提前结束。
  • 避免在上下文和日志中传播 Bearer Token 等敏感凭据。

只传播后续真正需要的身份信息

HTTP 请求的 Context 与请求生命周期一致,适合保存请求范围内、跨中间件与处理器使用的数据。认证通过后通常只需要传播稳定主体标识和授权判断所需的权限集合,而不是用户名密码、完整 JWT、Cookie 或原始 Authorization 头。

context key 不应使用普通字符串,因为不同包可能碰撞。使用包内私有的自定义类型,可以把“谁能写入和读取这个身份值”限制在明确的 API 边界内。

认证身份从中间件传播到处理器

实现认证中间件与读取辅助函数

下面的程序用两个演示令牌模拟认证结果:good-token 拥有读取权限,no-read-token 只有身份但没有目标权限。真实项目应把 authenticateToken 替换为 JWT 校验、Session 查询或外部身份服务,并保持后续传播的数据结构不变。

go
package main

import (
	"context"
	"encoding/json"
	"fmt"
	"net/http"
	"net/http/httptest"
	"strings"
)

type Identity struct {
	Subject     string
	Permissions map[string]bool
}

type identityKey struct{}

func withIdentity(r *http.Request, id Identity) *http.Request {
	ctx := context.WithValue(r.Context(), identityKey{}, id)
	return r.WithContext(ctx)
}

func currentIdentity(r *http.Request) (Identity, bool) {
	id, ok := r.Context().Value(identityKey{}).(Identity)
	return id, ok
}

func authenticateToken(token string) (Identity, bool) {
	switch token {
	case "good-token":
		return Identity{
			Subject:     "user-123",
			Permissions: map[string]bool{"profile:read": true},
		}, true
	case "no-read-token":
		return Identity{
			Subject:     "user-456",
			Permissions: map[string]bool{},
		}, true
	default:
		return Identity{}, false
	}
}

func writeError(w http.ResponseWriter, status int, code string) {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(status)
	_ = json.NewEncoder(w).Encode(map[string]string{"error": code})
}

func authMiddleware(next http.Handler) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		const prefix = "Bearer "
		raw := r.Header.Get("Authorization")
		if !strings.HasPrefix(raw, prefix) {
			w.Header().Set("WWW-Authenticate", "Bearer")
			writeError(w, http.StatusUnauthorized, "unauthorized")
			return
		}

		id, ok := authenticateToken(strings.TrimPrefix(raw, prefix))
		if !ok {
			w.Header().Set("WWW-Authenticate", "Bearer")
			writeError(w, http.StatusUnauthorized, "unauthorized")
			return
		}

		next.ServeHTTP(w, withIdentity(r, id))
	})
}

func profileHandler(w http.ResponseWriter, r *http.Request) {
	id, ok := currentIdentity(r)
	if !ok {
		writeError(w, http.StatusInternalServerError, "identity_missing")
		return
	}
	if !id.Permissions["profile:read"] {
		writeError(w, http.StatusForbidden, "forbidden")
		return
	}

	w.Header().Set("Content-Type", "application/json")
	_ = json.NewEncoder(w).Encode(map[string]string{"subject": id.Subject})
}

func exercise(label, token string, h http.Handler) {
	req := httptest.NewRequest(http.MethodGet, "/profile", nil)
	req.Header.Set("Authorization", "Bearer "+token)
	rec := httptest.NewRecorder()
	h.ServeHTTP(rec, req)
	fmt.Printf("%s: %d %s\n", label, rec.Code, strings.TrimSpace(rec.Body.String()))
}

func main() {
	handler := authMiddleware(http.HandlerFunc(profileHandler))
	exercise("authorized", "good-token", handler)
	exercise("forbidden", "no-read-token", handler)
	exercise("unauthorized", "bad-token", handler)
}

预期输出

text
authorized: 200 {"subject":"user-123"}
forbidden: 403 {"error":"forbidden"}
unauthorized: 401 {"error":"unauthorized"}

这里的 401 发生在“无法建立可信身份”时;403 则表示身份已经建立,但主体缺少 profile:read。把两者分开,既方便客户端决定是否重新认证,也能避免把权限问题误报成登录失效。

保持上下文与日志的敏感信息边界

上下文中的身份对象应尽量小,并把它当作请求期只读数据使用。若权限集合很大,可以传播角色、策略版本或授权句柄,再让专门的授权组件完成判断;不要把整个用户数据库记录塞进 Context。

认证失败时,响应只给稳定的错误码,不回显“签名错误”“用户不存在”“令牌过期多久”等内部细节。服务端可以记录足够的诊断信息,但日志中不要记录完整 Bearer Token、Session Cookie、密码或可直接重放的凭据。

让身份只在当前请求内生效

r.WithContext 返回一个携带新 Context 的请求副本,不会修改全局状态,因此多个并发请求之间不会共享身份。请求结束或客户端取消后,后续调用还可以通过同一个 Context 感知取消信号。

如果把身份复制到全局变量、包级缓存或可变单例中,就会破坏这种隔离并产生并发串号风险。把认证结果限制在当前请求 Context 内,并只传播最小主体与权限信息,后续处理链就能在清晰边界内完成认证、授权与审计。

按自己的节奏,确认真正理解。

目录与阅读设置

阅读设置

17

记录一个想法

传播认证身份

0 / 10000 · 笔记保存到账号。未提交的修改会在关闭、离开或刷新后丢失。

登录哪都通