fix: align customer payment encryption and protect original values

server/utility/encrypt/field.go

@@ -54,30 +54,32 @@ func DecryptField(ctx context.Context, encoded string) (string, error) {
 	if encoded == "" {
 		return "", nil
 	}
-	key, err := fieldKey(ctx)
+	raw, err := decodeFieldPayload(encoded)
 	if err != nil {
 		return "", err
 	}
-	raw, err := base64.RawURLEncoding.DecodeString(encoded)
-	if err != nil {
-		return "", gerror.Wrap(err, "敏感字段密文格式错误")
-	}
-	block, err := aes.NewCipher(key)
-	if err != nil {
-		return "", err
-	}
-	gcm, err := cipher.NewGCM(block)
-	if err != nil {
-		return "", err
-	}
-	if len(raw) < gcm.NonceSize() {
+	if len(raw) < 12+16 {
 		return "", gerror.New("敏感字段密文不完整")
 	}
-	plain, err := gcm.Open(nil, raw[:gcm.NonceSize()], raw[gcm.NonceSize():], nil)
-	if err != nil {
-		return "", gerror.Wrap(err, "敏感字段解密失败")
+	keys := financeFieldReadKeys(ctx)
+	if key, keyErr := fieldKey(ctx); keyErr == nil {
+		keys = append(keys, key)
 	}
-	return string(plain), nil
+	for _, key := range keys {
+		block, keyErr := aes.NewCipher(key)
+		if keyErr != nil {
+			continue
+		}
+		gcm, keyErr := cipher.NewGCM(block)
+		if keyErr != nil {
+			continue
+		}
+		plain, decryptErr := gcm.Open(nil, raw[:gcm.NonceSize()], raw[gcm.NonceSize():], nil)
+		if decryptErr == nil {
+			return string(plain), nil
+		}
+	}
+	return "", gerror.New("敏感字段解密失败，请核对当前及历史密钥配置")
 }
 
 // HashField creates a deterministic, non-reversible lookup key with a secret pepper.

server/utility/encrypt/finance_field.go

@@ -0,0 +1,111 @@
+package encrypt
+
+import (
+	"context"
+	"crypto/aes"
+	"crypto/cipher"
+	"crypto/hmac"
+	"crypto/rand"
+	"crypto/sha256"
+	"encoding/base64"
+	"encoding/hex"
+	"io"
+	"strings"
+
+	"github.com/gogf/gf/v2/errors/gerror"
+	"github.com/gogf/gf/v2/frame/g"
+)
+
+// financeFieldKey uses the same key derivation as the customer-facing finance service.
+// An empty configuration retains the existing HotGo format for older installations.
+func financeFieldKey(ctx context.Context, purpose string) ([]byte, error) {
+	master := strings.TrimSpace(g.Cfg().MustGet(ctx, "security.financeMasterKey", "").String())
+	if master != "" {
+		if len([]byte(master)) < 32 {
+			return nil, gerror.New("收款资料密钥配置不正确")
+		}
+		return deriveFinanceFieldKey(master, purpose), nil
+	}
+	name := "security.financeDataEncryptionKey"
+	if purpose == "lookup-hmac" {
+		name = "security.financeLookupHmacKey"
+	}
+	encoded := strings.TrimSpace(g.Cfg().MustGet(ctx, name, "").String())
+	if encoded == "" {
+		return nil, nil
+	}
+	key, err := decodeFieldPayload(encoded)
+	if err != nil || (purpose == "data-encryption" && len(key) != 32) || (purpose == "lookup-hmac" && len(key) < 32) {
+		return nil, gerror.New("收款资料密钥配置不正确")
+	}
+	return key, nil
+}
+
+func deriveFinanceFieldKey(master, purpose string) []byte {
+	mac := hmac.New(sha256.New, []byte(master))
+	_, _ = mac.Write([]byte("olons-finance:" + purpose + ":v1"))
+	return mac.Sum(nil)
+}
+
+func financeFieldReadKeys(ctx context.Context) [][]byte {
+	keys := make([][]byte, 0)
+	if key, err := financeFieldKey(ctx, "data-encryption"); err == nil && len(key) > 0 {
+		keys = append(keys, key)
+	}
+	for _, master := range g.Cfg().MustGet(ctx, "security.financeLegacyMasterKeys", []string{}).Strings() {
+		if master = strings.TrimSpace(master); len([]byte(master)) >= 32 {
+			keys = append(keys, deriveFinanceFieldKey(master, "data-encryption"))
+		}
+	}
+	return keys
+}
+
+func decodeFieldPayload(value string) ([]byte, error) {
+	value = strings.TrimSpace(value)
+	for _, encoding := range []*base64.Encoding{base64.RawURLEncoding, base64.RawStdEncoding, base64.URLEncoding, base64.StdEncoding} {
+		if raw, err := encoding.DecodeString(value); err == nil {
+			return raw, nil
+		}
+	}
+	return nil, gerror.New("敏感字段密文格式错误")
+}
+
+// EncryptPaymentField keeps new admin edits readable by the customer-facing service.
+func EncryptPaymentField(ctx context.Context, plaintext string) (string, error) {
+	if plaintext == "" {
+		return "", nil
+	}
+	key, err := financeFieldKey(ctx, "data-encryption")
+	if err != nil {
+		return "", err
+	}
+	if len(key) == 0 {
+		return EncryptField(ctx, plaintext)
+	}
+	block, err := aes.NewCipher(key)
+	if err != nil {
+		return "", gerror.Wrap(err, "初始化收款资料加密失败")
+	}
+	aead, err := cipher.NewGCM(block)
+	if err != nil {
+		return "", gerror.Wrap(err, "初始化收款资料加密失败")
+	}
+	nonce := make([]byte, aead.NonceSize())
+	if _, err = io.ReadFull(rand.Reader, nonce); err != nil {
+		return "", gerror.Wrap(err, "生成收款资料随机数失败")
+	}
+	return base64.RawStdEncoding.EncodeToString(aead.Seal(nonce, nonce, []byte(plaintext), nil)), nil
+}
+
+func HashPaymentField(ctx context.Context, value string) (string, error) {
+	key, err := financeFieldKey(ctx, "lookup-hmac")
+	if err != nil {
+		return "", err
+	}
+	if len(key) == 0 {
+		return HashField(ctx, value)
+	}
+	mac := hmac.New(sha256.New, key)
+	_, _ = mac.Write([]byte(strings.TrimSpace(value)))
+	return hex.EncodeToString(mac.Sum(nil)), nil
+}

server/utility/encrypt/finance_field_test.go

@@ -0,0 +1,113 @@
+package encrypt
+
+import (
+	"context"
+	"crypto/aes"
+	"crypto/cipher"
+	"crypto/hmac"
+	"crypto/sha256"
+	"encoding/base64"
+	"encoding/hex"
+	"encoding/json"
+	"testing"
+
+	"github.com/gogf/gf/v2/frame/g"
+	"github.com/gogf/gf/v2/os/gcfg"
+)
+
+func TestDecryptFieldAcceptsCustomerPaymentKeys(t *testing.T) {
+	ctx := context.Background()
+	current := "current-finance-master-key-with-at-least-32-characters"
+	previous := "previous-finance-master-key-with-at-least-32-characters"
+	setFieldTestConfig(t, map[string]interface{}{"dataKey": "admin-legacy-key", "financeMasterKey": current, "financeLegacyMasterKeys": []string{previous}})
+	for _, master := range []string{current, previous} {
+		encoded := customerPaymentFixture(t, master, "6222000000001234")
+		plain, err := DecryptField(ctx, encoded)
+		if err != nil || plain != "6222000000001234" {
+			t.Fatalf("customer payment must decrypt with current or previous key: %v", err)
+		}
+	}
+}
+
+func TestPaymentWritesRemainReadableByCustomerService(t *testing.T) {
+	ctx := context.Background()
+	master := "current-finance-master-key-with-at-least-32-characters"
+	setFieldTestConfig(t, map[string]interface{}{"dataKey": "admin-legacy-key", "financeMasterKey": master})
+	const value = "6222000000001234"
+	encoded, err := EncryptPaymentField(ctx, value)
+	if err != nil {
+		t.Fatal(err)
+	}
+	payload, err := base64.RawStdEncoding.DecodeString(encoded)
+	if err != nil {
+		t.Fatal("payment edit must use the customer's standard Base64 format")
+	}
+	mac := hmac.New(sha256.New, []byte(master))
+	_, _ = mac.Write([]byte("olons-finance:data-encryption:v1"))
+	block, _ := aes.NewCipher(mac.Sum(nil))
+	aead, _ := cipher.NewGCM(block)
+	plain, err := aead.Open(nil, payload[:aead.NonceSize()], payload[aead.NonceSize():], nil)
+	if err != nil || string(plain) != value {
+		t.Fatalf("customer service cannot read admin edit: %v", err)
+	}
+	actualHash, err := HashPaymentField(ctx, value)
+	if err != nil {
+		t.Fatal(err)
+	}
+	mac = hmac.New(sha256.New, []byte(master))
+	_, _ = mac.Write([]byte("olons-finance:lookup-hmac:v1"))
+	lookup := hmac.New(sha256.New, mac.Sum(nil))
+	_, _ = lookup.Write([]byte(value))
+	if actualHash != hex.EncodeToString(lookup.Sum(nil)) {
+		t.Fatal("admin lookup hash must match customer service")
+	}
+}
+
+func TestDecryptFieldKeepsLegacyHotGoDataReadable(t *testing.T) {
+	ctx := context.Background()
+	setFieldTestConfig(t, map[string]interface{}{"dataKey": "admin-legacy-key", "financeMasterKey": "current-finance-master-key-with-at-least-32-characters"})
+	encoded, err := EncryptField(ctx, "旧资料")
+	if err != nil {
+		t.Fatal(err)
+	}
+	plain, err := DecryptField(ctx, encoded)
+	if err != nil || plain != "旧资料" {
+		t.Fatalf("legacy HotGo record unreadable: %v", err)
+	}
+	for _, invalid := range []string{"DEMO-NOT-CIPHERTEXT", "AAAA", customerPaymentFixture(t, "unknown-master-key-with-at-least-32-characters", "姓名")} {
+		if _, err := DecryptField(ctx, invalid); err == nil {
+			t.Fatal("invalid or unknown-key records must not be reported as plaintext")
+		}
+	}
+}
+
+func setFieldTestConfig(t *testing.T, security map[string]interface{}) {
+	t.Helper()
+	data, err := json.Marshal(map[string]interface{}{"security": security})
+	if err != nil {
+		t.Fatal(err)
+	}
+	adapter, err := gcfg.NewAdapterContent(string(data))
+	if err != nil {
+		t.Fatal(err)
+	}
+	previous := g.Cfg().GetAdapter()
+	g.Cfg().SetAdapter(adapter)
+	t.Cleanup(func() { g.Cfg().SetAdapter(previous) })
+}
+
+func customerPaymentFixture(t *testing.T, master, value string) string {
+	t.Helper()
+	mac := hmac.New(sha256.New, []byte(master))
+	_, _ = mac.Write([]byte("olons-finance:data-encryption:v1"))
+	block, err := aes.NewCipher(mac.Sum(nil))
+	if err != nil {
+		t.Fatal(err)
+	}
+	aead, err := cipher.NewGCM(block)
+	if err != nil {
+		t.Fatal(err)
+	}
+	nonce := []byte{251, 255, 239, 255, 251, 255, 239, 255, 251, 255, 239, 255}
+	return base64.RawStdEncoding.EncodeToString(aead.Seal(nonce, nonce, []byte(value), nil))
+}