package webhookguard import ( "encoding/json" "fmt" "regexp" "strings" ) // redactedValue replaces a value whose key (or shape) looks sensitive. const redactedValue = "[redacted]" // SensitiveKeyMarkers are key substrings whose values are redacted. var SensitiveKeyMarkers = []string{ "token", "secret", "password", "passwd", "pwd", "passphrase", "api_key", "apikey", "api_secret", "client_secret", "private_key", "secret_key", "signing_key", "authorization", "bearer", "credential", "cookie", "session", "access_token", "refresh_token", "id_token", "bot_token", "webhook_secret", "x_api_key", "x_auth_token", "jwt", "oauth", "csrf", "otp", "signature", } // jwtTokenRe matches a compact JWT (header.payload.signature) -- the header's // base64url always begins "eyJ" -- anywhere in a string. It is unanchored so // a token embedded in prose is still caught, both in JSON string values and // in free text. var jwtTokenRe = regexp.MustCompile(`eyJ[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+`) // RedactPayload replaces values under sensitive keys, or with secret-shaped // values, with a marker and returns the re-encoded JSON. Best-effort. func RedactPayload(payload []byte) ([]byte, error) { var value any decoder := json.NewDecoder(strings.NewReader(string(payload))) decoder.UseNumber() if err := decoder.Decode(&value); err != nil { return nil, fmt.Errorf("redact payload: decode: %w", err) } redacted := redactValue(value) encoded, err := json.Marshal(redacted) if err != nil { return nil, fmt.Errorf("redact payload: encode: %w", err) } return encoded, nil } // RedactString replaces a free-text value that has an unambiguous secret's // shape, for fields that carry prose rather than a JSON document. Key-based // redaction does not apply: there is no key. func RedactString(value string) string { if sensitiveValueShape(value) { return redactedValue } return value } func redactValue(value any) any { switch typed := value.(type) { case map[string]any: for key, child := range typed { if sensitiveKey(key) { typed[key] = redactedValue continue } typed[key] = redactValue(child) } return typed case []any: for i, child := range typed { typed[i] = redactValue(child) } return typed case string: if sensitiveValueShape(typed) { return redactedValue } return typed default: return value } } // sensitiveValueShape reports whether a string contains an unambiguous secret // even under a non-sensitive key: a compact JWT anywhere in the string, or a // PEM private-key block. These shapes are never a meaningful field-mapping // value, so redacting them does not hurt the schema-by-example use case. func sensitiveValueShape(s string) bool { if len(s) < 20 { return false } if jwtTokenRe.MatchString(s) { return true } return strings.Contains(s, "-----BEGIN") && strings.Contains(s, "PRIVATE KEY-----") } func sensitiveKey(key string) bool { normalized := strings.NewReplacer("-", "_", " ", "_").Replace(strings.ToLower(key)) for _, marker := range SensitiveKeyMarkers { if strings.Contains(normalized, marker) { return true } } return false }