專欄 › 八、安全與 AI 協作 › 第 31 篇
微服務的安全性:認證、授權、密鑰與供應鏈
Microservice Security: Authentication, Authorisation, Secrets and Supply Chain
從訂單系統的威脅模型出發:在 gateway 驗證 JWT 並把身分傳給後端、每個服務自己做物件層級授權防 BOLA、服務之間用 mTLS、密鑰不進程式碼與日誌,最後用 govulncheck、SBOM 與簽章守住供應鏈。
這篇的步驟
上一篇〈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,或在相依套件裡藏了惡意程式碼)。第二種最容易被忽略,因為「有登入」常被誤以為「可信」。
接著畫出信任邊界:資料每跨過一條邊界,就要重新問「你是誰、你能不能做這件事」。
圖:網際網路到 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 就變成管理員;沒有限制來源,叢集裡任何一個被攻破的容器都能冒充任何使用者。
圖:認證在入口做一次;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 版的十項,後面幾步會對應到其中幾項:
| 編號 | 名稱 | 這套系統裡的例子 |
|---|---|---|
| API1 | Broken Object Level Authorization | 改 ID 看別人的訂單 |
| API2 | Broken Authentication | JWT 沒驗 aud、接受 none 演算法 |
| API3 | Broken Object Property Level Authorization | 用戶端送 "status":"paid" 就被寫進資料庫;回應多帶了內部欄位 |
| API4 | Unrestricted Resource Consumption | 沒有請求大小上限、沒有限流、一次能查一萬筆 |
| API5 | Broken Function Level Authorization | 一般使用者能呼叫退款這類管理功能 |
| API6 | Unrestricted Access to Sensitive Business Flows | 機器人大量下單佔住庫存 |
| API7 | Server Side Request Forgery | 服務依使用者給的網址發請求(例如自訂回呼網址) |
| API8 | Security Misconfiguration | CORS 全開、錯誤訊息帶堆疊、缺安全標頭 |
| API9 | Improper Inventory Management | 舊版 API、測試端點還在線上沒人管 |
| API10 | Unsafe 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)。
圖:憑證鏈驗證證明「你是叢集裡某個合法的服務」,名稱檢查再決定「你可以呼叫我」。
做法有兩條路。第一條是交給服務網格(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 把它限制在安全的範圍內。