This resume is also available in English.

八、安全與 AI 協作第 1 / 7 篇 · 全部目錄

專欄 › 八、安全與 AI 協作 › 第 31 篇

微服務的安全性:認證、授權、密鑰與供應鏈

Microservice Security: Authentication, Authorisation, Secrets and Supply Chain

從訂單系統的威脅模型出發:在 gateway 驗證 JWT 並把身分傳給後端、每個服務自己做物件層級授權防 BOLA、服務之間用 mTLS、密鑰不進程式碼與日誌,最後用 govulncheck、SBOM 與簽章守住供應鏈。

  • Security
  • Microservices
  • Go
  • OWASP
這篇的步驟
  1. 這篇要解決什麼
  2. 第 1 步:先畫出威脅模型,再決定要防什麼
  3. 第 2 步:認證集中在 gateway——驗證 JWT 的每一個欄位
  4. 第 3 步:把身分傳給後端,而且不能被偽造
  5. 第 4 步:授權在每個服務裡做——擋住 BOLA
  6. 第 5 步:服務之間用 mTLS 互相確認身分,並守住最小權限
  7. 第 6 步:密鑰不進程式碼、映像檔與日誌,而且要能輪替
  8. 第 7 步:輸入驗證、參數化查詢、限流與安全標頭
  9. 第 8 步:守住供應鏈——相依套件、映像檔與建置流程
  10. 第 9 步:整理成一張檢查表,對照前面的文章
  11. 常見陷阱
  12. 重點整理
  13. 下一篇

上一篇〈Go 處理金額:整數分、decimal、幣別、四捨五入與分攤〉把「算對錢」這件事做扎實了;但算得再準,只要有人能看到別人的訂單、改掉別人的金額,或拿走付款服務的金鑰,前面的努力就全部白費。這篇進入第八部分,先把整個訂單系統從安全的角度重新走一遍。

這篇要解決什麼

前面二十幾篇,我們把訂單系統拆成 api-gateway、order、payment、inventory 四個服務,用 gRPC 與訊息佇列串起來,部署進 Kubernetes 的 shop 命名空間。功能都能動了,但每拆出一個服務,就多出一組網路連線、一份設定、一把資料庫密碼與一個映像檔,也就多出好幾個可以被攻擊的地方。單體應用裡「同一個行程內呼叫函式」天然是可信的,到了微服務,每一次呼叫都跨過網路,信任不再是理所當然。

這篇要回答的是一連串很具體的問題:

  • 誰可能攻擊這套系統、從哪裡進來、想拿到什麼?也就是先畫出威脅模型。
  • 認證(authentication,你是誰)要在哪裡做?gateway 驗證 JWT 時,到底要檢查哪些欄位?
  • 驗證完的身分怎麼安全地傳給後端服務,而不讓用戶端自己偽造?
  • 授權(authorisation,你能做什麼)為什麼不能只在 gateway 做?OWASP API Security Top 10(2023)排名第一的 BOLA 長什麼樣子、在 Go 裡怎麼擋?
  • 服務之間要怎麼互相確認身分?mTLS 在 Go 的 crypto/tls 裡怎麼設定?
  • 資料庫密碼、金流 API 金鑰這些密鑰要放在哪裡、怎麼輪替?
  • 輸入驗證、SQL 注入、請求大小、限流、CORS、安全標頭,各自擋的是什麼?
  • 日誌要怎麼寫才不會把 token 或個資一起寫進去?
  • 程式碼本身與相依套件、映像檔的供應鏈怎麼守?

安全不是一個功能,而是一組分散在每一層的習慣。這篇的做法是:每一步都對應到前面某一篇已經寫過的程式,指出要在哪裡加什麼,最後整理成一張對照前面文章的檢查表。

第 1 步:先畫出威脅模型,再決定要防什麼

沒有威脅模型的安全工作,常常變成「把網路上看到的建議全部加一遍」,結果真正重要的地方沒做,次要的地方反而做得很仔細。威脅模型不必很正式,回答四個問題就夠了:我們在保護什麼?誰會來攻擊?他們從哪裡進來?擋不住時損失多大?

以訂單系統來說,要保護的資產大致是:

資產例子被拿到或被改掉的後果
使用者個資姓名、Email、地址、電話外洩、法規責任
訂單資料誰買了什麼、金額、狀態看到別人訂單、竄改狀態(未付款變成已付款)
付款能力金流 API 金鑰、退款權限被盜刷、被惡意退款
庫存預留與釋放被惡意佔滿庫存、超賣
系統本身資料庫、叢集、CI整個系統被接管

攻擊者大致有三種:外部的匿名使用者(只能碰到公開的 API)、已登入但不懷好意的使用者(有合法 token,想看別人的東西或拿到不該有的權限)、以及已經突破某一層的人(例如拿到某個容器的 shell,或在相依套件裡藏了惡意程式碼)。第二種最容易被忽略,因為「有登入」常被誤以為「可信」。

接著畫出信任邊界:資料每跨過一條邊界,就要重新問「你是誰、你能不能做這件事」。

瀏覽器/App 完全不可信 邊界 1:網際網路 api-gateway 驗 token、限流 清掉偽造標頭 邊界 2:叢集(mTLS) order inventory payment 邊界 3:資料與外部 PostgreSQL 每服務一個帳號 NATS 主題權限 外部金流 回呼要驗簽 每跨過一條線,都要重新問: 你是誰?你能做這件事嗎?

圖:網際網路到 gateway 是第一條邊界,gateway 到叢集內服務是第二條,服務到資料庫、訊息佇列與外部金流是第三條;每條線都要有自己的檢查。

