fix(security): webhook fail-closed、机密字段信封加密、限流信任代理修正
CI / backend (push) Canceled after 0s

三项 P0 安全修复:

1. Webhook 验签 fail-closed
   - WaffoWebhook 未配置验签材料时从「告警放行」改为 503 拒绝,
     封死伪造 order.completed 结算订单的路径
   - 通用 PaymentWebhook 从「仅 release 拒绝」收紧为默认拒绝,
     仅显式 ALLOW_UNVERIFIED_WEBHOOK=1(本地调试)放行

2. 机密字段信封加密(新增 internal/secretbox)
   - AES-256-GCM,主密钥 OPSLIC_MASTER_KEY(64 位 hex),密文带
     enc:v1: 前缀;Encrypt 幂等、历史明文原样放行
   - PaymentGatewayConfig.SecretKey/WebhookSecret 与 PeerNode.
     SharedKey 挂 GORM 钩子透明加解密,业务代码零改动;SharedKey
     列宽 128→512(密文更长)
   - 启动 fail-fast 校验主密钥;MigratePlaintext 幂等迁移存量明文;
     节点同步只含业务表,机密表为节点本地,互不影响
   - docker-compose/.env.example 补 OPSLIC_MASTER_KEY 与说明

3. 限流信任代理修正
   - 默认 SetTrustedProxies(nil) 不信任任何 X-Forwarded-For,
     封死伪造 XFF 轮换 IP 绕过按 IP 限流;反代节点用
     TRUSTED_PROXIES 指定内网 CIDR,非法配置拒绝启动

验证:go build/vet/test 全绿(含 secretbox 6 条单测);
读取路径(Waffo 私钥/webhook 密钥/互联密钥)确认全走 GORM 钩子。

部署注意:上线须配置 OPSLIC_MASTER_KEY(双节点一致)与
WAFFO_WEBHOOK_PUBLIC_KEY(未配则回调 503,属预期);香港反代
节点配 TRUSTED_PROXIES。
This commit is contained in:
Logan.Li committed 2026-11-01 02:03:26 +08:00
1 parent e0cef06234
commit 1c50d565eb
10 files changed
+360 -11

No files matched your search

