fix(oracle-fusion): sanitize structured diagnostics

Author: Bill Leoutsakos

apps/sim/lib/internal/oracle-fusion-financials/client.ts

@@ -6,7 +6,12 @@ import {
   secureFetchWithPinnedIP,
   validateUrlWithDNS,
 } from '@/lib/core/security/input-validation.server'
-import { redactExactSensitiveValues } from '@/lib/core/security/redaction'
+import {
+  isSensitiveKey,
+  REDACTED_MARKER,
+  redactApiKeys,
+  redactExactSensitiveValues,
+} from '@/lib/core/security/redaction'
 import { consumeOrCancelBody } from '@/lib/core/utils/stream-limits'
 import { normalizeOracleFusionApplicationOrigin } from '@/lib/credentials/client-credential-accounts/descriptors'
 import type { OracleFusionAuthInput } from '@/lib/internal/oracle-fusion-financials/schema'
@@ -23,6 +28,10 @@ const TRANSIENT_TRANSPORT_CODES = new Set([
   'EPIPE',
   'ETIMEDOUT',
 ])
+const MAX_STRUCTURED_DIAGNOSTIC_DEPTH = 8
+const UNSAFE_DIAGNOSTIC = Symbol('unsafe-oracle-diagnostic')
+const DIAGNOSTIC_KEY_VALUE_PATTERN =
+  /(?:"([^"\r\n]{1,128})"|'([^'\r\n]{1,128})'|([A-Za-z][A-Za-z0-9 _-]{0,127}))\s*(?::|=)/g
 const LOSSLESS_DECIMAL_FIELDS = new Set([
   'InvoiceId',
   'InvoiceDistributionId',
@@ -82,15 +91,92 @@ function collectOracleErrorMessages(payload: unknown, depth = 0): string[] {
   return messages
 }
 
+function isSensitiveDiagnosticKey(key: string): boolean {
+  return isSensitiveKey(key.trim().replaceAll(/\s+/g, '_'))
+}
+
+function containsSensitiveDiagnosticKey(value: string): boolean {
+  for (const match of value.matchAll(DIAGNOSTIC_KEY_VALUE_PATTERN)) {
+    if (isSensitiveDiagnosticKey(match[1] ?? match[2] ?? match[3] ?? '')) return true
+  }
+  return false
+}
+
+function sanitizeStructuredDiagnosticValue(
+  value: unknown,
+  accessToken: string,
+  depth: number
+): unknown | typeof UNSAFE_DIAGNOSTIC {
+  if (depth > MAX_STRUCTURED_DIAGNOSTIC_DEPTH) return UNSAFE_DIAGNOSTIC
+  if (typeof value === 'string') {
+    return sanitizeOracleDiagnostic(value, accessToken, depth) ?? UNSAFE_DIAGNOSTIC
+  }
+  if (Array.isArray(value)) {
+    const sanitized: unknown[] = []
+    for (const item of value) {
+      const result = sanitizeStructuredDiagnosticValue(item, accessToken, depth + 1)
+      if (result === UNSAFE_DIAGNOSTIC) return UNSAFE_DIAGNOSTIC
+      sanitized.push(result)
+    }
+    return sanitized
+  }
+  if (value && typeof value === 'object') {
+    const sanitized: Record<string, unknown> = {}
+    for (const [key, item] of Object.entries(value)) {
+      if (isSensitiveDiagnosticKey(key)) {
+        sanitized[key] = REDACTED_MARKER
+        continue
+      }
+      const result = sanitizeStructuredDiagnosticValue(item, accessToken, depth + 1)
+      if (result === UNSAFE_DIAGNOSTIC) return UNSAFE_DIAGNOSTIC
+      sanitized[key] = result
+    }
+    return sanitized
+  }
+  return value
+}
+
+function sanitizeOracleDiagnostic(message: string, accessToken: string, depth = 0): string | null {
+  const trimmed = message.trim()
+  if (trimmed === REDACTED_MARKER) return trimmed
+  if (!trimmed.includes('{') && !trimmed.includes('[')) {
+    const redacted = redactExactSensitiveValues(trimmed, [accessToken])
+    return containsSensitiveDiagnosticKey(redacted) ? null : redacted
+  }
+  if (depth >= MAX_STRUCTURED_DIAGNOSTIC_DEPTH) return null
+
+  try {
+    const structured = JSON.parse(trimmed)
+    if (!structured || typeof structured !== 'object') return null
+    const sanitized = sanitizeStructuredDiagnosticValue(
+      redactApiKeys(structured),
+      accessToken,
+      depth + 1
+    )
+    if (sanitized === UNSAFE_DIAGNOSTIC) return null
+    return redactExactSensitiveValues(JSON.stringify(sanitized), [accessToken])
+  } catch {
+    // Provider-controlled text that resembles embedded structured data is not
+    // reflected unless the complete diagnostic can be parsed and redacted.
+    return null
+  }
+}
+
 function sanitizeOracleError(body: string, accessToken: string, status: number): string {
   let messages: string[] = []
   try {
-    messages = collectOracleErrorMessages(JSON.parse(body))
+    messages = collectOracleErrorMessages(redactApiKeys(JSON.parse(body)))
   } catch {
     // Non-JSON proxy pages are intentionally not reflected to tool callers.
   }
-  const unique = [...new Set(messages)]
-  const safe = truncate(redactExactSensitiveValues(unique.join(' — '), [accessToken]), 1_000)
+  const unique = [
+    ...new Set(
+      messages
+        .map((message) => sanitizeOracleDiagnostic(message, accessToken))
+        .filter((message): message is string => Boolean(message))
+    ),
+  ]
+  const safe = truncate(unique.join(' — '), 1_000)
   return safe || `Oracle Fusion Financials request failed with HTTP ${status}`
 }
 

apps/sim/lib/internal/oracle-fusion-financials/oracle-fusion-financials.test.ts

@@ -1171,6 +1171,74 @@ describe('Oracle Fusion Financials provider', () => {
     expect(mockSecureFetch).toHaveBeenCalledTimes(3)
   })
 
+  it('recursively redacts credentials from structured Oracle diagnostics', async () => {
+    mockSecureFetch.mockResolvedValueOnce(
+      response(400, {
+        title: 'validation failed',
+        detail: JSON.stringify({
+          context: {
+            client_secret: 'provider-nested-secret-canary',
+            'api key': 'provider-spaced-api-key-canary',
+            ' private key ': 'provider-spaced-private-key-canary',
+            'proxy authorization': 'provider-spaced-proxy-auth-canary',
+            entries: [{ access_token: 'provider-nested-token-canary' }],
+            serialized: JSON.stringify({
+              private_key: 'provider-double-serialized-secret-canary',
+            }),
+          },
+          reason: 'invalid request',
+        }),
+      })
+    )
+
+    const error = await requestOracleFusionJson(AUTH, {
+      path: `${RESOURCE_PATH}/invoices`,
+    }).catch((caught) => caught)
+
+    expect(error).toBeInstanceOf(OracleFusionFinancialsProviderError)
+    expect(error).toMatchObject({ status: 400 })
+    expect((error as Error).message).toContain('validation failed')
+    expect((error as Error).message).toContain('invalid request')
+    expect((error as Error).message).toContain('[REDACTED]')
+    expect((error as Error).message).not.toContain('provider-nested-secret-canary')
+    expect((error as Error).message).not.toContain('provider-spaced-api-key-canary')
+    expect((error as Error).message).not.toContain('provider-spaced-private-key-canary')
+    expect((error as Error).message).not.toContain('provider-spaced-proxy-auth-canary')
+    expect((error as Error).message).not.toContain('provider-nested-token-canary')
+    expect((error as Error).message).not.toContain('provider-double-serialized-secret-canary')
+  })
+
+  it('does not reflect ambiguous structured Oracle diagnostics', async () => {
+    mockSecureFetch.mockResolvedValueOnce(
+      response(400, {
+        detail: 'validation failed {"client_secret":"provider-ambiguous-secret-canary"}',
+      })
+    )
+
+    await expect(
+      requestOracleFusionJson(AUTH, { path: `${RESOURCE_PATH}/invoices` })
+    ).rejects.toMatchObject({
+      status: 400,
+      message: 'Oracle Fusion Financials request failed with HTTP 400',
+    })
+  })
+
+  it('does not reflect credential-shaped Oracle diagnostic fragments', async () => {
+    mockSecureFetch.mockResolvedValueOnce(
+      response(400, {
+        detail: 'api key: "provider-fragment-secret-canary"',
+        message: 'client_secret: "provider-fragment-client-secret-canary"',
+      })
+    )
+
+    await expect(
+      requestOracleFusionJson(AUTH, { path: `${RESOURCE_PATH}/invoices` })
+    ).rejects.toMatchObject({
+      status: 400,
+      message: 'Oracle Fusion Financials request failed with HTTP 400',
+    })
+  })
+
   it('propagates cancellation before a request and while waiting to retry', async () => {
     const preAborted = new AbortController()
     preAborted.abort(new DOMException('cancelled', 'AbortError'))