有了這張圖,就可以用 STRIDE 這類分類(偽冒、竄改、否認、資訊洩漏、阻斷服務、權限提升)逐條檢查每個箭頭。例如「gateway → order」這條線:有沒有可能有人繞過 gateway 直接打 order(偽冒)?傳遞身分的標頭能不能被用戶端偽造(偽冒、權限提升)?連線有沒有加密(資訊洩漏)?這篇後面的每一步,都是在回答這些問題。

提示:威脅模型放在 repo 的 docs/ 裡,跟程式碼一起審查。每次新增服務、新增對外 API 或新增外部相依時,回頭更新這張圖,比一次寫得很完整更重要。

第 2 步:認證集中在 gateway——驗證 JWT 的每一個欄位

在〈API Gateway:路由、認證、限流〉裡,我們讓 gateway 當唯一入口,在那裡做認證。這一步把 JWT 驗證的細節補齊。實務上,使用者通常是透過 OIDC(OpenID Connect)向身分提供者(Identity Provider,例如自建的 Keycloak 或雲端的身分服務)登入,拿到一個簽過名的 JWT access token,之後每次呼叫 API 都放在 Authorization: Bearer ... 標頭裡。

gateway 收到 token 之後,全部要檢查的項目如下,少一項就是一個洞:

檢查為什麼
簽章確認 token 是身分提供者簽的、沒被改過。公鑰來自 JWKS,依 header 的 kid 選鑰
演算法只接受預期的演算法(例如 RS256 或 ES256);絕不接受 none,也不能讓 token 自己決定用 HMAC 驗非對稱金鑰
iss(issuer)必須等於你信任的身分提供者網址,避免別的提供者簽的 token 被拿來用
aud(audience)必須包含這套 API 的識別;否則別的應用程式拿到的 token 也能打你的 API
exp、nbf過期或還沒生效就拒絕;允許幾十秒以內的時鐘誤差
必要的 claim例如 sub(使用者 ID)不能是空的

金鑰輪替靠的是 JWKS(JSON Web Key Set):身分提供者在一個公開網址(OIDC discovery 文件的 jwks_uri)提供目前有效的公鑰清單,每把鑰匙有自己的 kid。輪替時,提供者先把新鑰匙加進清單、一段時間後開始用新鑰匙簽名、再過一段時間才移除舊鑰匙。gateway 這邊要做的是:快取 JWKS、遇到不認識的 kid 時重新抓一次(加上頻率限制,避免攻擊者用亂填的 kid 讓你一直去打身分提供者)。

JWT 驗證不建議自己寫。下面用 github.com/coreos/go-oidc/v3 示範,它會自己處理 discovery、JWKS 快取與輪替、簽章、iss、aud 與 exp:

// 片段:需要 github.com/coreos/go-oidc/v3/oidc
package auth

import (
	"context"
	"net/http"
	"strings"

	"github.com/coreos/go-oidc/v3/oidc"
)

type Claims struct {
	Subject string   `json:"sub"`
	Roles   []string `json:"roles"`
}

func NewVerifier(ctx context.Context, issuer, audience string) (*oidc.IDTokenVerifier, error) {
	provider, err := oidc.NewProvider(ctx, issuer) // 讀 discovery 文件,取得 jwks_uri
	if err != nil {
		return nil, err
	}
	return provider.Verifier(&oidc.Config{
		ClientID:             audience,             // 檢查 aud
		SupportedSigningAlgs: []string{oidc.RS256}, // 只接受預期的演算法
	}), nil
}

// Authenticate 是 gateway 的中介層:驗 token,刪掉外來的身分標頭,再加上驗證過的身分。
func Authenticate(v *oidc.IDTokenVerifier, next http.Handler) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		r.Header.Del("X-User-ID") // 用戶端自己送來的一律不算數
		r.Header.Del("X-User-Roles")

		raw, ok := strings.CutPrefix(r.Header.Get("Authorization"), "Bearer ")
		if !ok {
			http.Error(w, "unauthenticated", http.StatusUnauthorized)
			return
		}
		tok, err := v.Verify(r.Context(), raw) // 簽章、iss、aud、exp
		if err != nil {
			http.Error(w, "unauthenticated", http.StatusUnauthorized)
			return
		}
		var c Claims
		if err := tok.Claims(&c); err != nil || c.Subject == "" {
			http.Error(w, "unauthenticated", http.StatusUnauthorized)
			return
		}
		r.Header.Set("X-User-ID", c.Subject)
		r.Header.Set("X-User-Roles", strings.Join(c.Roles, ","))
		r.Header.Del("Authorization") // 後端不需要原始 token,就不要往後傳
		next.ServeHTTP(w, r)
	})
}

這個套件名稱裡的 IDTokenVerifier 原本是給 OIDC 的 ID token 用的,但它驗的就是一般 JWT 的簽章與標準欄位;如果你的 access token 是 JWT、aud 設成 API 的識別,用法相同。如果身分提供者發的是不透明(opaque)token,就改用 token introspection 端點查詢,原則一樣:驗證在 gateway 做一次,後端拿到的是驗證過的結果。

三個容易漏掉的細節:第一,回應的錯誤訊息一律是簡短的 401,不要回「簽章錯誤」「已過期」這種細節,讓攻擊者少一點線索(細節寫進日誌即可)。第二,r.Header.Del 那兩行非常關鍵,下一步會說明。第三,登出與撤銷:JWT 在過期前本身一直有效,所以 access token 的效期要短(幾分鐘到十幾分鐘),再搭配 refresh token;真的需要即時撤銷時,才在 gateway 加一份撤銷清單。

第 3 步:把身分傳給後端,而且不能被偽造

gateway 驗證完 token 之後,後端服務需要知道「這個請求是誰發的」。常見做法有兩種:

