fix(security): harden secret redaction follow-ups for PR #1884

Restore PreserveIfRedacted merge on tenant KV PUT so Admin settings saves
no longer overwrite stored secrets with placeholder values. Redact cross-
tenant tenant listings, tighten Viewer MCP/model responses, and align init
config frontend types with credentials metadata.
This commit is contained in:
wizardchen
2026-07-02 14:24:40 +08:00
committed by lyingbug
parent 512d2e5c25
commit 1a264e09c1
16 changed files with 377 additions and 44 deletions
+109
View File
@@ -141,3 +141,112 @@ func CredentialsConfigForResponse(cfg *CredentialsConfig, maskSecrets bool) *Cre
}
return &out
}
// MergeWebSearchConfigForUpdate applies preserve semantics to secret fields on
// tenant KV PUT.
func MergeWebSearchConfigForUpdate(incoming, existing *WebSearchConfig) *WebSearchConfig {
out := *EffectiveWebSearchConfig(incoming)
var prev WebSearchConfig
if existing != nil {
prev = *EffectiveWebSearchConfig(existing)
}
out.APIKey = PreserveIfRedacted(out.APIKey, prev.APIKey)
out.ProxyURL = PreserveIfRedacted(out.ProxyURL, prev.ProxyURL)
return &out
}
// MergeParserEngineConfigForUpdate applies preserve semantics to secret fields
// on tenant KV PUT.
func MergeParserEngineConfigForUpdate(incoming, existing *ParserEngineConfig) *ParserEngineConfig {
if incoming == nil {
return nil
}
out := *incoming
var prev ParserEngineConfig
if existing != nil {
prev = *existing
}
out.MinerUAPIKey = PreserveIfRedacted(out.MinerUAPIKey, prev.MinerUAPIKey)
out.PaddleOCRVLCloudToken = PreserveIfRedacted(out.PaddleOCRVLCloudToken, prev.PaddleOCRVLCloudToken)
return &out
}
// MergeStorageEngineConfigForUpdate applies preserve semantics to provider
// secret fields on tenant KV PUT.
func MergeStorageEngineConfigForUpdate(incoming, existing *StorageEngineConfig) *StorageEngineConfig {
if incoming == nil {
return nil
}
out := *incoming
if out.MinIO != nil {
minio := *out.MinIO
var prev MinIOEngineConfig
if existing != nil && existing.MinIO != nil {
prev = *existing.MinIO
}
minio.AccessKeyID = PreserveIfRedacted(minio.AccessKeyID, prev.AccessKeyID)
minio.SecretAccessKey = PreserveIfRedacted(minio.SecretAccessKey, prev.SecretAccessKey)
out.MinIO = &minio
}
if out.COS != nil {
cos := *out.COS
var prev COSEngineConfig
if existing != nil && existing.COS != nil {
prev = *existing.COS
}
cos.SecretID = PreserveIfRedacted(cos.SecretID, prev.SecretID)
cos.SecretKey = PreserveIfRedacted(cos.SecretKey, prev.SecretKey)
out.COS = &cos
}
if out.TOS != nil {
tos := *out.TOS
var prev TOSEngineConfig
if existing != nil && existing.TOS != nil {
prev = *existing.TOS
}
tos.AccessKey = PreserveIfRedacted(tos.AccessKey, prev.AccessKey)
tos.SecretKey = PreserveIfRedacted(tos.SecretKey, prev.SecretKey)
out.TOS = &tos
}
if out.S3 != nil {
s3 := *out.S3
var prev S3EngineConfig
if existing != nil && existing.S3 != nil {
prev = *existing.S3
}
s3.AccessKey = PreserveIfRedacted(s3.AccessKey, prev.AccessKey)
s3.SecretKey = PreserveIfRedacted(s3.SecretKey, prev.SecretKey)
out.S3 = &s3
}
if out.OSS != nil {
oss := *out.OSS
var prev OSSEngineConfig
if existing != nil && existing.OSS != nil {
prev = *existing.OSS
}
oss.AccessKey = PreserveIfRedacted(oss.AccessKey, prev.AccessKey)
oss.SecretKey = PreserveIfRedacted(oss.SecretKey, prev.SecretKey)
out.OSS = &oss
}
if out.KS3 != nil {
ks3 := *out.KS3
var prev KS3EngineConfig
if existing != nil && existing.KS3 != nil {
prev = *existing.KS3
}
ks3.AccessKey = PreserveIfRedacted(ks3.AccessKey, prev.AccessKey)
ks3.SecretKey = PreserveIfRedacted(ks3.SecretKey, prev.SecretKey)
out.KS3 = &ks3
}
if out.OBS != nil {
obs := *out.OBS
var prev OBSEngineConfig
if existing != nil && existing.OBS != nil {
prev = *existing.OBS
}
obs.AccessKey = PreserveIfRedacted(obs.AccessKey, prev.AccessKey)
obs.SecretKey = PreserveIfRedacted(obs.SecretKey, prev.SecretKey)
out.OBS = &obs
}
return &out
}
+92
View File
@@ -0,0 +1,92 @@
package types
import (
"testing"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
)
func TestWebSearchConfigForResponse_MasksSecrets(t *testing.T) {
cfg := &WebSearchConfig{
APIKey: "search-secret",
ProxyURL: "http://proxy.internal:8080",
}
resp := WebSearchConfigForResponse(cfg, true)
require.NotNil(t, resp)
assert.Empty(t, resp.APIKey)
assert.Equal(t, RedactedSecretPlaceholder, resp.ProxyURL)
}
func TestWebSearchConfigForResponse_Unmasked(t *testing.T) {
cfg := &WebSearchConfig{APIKey: "search-secret", ProxyURL: "http://proxy"}
resp := WebSearchConfigForResponse(cfg, false)
require.NotNil(t, resp)
assert.Equal(t, "search-secret", resp.APIKey)
assert.Equal(t, "http://proxy", resp.ProxyURL)
}
func TestMergeWebSearchConfigForUpdate_PreservesRedactedSecrets(t *testing.T) {
existing := &WebSearchConfig{APIKey: "stored-key", ProxyURL: "http://stored"}
incoming := &WebSearchConfig{
APIKey: "",
ProxyURL: RedactedSecretPlaceholder,
MaxResults: 10,
}
merged := MergeWebSearchConfigForUpdate(incoming, existing)
require.NotNil(t, merged)
assert.Equal(t, "stored-key", merged.APIKey)
assert.Equal(t, "http://stored", merged.ProxyURL)
assert.Equal(t, 10, merged.MaxResults)
}
func TestMergeParserEngineConfigForUpdate_PreservesRedactedSecrets(t *testing.T) {
existing := &ParserEngineConfig{
MinerUAPIKey: "mineru-secret",
PaddleOCRVLCloudToken: "paddle-secret",
MinerUEndpoint: "http://mineru",
}
incoming := &ParserEngineConfig{
MinerUAPIKey: RedactedSecretPlaceholder,
PaddleOCRVLCloudToken: RedactedSecretPlaceholder,
MinerUEndpoint: "http://mineru-new",
}
merged := MergeParserEngineConfigForUpdate(incoming, existing)
require.NotNil(t, merged)
assert.Equal(t, "mineru-secret", merged.MinerUAPIKey)
assert.Equal(t, "paddle-secret", merged.PaddleOCRVLCloudToken)
assert.Equal(t, "http://mineru-new", merged.MinerUEndpoint)
}
func TestMergeStorageEngineConfigForUpdate_PreservesRedactedSecrets(t *testing.T) {
existing := &StorageEngineConfig{
DefaultProvider: "minio",
MinIO: &MinIOEngineConfig{
AccessKeyID: "access-id",
SecretAccessKey: "secret-key",
BucketName: "bucket",
},
}
incoming := &StorageEngineConfig{
DefaultProvider: "minio",
MinIO: &MinIOEngineConfig{
AccessKeyID: RedactedSecretPlaceholder,
SecretAccessKey: RedactedSecretPlaceholder,
BucketName: "bucket-new",
},
}
merged := MergeStorageEngineConfigForUpdate(incoming, existing)
require.NotNil(t, merged)
require.NotNil(t, merged.MinIO)
assert.Equal(t, "access-id", merged.MinIO.AccessKeyID)
assert.Equal(t, "secret-key", merged.MinIO.SecretAccessKey)
assert.Equal(t, "bucket-new", merged.MinIO.BucketName)
}
func TestParserEngineConfigForResponse_NilSafe(t *testing.T) {
assert.Nil(t, ParserEngineConfigForResponse(nil, true))
}
func TestStorageEngineConfigForResponse_NilSafe(t *testing.T) {
assert.Nil(t, StorageEngineConfigForResponse(nil, true))
}
+26 -17
View File
@@ -1,23 +1,32 @@
// Package types — shared secret-handling helpers.
// Package types — shared secret redaction helpers.
//
// Historically this file also held PreserveIfRedacted / IsRedactedOrEmpty
// to support the old "echo redacted placeholder back, server merges on
// Update" pattern shared by MCP / Model / WebSearch / DataSource. Those
// resources have since moved to the credential-resource pattern (a
// dedicated /credentials subresource), so the merge helpers were removed.
// VectorStore connection configs and tenant KV configs (web search, parser
// engine, storage engine) use the redacted-placeholder round-trip pattern:
//
// The placeholder constant survives because VectorStore connection configs
// still inline-redact a Password / APIKey on response (see
// types/vectorstore.go → ConnectionConfig.MaskSensitiveFields); migrating
// VectorStore to the credential-resource pattern is left for a future PR
// because it would require introducing a separate connection record (the
// secret currently lives inline on the knowledge base config).
// - GET responses replace set secrets with RedactedSecretPlaceholder (or
// empty string when unset).
// - PUT requests treat "", or RedactedSecretPlaceholder as "preserve
// existing"; any other value replaces the stored secret.
//
// MCP / Model / WebSearch provider / DataSource credentials use a dedicated
// /credentials subresource instead; see internal/handler/dto/mcp.go.
package types
// RedactedSecretPlaceholder is the fixed value returned in API responses
// whenever a sensitive field is set but withheld from the client. Currently
// used only by VectorStore connection responses. New code should NOT
// introduce redacted-placeholder semantics — model the credential as a
// subresource and omit it from the main response shape instead (see
// internal/handler/dto/mcp.go for the template).
// whenever a sensitive field is set but withheld from the client.
const RedactedSecretPlaceholder = "***"
// IsRedactedOrEmpty reports whether s should be treated as "no change
// requested" in an Update request.
func IsRedactedOrEmpty(s string) bool {
return s == "" || s == RedactedSecretPlaceholder
}
// PreserveIfRedacted returns existing when incoming is empty or the redacted
// placeholder, otherwise returns incoming.
func PreserveIfRedacted(incoming, existing string) string {
if IsRedactedOrEmpty(incoming) {
return existing
}
return incoming
}
+45
View File
@@ -0,0 +1,45 @@
package types
import "testing"
func TestIsRedactedOrEmpty(t *testing.T) {
tests := []struct {
name string
in string
want bool
}{
{"empty string is redacted-or-empty", "", true},
{"fixed placeholder is redacted-or-empty", RedactedSecretPlaceholder, true},
{"short real secret is not redacted", "ab", false},
{"real secret longer than placeholder is not redacted", "real-bearer-token", false},
{"secret containing placeholder substring is not redacted", "prefix***suffix", false},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
if got := IsRedactedOrEmpty(tt.in); got != tt.want {
t.Errorf("IsRedactedOrEmpty(%q) = %v, want %v", tt.in, got, tt.want)
}
})
}
}
func TestPreserveIfRedacted(t *testing.T) {
tests := []struct {
name string
incoming string
existing string
want string
}{
{"empty incoming preserves existing", "", "stored-secret", "stored-secret"},
{"placeholder incoming preserves existing", RedactedSecretPlaceholder, "stored-secret", "stored-secret"},
{"real incoming replaces existing", "new-secret", "stored-secret", "new-secret"},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
if got := PreserveIfRedacted(tt.incoming, tt.existing); got != tt.want {
t.Errorf("PreserveIfRedacted(%q, %q) = %q, want %q",
tt.incoming, tt.existing, got, tt.want)
}
})
}
}