+64
View File
@@ -0,0 +1,64 @@
package secretbox
import (
"fmt"
"gorm.io/gorm"
)
// MigratePlaintext 启动时把历史明文机密一次性加密回写(幂等,可重跑)。
// 只处理非空且无 enc:v1: 前缀的值;双节点各自执行,密文经节点同步后
// 在相同 OPSLIC_MASTER_KEY 下均可解密。 // Logan.Li
func MigratePlaintext(db *gorm.DB) error {
if !Ready() {
return fmt.Errorf("secretbox: 主密钥未装载,拒绝执行机密迁移")
}
// payment_gateway_configs: 主键为 gateway(字符串) // Logan.Li
var gwRows []struct {
Gateway string
SecretKey string
WebhookSecret string
}
if err := db.Raw(`SELECT gateway, secret_key, webhook_secret FROM payment_gateway_configs
WHERE (secret_key <> '' AND secret_key NOT LIKE ?)
OR (webhook_secret <> '' AND webhook_secret NOT LIKE ?)`, Prefix+"%", Prefix+"%").
Scan(&gwRows).Error; err != nil {
return fmt.Errorf("扫描 payment_gateway_configs: %w", err)
}
for _, r := range gwRows {
encSecret, err := Encrypt(r.SecretKey)
if err != nil {
return fmt.Errorf("加密 %s.secret_key: %w", r.Gateway, err)
}
encWebhook, err := Encrypt(r.WebhookSecret)
if err != nil {
return fmt.Errorf("加密 %s.webhook_secret: %w", r.Gateway, err)
}
if err := db.Exec(`UPDATE payment_gateway_configs SET secret_key = ?, webhook_secret = ? WHERE gateway = ?`,
encSecret, encWebhook, r.Gateway).Error; err != nil {
return fmt.Errorf("回写 %s: %w", r.Gateway, err)
}
}
// peer_nodes: 主键为 id(整型) // Logan.Li
var peerRows []struct {
ID uint
SharedKey string
}
if err := db.Raw(`SELECT id, shared_key FROM peer_nodes
WHERE shared_key <> '' AND shared_key NOT LIKE ?`, Prefix+"%").
Scan(&peerRows).Error; err != nil {
return fmt.Errorf("扫描 peer_nodes: %w", err)
}
for _, r := range peerRows {
enc, err := Encrypt(r.SharedKey)
if err != nil {
return fmt.Errorf("加密 peer_nodes.%d: %w", r.ID, err)
}
if err := db.Exec(`UPDATE peer_nodes SET shared_key = ? WHERE id = ?`, enc, r.ID).Error; err != nil {
return fmt.Errorf("回写 peer_nodes.%d: %w", r.ID, err)
}
}
return nil
}
+104
View File
@@ -0,0 +1,104 @@
// Package secretbox 为落库机密字段提供信封加密(AES-256-GCM)。
// 主密钥来自环境变量 OPSLIC_MASTER_KEY(64 位 hex = 32 字节),启动时装载,
// 缺失或非法即 fail-fast。密文带 enc:v1: 前缀;无前缀的值视为历史明文,
// Decrypt 原样返回——支持存量数据一次性迁移渐进完成。 // Logan.Li
package secretbox
import (
"crypto/aes"
"crypto/cipher"
"crypto/rand"
"encoding/base64"
"encoding/hex"
"errors"
"fmt"
"os"
"strings"
"sync"
)
// Prefix 密文前缀;同时用于迁移时识别未加密的历史明文。 // Logan.Li
const Prefix = "enc:v1:"
var (
mu sync.RWMutex
aed cipher.AEAD
)
// LoadMasterKey 从 OPSLIC_MASTER_KEY 装载主密钥;缺失/非法返回错误(调用方应 fail-fast)。 // Logan.Li
func LoadMasterKey() error {
raw := strings.TrimSpace(os.Getenv("OPSLIC_MASTER_KEY"))
if raw == "" {
return errors.New("未配置 OPSLIC_MASTER_KEY(64 位 hex,32 字节):机密字段加密不可用,拒绝启动")
}
key, err := hex.DecodeString(raw)
if err != nil || len(key) != 32 {
return errors.New("OPSLIC_MASTER_KEY 必须是 64 位 hex(32 字节)")
}
block, err := aes.NewCipher(key)
if err != nil {
return fmt.Errorf("初始化 AES 失败: %w", err)
}
gcm, err := cipher.NewGCM(block)
if err != nil {
return fmt.Errorf("初始化 GCM 失败: %w", err)
}
mu.Lock()
aed = gcm
mu.Unlock()
return nil
}
// Ready 报告主密钥是否已装载。 // Logan.Li
func Ready() bool {
mu.RLock()
defer mu.RUnlock()
return aed != nil
}
// Encrypt 加密明文:空串与已是密文的值原样返回(幂等,可安全重复调用)。 // Logan.Li
func Encrypt(plain string) (string, error) {
if plain == "" || strings.HasPrefix(plain, Prefix) {
return plain, nil
}
mu.RLock()
g := aed
mu.RUnlock()
if g == nil {
return "", errors.New("secretbox: 主密钥未装载")
}
nonce := make([]byte, g.NonceSize())
if _, err := rand.Read(nonce); err != nil {
return "", fmt.Errorf("生成 nonce 失败: %w", err)
}
sealed := g.Seal(nonce, nonce, []byte(plain), nil)
return Prefix + base64.StdEncoding.EncodeToString(sealed), nil
}
// Decrypt 解密:无前缀(空值或历史明文)原样返回;密文被篡改时返回错误。 // Logan.Li
func Decrypt(s string) (string, error) {
if !strings.HasPrefix(s, Prefix) {
return s, nil
}
mu.RLock()
g := aed
mu.RUnlock()
if g == nil {
return "", errors.New("secretbox: 主密钥未装载,无法解密机密字段")
}
raw, err := base64.StdEncoding.DecodeString(strings.TrimPrefix(s, Prefix))
if err != nil {
return "", fmt.Errorf("机密字段 base64 解码失败: %w", err)
}
if len(raw) < g.NonceSize() {
return "", errors.New("机密字段密文长度非法")
}
plain, err := g.Open(nil, raw[:g.NonceSize()], raw[g.NonceSize():], nil)
if err != nil {
return "", fmt.Errorf("机密字段解密失败(主密钥不一致或密文被篡改): %w", err)
}
return string(plain), nil
}
// MustDecrypt 供钩子使用:解密失败直接返回错误,让读写显式失败而非静默拿错值。 // Logan.Li
func MustDecrypt(s string) (string, error) { return Decrypt(s) }
@@ -0,0 +1,74 @@
package secretbox
import (
"os"
"strings"
"testing"
)
func withTestKey(t *testing.T) {
t.Helper()
t.Setenv("OPSLIC_MASTER_KEY", strings.Repeat("ab", 32))
if err := LoadMasterKey(); err != nil {
t.Fatalf("LoadMasterKey: %v", err)
}
}
func TestRoundtrip(t *testing.T) {
withTestKey(t)
for _, plain := range []string{"waffo-secret-123", "-----BEGIN RSA PRIVATE KEY-----\nabc\n-----END RSA PRIVATE KEY-----", "x", ""} {
enc, err := Encrypt(plain)
if err != nil {
t.Fatalf("Encrypt(%q): %v", plain, err)
}
if plain != "" && !strings.HasPrefix(enc, Prefix) {
t.Fatalf("密文缺少前缀: %q", enc)
}
got, err := Decrypt(enc)
if err != nil {
t.Fatalf("Decrypt: %v", err)
}
if got != plain {
t.Fatalf("roundtrip 不一致: got %q want %q", got, plain)
}
}
}
func TestEncryptIdempotent(t *testing.T) {
withTestKey(t)
once, _ := Encrypt("same-value")
twice, _ := Encrypt(once)
if once != twice {
t.Fatal("对已加密值再次 Encrypt 必须原样返回(幂等)")
}
}
func TestDecryptPlaintextPassthrough(t *testing.T) {
withTestKey(t)
got, err := Decrypt("legacy-plaintext")
if err != nil || got != "legacy-plaintext" {
t.Fatalf("历史明文应原样返回: got %q err %v", got, err)
}
}
func TestTamperDetection(t *testing.T) {
withTestKey(t)
enc, _ := Encrypt("secret")
tampered := enc[:len(enc)-2] + "A="
if _, err := Decrypt(tampered); err == nil {
t.Fatal("篡改后的密文必须解密失败")
}
}
func TestLoadMasterKeyFailFast(t *testing.T) {
t.Setenv("OPSLIC_MASTER_KEY", "")
if err := LoadMasterKey(); err == nil {
t.Fatal("缺失主密钥必须报错")
}
t.Setenv("OPSLIC_MASTER_KEY", "not-hex")
if err := LoadMasterKey(); err == nil {
t.Fatal("非法主密钥必须报错")
}
}
func TestMain(m *testing.M) { os.Exit(m.Run()) }