做法優點要注意
gateway 加上 X-User-ID 等標頭簡單,後端不用懂 JWT後端只能接受來自 gateway 的連線;gateway 必須先刪掉用戶端送來的同名標頭
原封不動轉送 JWT,後端再驗一次後端不必信任網路位置每個服務都要設定 JWKS;token 傳得越遠,外洩面越大
gateway 換發一個內部短效 token後端可以驗證來源,權限可以縮小多一個簽發元件要維護

這個系列採用第一種,並用兩件事把它的前提守住:gateway 一定先刪掉外來的 X-User-* 標頭(上一步的程式碼),以及後端只接受 gateway 的連線——在 Kubernetes 裡用 NetworkPolicy 限制來源(見〈在 Kubernetes 部署整套微服務〉),再用第 5 步的 mTLS 確認對方的憑證確實是 gateway。只做到其中一件都不夠:沒有刪標頭,用戶端自己帶 X-User-ID: admin 就變成管理員;沒有限制來源,叢集裡任何一個被攻破的容器都能冒充任何使用者。

身分提供者 用戶端 ① 登入取得 JWT ② Bearer api-gateway 簽章(依 kid 找公鑰) iss、aud、exp、nbf 刪掉外來 X-User-* 加上已驗證的身分 ③ 定期抓 JWKS(快取) ④ mTLS order 服務 讀出 UserID 查訂單 ⑤ 比對擁有者 不符回 404 認證在入口做一次,授權在每個服務做

圖:認證在入口做一次;gateway 把驗證過的身分交給後端,但「這筆訂單是不是你的」要由 order 服務自己判斷。

在 gRPC 的情境下,身分放在 metadata 裡,由 gateway 的用戶端攔截器(interceptor)加上、後端的伺服器攔截器讀出並放進 context,概念與 HTTP 標頭完全相同(見〈gRPC 與 Protocol Buffers〉)。透過訊息佇列傳遞的事件則不同:事件是「系統內部發生的事實」,例如 OrderCreated 裡記錄的 UserID 是訂單資料的一部分,消費者不應該把它當成「現在發出請求的人」,也不該依它做權限決定。

第 4 步:授權在每個服務裡做——擋住 BOLA

OWASP API Security Top 10(2023 版)的第一名是 API1:2023 Broken Object Level Authorization(BOLA):API 用路徑或參數裡的 ID 找資料,卻沒有確認這筆資料屬於呼叫者。最典型的例子就是 GET /orders/{id}:已登入的 alice 把網址裡的 o-1 改成 o-2,就看到了 bob 的訂單。它排第一不是因為技術難,而是因為太容易漏:gateway 只知道「這個人登入了」,不知道 o-2 是誰的;這個判斷只有擁有資料的服務做得到。

順便列出 2023 版的十項,後面幾步會對應到其中幾項:

編號名稱這套系統裡的例子
API1Broken Object Level Authorization改 ID 看別人的訂單
API2Broken AuthenticationJWT 沒驗 aud、接受 none 演算法
API3Broken Object Property Level Authorization用戶端送 "status":"paid" 就被寫進資料庫;回應多帶了內部欄位
API4Unrestricted Resource Consumption沒有請求大小上限、沒有限流、一次能查一萬筆
API5Broken Function Level Authorization一般使用者能呼叫退款這類管理功能
API6Unrestricted Access to Sensitive Business Flows機器人大量下單佔住庫存
API7Server Side Request Forgery服務依使用者給的網址發請求(例如自訂回呼網址)
API8Security MisconfigurationCORS 全開、錯誤訊息帶堆疊、缺安全標頭
API9Improper Inventory Management舊版 API、測試端點還在線上沒人管
API10Unsafe Consumption of APIs直接相信外部金流回傳的資料,沒有驗簽與驗證

授權模型常見的有 RBAC(以角色為主:support 角色可以看所有訂單)與 ABAC(以屬性為主:訂單的 UserID 等於呼叫者、或訂單所屬商店等於呼叫者管理的商店)。實務上兩者常常一起用:RBAC 決定「能不能呼叫這個功能」(擋 API5),ABAC 式的擁有者檢查決定「能不能碰這筆資料」(擋 API1)。

授權檢查放在服務層(service),而不是 handler 或 repository,理由是:handler 可能有好幾個(HTTP、gRPC、內部批次),都會走到同一個服務方法;repository 只管存取資料,不該知道「呼叫者是誰」。下面是一個完整、可以直接執行的例子,延續〈分層架構與依賴注入〉的結構,用 httptest 跑四種情況:

// cmd/order:身分從 gateway 傳進來,物件層級授權在服務裡檢查。
package main

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

type Status string

const (
	StatusPending   Status = "pending"
	StatusPaid      Status = "paid"
	StatusCancelled Status = "cancelled"
)

type Order struct {
	ID     string `json:"id"`
	UserID string `json:"user_id"`
	Total  int64  `json:"total"` // 以「分」為單位
	Status Status `json:"status"`
}

// Identity 是 gateway 驗證過 token 之後交給後端的身分。
type Identity struct {
	UserID string
	Roles  []string
}

func (id Identity) Has(role string) bool {
	for _, r := range id.Roles {
		if r == role {
			return true
		}
	}
	return false
}

type ctxKey struct{}

func identityFrom(ctx context.Context) (Identity, bool) {
	id, ok := ctx.Value(ctxKey{}).(Identity)
	return id, ok && id.UserID != ""
}

// withIdentity 讀 gateway 加上的標頭。前提:服務只接受來自 gateway(mTLS)的連線,
// 而且 gateway 會先刪掉用戶端自己送來的同名標頭。
func withIdentity(next http.Handler) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		uid := r.Header.Get("X-User-ID")
		if uid == "" {
			http.Error(w, "unauthenticated", http.StatusUnauthorized)
			return
		}
		var roles []string
		if v := r.Header.Get("X-User-Roles"); v != "" {
			roles = strings.Split(v, ",")
		}
		ctx := context.WithValue(r.Context(), ctxKey{}, Identity{UserID: uid, Roles: roles})
		next.ServeHTTP(w, r.WithContext(ctx))
	})
}

var ErrNotFound = errors.New("order not found")

type Repository interface {
	Get(ctx context.Context, id string) (Order, error)
}

type memRepo map[string]Order

func (m memRepo) Get(_ context.Context, id string) (Order, error) {
	o, ok := m[id]
	if !ok {
		return Order{}, ErrNotFound
	}
	return o, nil
}

type Service struct{ repo Repository }

// GetForUser 是 BOLA 的防線:查到訂單之後,確認它屬於呼叫者。
// 不屬於時回傳 ErrNotFound,不讓攻擊者分辨「不存在」與「不是你的」。
func (s *Service) GetForUser(ctx context.Context, id string) (Order, error) {
	who, ok := identityFrom(ctx)
	if !ok {
		return Order{}, ErrNotFound
	}
	o, err := s.repo.Get(ctx, id)
	if err != nil {
		return Order{}, err
	}
	if o.UserID != who.UserID && !who.Has("support") {
		slog.WarnContext(ctx, "order access denied", "order_id", id, "user_id", who.UserID)
		return Order{}, ErrNotFound
	}
	return o, nil
}

func (s *Service) handleGet(w http.ResponseWriter, r *http.Request) {
	o, err := s.GetForUser(r.Context(), r.PathValue("id"))
	if errors.Is(err, ErrNotFound) {
		http.Error(w, "not found", http.StatusNotFound)
		return
	}
	if err != nil {
		http.Error(w, "internal error", http.StatusInternalServerError)
		return
	}
	w.Header().Set("Content-Type", "application/json")
	json.NewEncoder(w).Encode(o)
}

func main() {
	svc := &Service{repo: memRepo{
		"o-1": {ID: "o-1", UserID: "alice", Total: 129900, Status: StatusPaid},
		"o-2": {ID: "o-2", UserID: "bob", Total: 4500, Status: StatusPending},
	}}
	mux := http.NewServeMux()
	mux.HandleFunc("GET /orders/{id}", svc.handleGet)
	h := withIdentity(mux)

	for _, tc := range []struct{ user, roles, id string }{
		{"alice", "", "o-1"},        // 自己的訂單:200
		{"alice", "", "o-2"},        // 別人的訂單:404
		{"carol", "support", "o-2"}, // 客服角色:200
		{"", "", "o-1"},             // 沒有身分:401
	} {
		req := httptest.NewRequest(http.MethodGet, "/orders/"+tc.id, nil)
		if tc.user != "" {
			req.Header.Set("X-User-ID", tc.user)
		}
		if tc.roles != "" {
			req.Header.Set("X-User-Roles", tc.roles)
		}
		rec := httptest.NewRecorder()
		h.ServeHTTP(rec, req)
		fmt.Printf("user=%-6q order=%s -> %d\n", tc.user, tc.id, rec.Code)
	}
}

執行結果是 200、404、200、401。幾個設計決定值得說明:

  • 不屬於你時回 404,不回 403。 回 403 等於告訴攻擊者「這個 ID 存在」,他就能列舉出有效的訂單 ID。404 讓「不存在」與「不是你的」看起來一樣。
  • 拒絕時寫一筆警告日誌。 正常使用者幾乎不會碰到這條路徑,短時間內大量出現就是有人在掃 ID,這可以接到〈可觀測性:日誌、指標、追蹤〉的告警。
  • 列表查詢要把條件放進 SQL。 ListOrders 不要先查全部再在 Go 裡過濾,而是 WHERE user_id = $1;否則分頁、計數都會洩漏別人的資料筆數。
  • ID 改成難猜的值(例如 UUID)有幫助,但不能取代檢查。 ID 會出現在網址、日誌、分享連結裡,遲早會被看到。

寫入也是一樣。取消訂單、修改地址這類操作,在服務方法開頭就確認擁有者與狀態,並把「檢查擁有者」寫進表格驅動測試(見〈測試:表格驅動、httptest、整合測試〉),讓每一個會碰到訂單的方法都有一列「別人的訂單」測試案例。這種測試很便宜,卻是防止 BOLA 回歸最有效的方法。

第 5 步:服務之間用 mTLS 互相確認身分,並守住最小權限

gateway 到 order、order 到 inventory 這些內部呼叫,也要回答「你是誰」。一般 TLS 只讓用戶端確認伺服器的身分;mTLS(mutual TLS)則讓雙方都出示憑證,伺服器也能確認呼叫者是哪個服務。它同時解決兩件事:連線加密(叢集內的流量也可能被同一台節點上的其他程式看到),以及服務身分(只有 gateway 能呼叫 order 的公開 API、只有 order 能呼叫 inventory 的預留 API)。

叢集內 CA 簽發短效憑證 order(用戶端) Certificates:自己的憑證 RootCAs:叢集 CA inventory(伺服器) ClientAuth:必須驗證 ClientCAs:叢集 CA ① 驗伺服器憑證 ② 伺服器要求用戶端憑證 ③ VerifyConnection 憑證上的名稱在允許清單上? 不在就中斷連線 驗證鏈:證明「你是叢集裡的某個服務」 檢查名稱:決定「你可以呼叫我」

圖:憑證鏈驗證證明「你是叢集裡某個合法的服務」,名稱檢查再決定「你可以呼叫我」。

做法有兩條路。第一條是交給服務網格(service mesh,例如 Istio、Linkerd):每個 Pod 旁邊的代理自動簽發與輪替憑證、自動做 mTLS,再用網格的授權政策描述「誰可以呼叫誰」,Go 程式完全不用改。第二條是在 Go 裡自己設定 crypto/tls,憑證由 cert-manager 這類工具簽發並以 Secret 掛載進 Pod。服務數量不多、或想先理解原理時,第二條路更透明:

// mTLS:order 服務只接受帶著叢集內 CA 簽發憑證、而且身分在白名單上的呼叫者。
package main

import (
	"crypto/tls"
	"crypto/x509"
	"errors"
	"fmt"
	"log"
	"net/http"
	"os"
	"slices"
	"time"
)

func loadPool(path string) (*x509.CertPool, error) {
	pem, err := os.ReadFile(path)
	if err != nil {
		return nil, err
	}
	pool := x509.NewCertPool()
	if !pool.AppendCertsFromPEM(pem) {
		return nil, errors.New("no CA certificate found in " + path)
	}
	return pool, nil
}

// serverTLS:要求並驗證用戶端憑證,再檢查憑證上的服務身分。
func serverTLS(caFile, certFile, keyFile string, allowed []string) (*tls.Config, error) {
	ca, err := loadPool(caFile)
	if err != nil {
		return nil, err
	}
	return &tls.Config{
		MinVersion: tls.VersionTLS13,
		ClientAuth: tls.RequireAndVerifyClientCert,
		ClientCAs:  ca,
		// 每次握手重新讀檔,憑證輪替時不必重啟服務。
		GetCertificate: func(*tls.ClientHelloInfo) (*tls.Certificate, error) {
			c, err := tls.LoadX509KeyPair(certFile, keyFile)
			return &c, err
		},
		// 走到這裡時鏈已經驗證過;這裡只做「誰可以呼叫我」的授權。
		VerifyConnection: func(cs tls.ConnectionState) error {
			if len(cs.PeerCertificates) == 0 {
				return errors.New("no client certificate")
			}
			leaf := cs.PeerCertificates[0]
			for _, name := range leaf.DNSNames {
				if slices.Contains(allowed, name) {
					return nil
				}
			}
			return fmt.Errorf("caller %v not allowed", leaf.DNSNames)
		},
	}, nil
}

// clientTLS:呼叫其他服務時出示自己的憑證,並只信任叢集內 CA。
func clientTLS(caFile, certFile, keyFile string) (*tls.Config, error) {
	ca, err := loadPool(caFile)
	if err != nil {
		return nil, err
	}
	cert, err := tls.LoadX509KeyPair(certFile, keyFile)
	if err != nil {
		return nil, err
	}
	return &tls.Config{
		MinVersion:   tls.VersionTLS13,
		RootCAs:      ca,
		Certificates: []tls.Certificate{cert},
	}, nil
}

func main() {
	dir := os.Getenv("TLS_DIR") // 例如 /etc/shop/tls,由 Secret 掛載
	cfg, err := serverTLS(dir+"/ca.crt", dir+"/tls.crt", dir+"/tls.key",
		[]string{"api-gateway.shop.svc", "payment.shop.svc"})
	if err != nil {
		log.Fatal(err)
	}
	mux := http.NewServeMux()
	mux.HandleFunc("GET /healthz", func(w http.ResponseWriter, _ *http.Request) { w.Write([]byte("ok")) })

	srv := &http.Server{
		Addr:              ":8443",
		Handler:           mux,
		TLSConfig:         cfg,
		ReadHeaderTimeout: 5 * time.Second,
	}
	// 憑證已經在 TLSConfig 裡,所以兩個檔名參數留空。
	log.Fatal(srv.ListenAndServeTLS("", ""))
}

// newInventoryClient:order 呼叫 inventory 時用的 HTTP client。
func newInventoryClient(dir string) (*http.Client, error) {
	cfg, err := clientTLS(dir+"/ca.crt", dir+"/tls.crt", dir+"/tls.key")
	if err != nil {
		return nil, err
	}
	return &http.Client{
		Timeout:   3 * time.Second,
		Transport: &http.Transport{TLSClientConfig: cfg},
	}, nil
}

tls.RequireAndVerifyClientCert 讓握手在用戶端沒有憑證、或憑證不是 ClientCAs 簽的時候直接失敗;VerifyConnection 在鏈驗證通過之後執行,用來做「這個服務能不能呼叫我」的判斷。這裡用憑證的 DNS 名稱當身分;服務網格多半用 SPIFFE 格式的 URI(spiffe://...),放在憑證的 URI SAN,對應的欄位是 leaf.URIs。gRPC 用同一份 tls.Config,透過 credentials.NewTLS(cfg) 帶進去即可。GetCertificate 每次握手重新讀檔是最簡單的輪替方式;流量大時可以改成監看檔案變動後再重新載入並快取。

mTLS 解決的是身分,最小權限則要每一層都做:

  • 資料庫:每個服務一個帳號,只能存取自己的 schema;order 的帳號不能讀 payment 的資料表;應用帳號沒有 DDL 權限,遷移用另一個帳號在部署時執行(見〈用 Docker Compose 部署整套微服務〉把遷移當一次性工作的做法)。
  • 訊息佇列:每個服務只能發布與訂閱自己需要的主題,inventory 不能發布 PaymentSucceeded。
  • Kubernetes:每個服務有自己的 ServiceAccount,不需要呼叫 Kubernetes API 的就關掉 token 自動掛載;容器以非 root 執行、根檔案系統唯讀;NetworkPolicy 預設拒絕,只開需要的連線。
  • 外部連線:只有 payment 需要連外部金流,其他服務的對外流量可以全部擋掉,這也是防 SSRF(API7)最實際的一層。

第 6 步:密鑰不進程式碼、映像檔與日誌,而且要能輪替

密鑰包括資料庫密碼、金流 API 金鑰、JWT 簽章私鑰、TLS 私鑰、第三方服務的 token。原則只有三條:不進版本控制、不進映像檔、不進日誌;在這之上再加一條:要能在不改程式的情況下輪替。

不進版本控制最容易違反的方式,是「先寫在 config.yaml 裡測試一下」,然後忘了拿掉;一旦推上遠端,就算下一個 commit 刪掉,它仍然留在歷史裡,必須視為已外洩、立即換掉。防護方式是 .gitignore 加上提交前的密鑰掃描(pre-commit hook 或 CI 裡的掃描工具),以及在 PR 審查時特別看設定檔。不進映像檔則是指 Dockerfile 裡不要 COPY .env、不要用 ARG/ENV 帶密碼——映像檔的每一層都可以被拆開來看,docker history 也會留下建置參數。

在執行時取得密鑰,大致有三種方式:

方式做法優點缺點
環境變數Kubernetes Secret 以 env 注入最簡單,〈設定與優雅關閉〉的設定載入就能讀容易被印出來(除錯時 dump 環境、錯誤回報工具收集環境);更新要重啟 Pod
掛載檔案Secret 以 volume 掛到 /etc/shop/secrets/可以設檔案權限;Secret 更新後檔案會跟著更新,程式可重新讀取程式要自己處理重新載入
密鑰管理服務執行時向 Vault、雲端 Secret Manager 取得,或用 External Secrets 同步成 Secret集中稽核、細緻權限、可以發動態短效憑證多一個相依,啟動時要處理它不可用的情況

這個系列的建議是:密鑰以檔案掛載,設定(非機密的部分)用環境變數;中大型團隊再接上密鑰管理服務,由它同步成 Kubernetes Secret,程式碼不必知道密鑰從哪來。記得 Kubernetes Secret 預設只是 base64 編碼,叢集要開啟靜態加密(encryption at rest),並用 RBAC 限制誰能讀 Secret。

輪替要事先設計,而不是出事時才想:資料庫密碼可以準備兩個帳號輪流換;JWT 簽章金鑰靠 JWKS 同時發布新舊公鑰;外部金流的金鑰則照供應商的流程,通常支援同時存在兩把。程式這邊要做到的是「讀取的時機不只有啟動時」:檔案掛載的密鑰可以在每次建立新連線時重新讀檔,或監看檔案變動。第 5 步的 GetCertificate 就是同一個思路。

第 7 步:輸入驗證、參數化查詢、限流與安全標頭

這一步把 API8(設定錯誤)、API4(資源無限制消耗)、API3(物件屬性層級授權)與注入問題放在一起,因為它們都是「怎麼處理進來的請求」。

輸入驗證要在服務的邊界做,而且用白名單思維:規定什麼是合法的,而不是列舉什麼是危險的。數量要有上下限、字串要有長度上限、列舉值要在清單裡。JSON 解碼時用 DisallowUnknownFields,用戶端送來 "status":"paid" 或 "total":1 這種不該由它決定的欄位,就直接拒絕,這是擋 API3 中「大量賦值(mass assignment)」最簡單的方式;回應時也只輸出 DTO 裡明列的欄位,不要把資料庫模型整個序列化出去。

SQL 注入的解法在 Go 裡很單純:值永遠透過佔位符傳給 database/sql(見〈database/sql、交易與連線池〉),從不用 fmt.Sprintf 拼進 SQL。不能當參數的部分(排序欄位、排序方向、資料表名稱)用白名單對應。輸出編碼則看輸出到哪裡:JSON 交給 encoding/json、HTML 交給 html/template 自動跳脫,不要自己拼字串。

請求大小用 http.MaxBytesReader 限制,再配合 http.Server 的 ReadHeaderTimeout、ReadTimeout 與 MaxHeaderBytes;列表 API 要有最大筆數。限流在 gateway 依使用者與 IP 做(token bucket 的實作見〈API Gateway:路由、認證、限流〉),登入、下單、付款這類敏感流程要有更嚴格的額度,也是對付 API6 的第一道防線。

日誌則要反過來想:寫進去的東西會被很多人與很多系統看到。token、密碼、卡號永遠不寫;Email、電話這類個資遮罩後再寫;使用者 ID 通常可以寫,因為除錯需要。與其要求每個人記得,不如在 slog 的 handler 上用 ReplaceAttr 統一遮蔽:

// 輸入驗證、參數化查詢、不洩漏 token 與個資的日誌。
package main

import (
	"context"
	"database/sql"
	"encoding/json"
	"errors"
	"fmt"
	"log/slog"
	"net/http"
	"os"
	"strings"
)

type CreateOrderRequest struct {
	Items []struct {
		SKU      string `json:"sku"`
		Quantity int    `json:"quantity"`
	} `json:"items"`
	Note string `json:"note"`
}

func (r CreateOrderRequest) Validate() error {
	if len(r.Items) == 0 || len(r.Items) > 50 {
		return errors.New("items: need 1 to 50 items")
	}
	for i, it := range r.Items {
		if it.SKU == "" || len(it.SKU) > 64 {
			return fmt.Errorf("items[%d].sku: invalid", i)
		}
		if it.Quantity < 1 || it.Quantity > 99 {
			return fmt.Errorf("items[%d].quantity: must be 1..99", i)
		}
	}
	if len([]rune(r.Note)) > 200 {
		return errors.New("note: too long")
	}
	return nil
}

func decodeCreate(w http.ResponseWriter, r *http.Request) (CreateOrderRequest, error) {
	var req CreateOrderRequest
	r.Body = http.MaxBytesReader(w, r.Body, 64<<10) // 64 KiB 上限
	dec := json.NewDecoder(r.Body)
	dec.DisallowUnknownFields() // 擋掉 "status"、"total" 這類用戶端不該送的欄位
	if err := dec.Decode(&req); err != nil {
		return req, fmt.Errorf("decode: %w", err)
	}
	return req, req.Validate()
}

// 參數化查詢:值永遠走佔位符,不拼進 SQL 字串。
// 排序欄位這種不能當參數的東西,用白名單對應。
var sortColumns = map[string]string{"created": "created_at", "total": "total"}

func listOrders(ctx context.Context, db *sql.DB, userID, status, sort string) (*sql.Rows, error) {
	col, ok := sortColumns[sort]
	if !ok {
		col = "created_at"
	}
	q := "SELECT id, total, status FROM orders WHERE user_id = $1 AND status = $2 ORDER BY " + col + " DESC LIMIT 50"
	return db.QueryContext(ctx, q, userID, status)
}

// 日誌:敏感鍵一律遮蔽,Email 只留網域。
var secretKeys = map[string]bool{"authorization": true, "token": true, "password": true, "card_number": true}

func redact(_ []string, a slog.Attr) slog.Attr {
	k := strings.ToLower(a.Key)
	switch {
	case secretKeys[k]:
		return slog.String(a.Key, "[REDACTED]")
	case k == "email":
		if _, domain, ok := strings.Cut(a.Value.String(), "@"); ok {
			return slog.String(a.Key, "***@"+domain)
		}
	}
	return a
}

func main() {
	log := slog.New(slog.NewJSONHandler(os.Stdout, &slog.HandlerOptions{ReplaceAttr: redact}))
	log.Info("login", "user_id", "u-42", "email", "alice@example.com", "token", "eyJhbGciOi...")

	mux := http.NewServeMux()
	mux.HandleFunc("POST /orders", func(w http.ResponseWriter, r *http.Request) {
		req, err := decodeCreate(w, r)
		if err != nil {
			http.Error(w, "invalid request", http.StatusBadRequest)
			return
		}
		fmt.Fprintf(w, "ok: %d items\n", len(req.Items))
	})
	_ = mux
	_ = listOrders
}

執行後日誌裡的 email 會變成 ***@example.com、token 變成 [REDACTED]。注意 ReplaceAttr 只看得到鍵名,如果有人把整個請求結構用一個鍵印出來,它就攔不到;所以團隊規範仍然要寫清楚「不要把整個請求或標頭印進日誌」,並在審查時注意。追蹤(tracing)的 span 屬性也是同樣的道理,不要把 Authorization 標頭當成屬性記錄。

安全標頭與 CORS 放在 gateway 統一處理。純 JSON API 至少要有 Content-Type: application/json、X-Content-Type-Options: nosniff,HTTPS 網域加上 Strict-Transport-Security。CORS 不是防護機制,而是「放寬」瀏覽器同源政策的機制:只列出確實需要的前端網域,不要把請求的 Origin 原樣反射回去;需要帶 Cookie(Access-Control-Allow-Credentials: true)時更不能配 *。錯誤回應不帶堆疊與內部訊息,細節只寫進日誌並附上 request ID,讓客服能對照。

第 8 步:守住供應鏈——相依套件、映像檔與建置流程

最後一條邊界在程式碼之外:你執行的東西,真的是你以為的那些程式碼嗎?供應鏈攻擊可能發生在相依套件(被植入惡意程式碼或有已知漏洞)、基底映像檔、建置環境,或發布到映像檔倉庫之後被替換。

Go 在這方面有不錯的基礎。go.sum 記錄每個模組版本的雜湊,加上預設的 checksum database(sum.golang.org),可以確保同一個版本在任何地方下載到的內容都一樣(見〈工程結構與 Go Modules〉)。go.sum 一定要提交;go mod verify 可以確認本機模組快取沒有被改過。

已知漏洞用官方的 govulncheck 檢查。它的特點是會分析呼叫圖:只有你的程式真的呼叫到有漏洞的函式時才報告,雜訊比單純比對版本號少很多。除了掃原始碼,也可以掃編譯好的執行檔:

# 相依套件完整性
go mod verify

# 已知漏洞:分析呼叫圖,只報告真的會呼叫到的漏洞
go install golang.org/x/vuln/cmd/govulncheck@latest
govulncheck ./...

# 也可以檢查已經編譯好的執行檔(例如從映像檔裡取出的)
go build -o bin/order ./cmd/order
govulncheck -mode=binary bin/order

# 建置映像檔時一併產生 SBOM 與來源證明(需要 BuildKit 與支援 attestation 的 registry)
docker buildx build --sbom=true --provenance=true \
  -t registry.example.com/shop/order:1.4.2 --push -f deploy/Dockerfile .

govulncheck 也會檢查 Go 標準函式庫本身,所以它報告的修補方式有時是「升級 Go 版本」。在 CI 裡,每次 PR 跑一次,另外每天排程對主分支跑一次——新的漏洞公告不會等你改程式碼才出現。

映像檔這一側,〈Docker 與 Kubernetes 部署(單一服務)〉已經用了多階段建置與 distroless 基底:最終映像檔裡只有一個靜態執行檔與 CA 憑證,沒有 shell、沒有套件管理器,攻擊者就算拿到執行權限,可以利用的工具也很少。再往前一步:

  • 固定基底映像檔的 digest(@sha256:...),而不是只寫標籤,避免同一個標籤被換掉內容;再用自動化工具定期提 PR 更新它。
  • SBOM(軟體物料清單)列出映像檔裡所有元件與版本。新漏洞公告出來時,你可以直接查「哪些映像檔含有這個元件」,而不是逐一猜測。
  • 映像檔簽章:發布時用 Sigstore 的 cosign 這類工具簽章,叢集用准入控制器(admission controller)只允許有效簽章的映像檔部署。概念是「只有 CI 建出來的東西能上線」,人手 docker push 的映像檔進不了叢集。
  • 建置環境:CI 的 token 只給需要的權限、第三方 Action 固定到 commit SHA、正式環境的部署憑證只在受保護的分支上可用。這部分在〈AI 工作流接進團隊流程:PR 審查、CI 與人工把關〉會再談。

第 9 步:整理成一張檢查表,對照前面的文章

把前面八步收斂成一張可以放進 PR 範本或上線前檢查的表。每一項都對應到這個系列裡已經實作過的地方,方便回頭找程式碼:

項目要確認的事相關文章
威脅模型有信任邊界圖,新服務或新對外 API 會更新本篇第 1 步
認證gateway 驗簽章、演算法、iss、aud、exp;JWKS 快取與輪替〈API Gateway〉
身分傳遞gateway 刪除外來的 X-User-*;後端只接受 gateway 連線〈net/http 與中介層〉、〈context〉
物件層級授權每個讀寫訂單的方法都檢查擁有者,測試有「別人的訂單」案例〈分層架構與依賴注入〉、〈測試〉
功能層級授權退款、後台功能檢查角色本篇第 4 步
服務間信任mTLS 或服務網格;NetworkPolicy 預設拒絕〈gRPC〉、〈在 Kubernetes 部署整套微服務〉
最小權限每服務一個資料庫帳號、主題權限、非 root、唯讀檔案系統〈Docker Compose〉、〈Kubernetes〉
密鑰不進 git、映像檔、日誌;以檔案掛載;有輪替流程〈設定與優雅關閉〉
輸入與注入白名單驗證、DisallowUnknownFields、參數化查詢、大小上限〈database/sql、交易與連線池〉
資源消耗限流、逾時、列表上限〈API Gateway〉、〈逾時、重試與熔斷〉
外部回呼金流回呼驗簽、冪等處理、對帳〈支付常見問題〉、〈冪等與分散式鎖〉
日誌ReplaceAttr 遮蔽 token 與個資;拒絕存取有告警〈可觀測性〉
供應鏈go.sum 提交、govulncheck 在 CI 與排程、distroless、SBOM、簽章〈Docker 與 Kubernetes 部署〉

這張表不是一次做完的清單,而是一份可以逐步提高的基準。建議的順序是先做「擋住最常見、影響最大」的:物件層級授權、JWT 完整驗證、密鑰不進 git、govulncheck 進 CI;接著是 mTLS 與最小權限;最後才是簽章與准入控制這類需要較多基礎設施的項目。

常見陷阱

  • 只在 gateway 做授權。 gateway 能判斷「有沒有登入」「有沒有某個角色」,但判斷不了「這筆訂單是不是你的」。BOLA 只能在擁有資料的服務裡擋。
  • 後端相信任何人送來的 X-User-ID。 gateway 沒刪外來標頭,或後端可以被叢集內其他 Pod 直接呼叫,身分標頭就等於可以自己填。
  • JWT 只驗簽章。 沒驗 aud,別的應用的 token 也能用;沒限定演算法,可能遇到演算法混淆攻擊;沒驗 exp,外洩的 token 永遠有效。
  • 回 403 洩漏資源是否存在。 對使用者擁有的資源,不屬於他時回 404。
  • 密鑰在 git 歷史裡。 刪掉檔案不等於移除外洩;推上去過的密鑰一律換掉。
  • 把除錯日誌開在正式環境。 除錯時印出的整個請求常常包含 Authorization 標頭與個資。
  • InsecureSkipVerify: true 留在程式裡。 測試時為了方便關掉憑證驗證,結果一起上線,mTLS 形同虛設。測試環境應該用測試 CA,而不是關掉驗證。
  • CORS 反射任意 Origin 又允許憑證。 等於讓任何網站都能以使用者身分呼叫你的 API。
  • govulncheck 只在專案開始時跑一次。 漏洞公告每天都在新增,要排程持續跑。
  • 相信外部金流的回應與回呼。 回呼要驗簽、金額與訂單要跟自己的資料比對,見 API10。

重點整理

  • 先畫威脅模型與信任邊界,每跨過一條邊界都要重新認證與授權。
  • 認證在 gateway 做一次:驗簽章、限定演算法、iss、aud、exp/nbf,用 JWKS 處理金鑰輪替;JWT 驗證交給成熟的函式庫。
  • gateway 刪掉外來的身分標頭再加上驗證過的身分;後端只接受 gateway 的連線。
  • BOLA 是 OWASP API Security Top 10(2023)第一名:每個讀寫資源的服務方法都要檢查擁有者,不屬於時回 404,並用表格驅動測試守住。
  • 服務之間用 mTLS(RequireAndVerifyClientCert 加 VerifyConnection 檢查呼叫者名稱)或服務網格;資料庫、訊息佇列、Kubernetes 都照最小權限設定。
  • 密鑰不進 git、映像檔與日誌,以檔案掛載或密鑰管理服務提供,事先設計輪替。
  • 白名單式輸入驗證、DisallowUnknownFields、參數化查詢、請求大小上限、限流、安全標頭與嚴格的 CORS。
  • 用 slog 的 ReplaceAttr 統一遮蔽 token 與個資。
  • 供應鏈:提交 go.sum、govulncheck 進 CI 並排程、distroless 與固定 digest、SBOM、映像檔簽章。

下一篇

安全的很多環節,最後都落在「每一次程式碼變更都有人仔細看過、檢查都有跑」。下一篇〈用 Claude Code 開發 Go 微服務:規則、權限與安全審查〉談怎麼讓 AI 代理參與開發,同時用專案規則、權限設定與 hooks 把它限制在安全的範圍內。