fix(oci): fail closed on encoded diagnostics

Author: BillLeoutsakosvl346

apps/sim/lib/internal/oci/client.server.test.ts

@@ -181,7 +181,7 @@ describe('OCI request client', () => {
       code: 'NotAuthenticated',
       opcRequestId: 'request-401',
     })
-    expect((failure as Error).message).toContain('[redacted]')
+    expect((failure as Error).message).toContain('[REDACTED]')
     expect((failure as Error).message).not.toContain('client-secret-passphrase')
     expect((failure as Error).message).not.toContain('BEGIN PRIVATE KEY')
     expect((failure as Error).message).not.toContain('objectstorage.us-ashburn-1')
@@ -232,12 +232,149 @@ describe('OCI request client', () => {
       maxResponseBytes: 65_536,
     }).catch((error: unknown) => error)
     expect(failure).toBeInstanceOf(OciRequestError)
-    expect((failure as Error).message).toContain('[redacted]')
+    expect((failure as Error).message).toContain('[REDACTED]')
     expect((failure as Error).message).not.toContain('provider-echo')
     expect((failure as Error).message).not.toContain('(request-target)')
     expect((failure as Error).message).not.toContain('tenant/user/fingerprint')
   })
 
+  it('redacts encoded credentials and request URLs echoed by the provider', async () => {
+    const encodedFingerprint = encodeURIComponent(credentials.fingerprint)
+    const requestUrl = `${destination.origin}/n/`
+    const encodedRequestUrl = encodeURIComponent(requestUrl)
+    const escapedPassphrase = 'secret "pass"'
+    const escapedPassphraseEcho = JSON.stringify(escapedPassphrase).slice(1, -1)
+    secureFetchMock.mockResolvedValueOnce(
+      secureResponse({
+        ok: false,
+        status: 401,
+        body: JSON.stringify({
+          code: 'NotAuthenticated',
+          message: `provider echoed ${encodedFingerprint} ${encodedRequestUrl} ${escapedPassphraseEcho}`,
+        }),
+      })
+    )
+    const failure = await sendOciRequest({
+      destination,
+      credentials: { ...credentials, passphrase: escapedPassphrase },
+      method: 'GET',
+      encodedPath: '/n/',
+      timeout: 10_000,
+      maxResponseBytes: 65_536,
+    }).catch((error: unknown) => error)
+    expect((failure as Error).message).not.toContain(encodedFingerprint)
+    expect((failure as Error).message).not.toContain(encodedRequestUrl)
+    expect((failure as Error).message).not.toContain(escapedPassphraseEcho)
+    expect((failure as Error).message).not.toContain(escapedPassphrase)
+  })
+
+  it('redacts a maximum-size passphrase before bounding an encoded diagnostic', async () => {
+    const longPassphrase = ' '.repeat(4096)
+    const encodedPassphrase = new URLSearchParams({ value: longPassphrase })
+      .toString()
+      .slice('value='.length)
+    secureFetchMock.mockResolvedValueOnce(
+      secureResponse({
+        ok: false,
+        status: 401,
+        body: JSON.stringify({
+          code: 'NotAuthenticated',
+          message: `provider echoed ${encodedPassphrase}`,
+        }),
+      })
+    )
+    const failure = await sendOciRequest({
+      destination,
+      credentials: { ...credentials, passphrase: longPassphrase },
+      method: 'GET',
+      encodedPath: '/n/',
+      timeout: 10_000,
+      maxResponseBytes: 65_536,
+    }).catch((error: unknown) => error)
+    expect((failure as Error).message).toContain('[REDACTED]')
+    expect((failure as Error).message).not.toContain('+'.repeat(1024))
+  })
+
+  it.each([
+    encodeURIComponent('-----BEGIN PRIVATE KEY-----\ntruncated'),
+    encodeURIComponent(`${destination.origin}/n/truncated`),
+  ])('fails closed for encoded key or URL prefixes', async (message) => {
+    secureFetchMock.mockResolvedValueOnce(
+      secureResponse({
+        ok: false,
+        status: 401,
+        body: JSON.stringify({ code: 'NotAuthenticated', message }),
+      })
+    )
+    const failure = await sendOciRequest({
+      destination,
+      credentials,
+      method: 'GET',
+      encodedPath: '/n/',
+      timeout: 10_000,
+      maxResponseBytes: 65_536,
+    }).catch((error: unknown) => error)
+    expect((failure as Error).message).toBe('OCI request failed with status 401')
+  })
+
+  it('redacts generic and percent-encoded sensitive JSON fields', async () => {
+    const echoedSecrets = [
+      'access-value',
+      'token-value',
+      'secret-value',
+      'password-value',
+      '(request-target) host x-date',
+    ]
+    secureFetchMock.mockResolvedValueOnce(
+      secureResponse({
+        ok: false,
+        status: 401,
+        body: JSON.stringify({
+          code: 'NotAuthenticated',
+          message: JSON.stringify({
+            access_token: echoedSecrets[0],
+            token: echoedSecrets[1],
+            secret: echoedSecrets[2],
+            'pass%70hrase': echoedSecrets[3],
+            signing_string: echoedSecrets[4],
+          }),
+        }),
+      })
+    )
+    const failure = await sendOciRequest({
+      destination,
+      credentials,
+      method: 'GET',
+      encodedPath: '/n/',
+      timeout: 10_000,
+      maxResponseBytes: 65_536,
+    }).catch((error: unknown) => error)
+    for (const secret of echoedSecrets) expect((failure as Error).message).not.toContain(secret)
+  })
+
+  it.each([
+    '{"authorization":"Signature version=\\"1\\",signature=\\"echoed\\"',
+    JSON.stringify({ level1: { level2: { level3: { authorization: 'echoed' } } } }),
+    JSON.stringify({ 'pass%25252570hrase': 'echoed' }),
+  ])('fails closed for malformed or over-depth structured diagnostics', async (message) => {
+    secureFetchMock.mockResolvedValueOnce(
+      secureResponse({
+        ok: false,
+        status: 401,
+        body: JSON.stringify({ code: 'NotAuthenticated', message }),
+      })
+    )
+    const failure = await sendOciRequest({
+      destination,
+      credentials,
+      method: 'GET',
+      encodedPath: '/n/',
+      timeout: 10_000,
+      maxResponseBytes: 65_536,
+    }).catch((error: unknown) => error)
+    expect((failure as Error).message).toBe('OCI request failed with status 401')
+  })
+
   it.each([
     '//attacker.example/path',
     '/safe//attacker',

apps/sim/lib/internal/oci/client.server.ts

@@ -62,7 +62,8 @@ function validateRequestLimits(timeout: number, maxResponseBytes: number): void
 
 function sensitiveRequestValues(
   credentials: OciSigningCredentials,
-  authorization: string | undefined
+  authorization: string | undefined,
+  requestUrl: string
 ): string[] {
   return [
     credentials.tenancyId,
@@ -71,6 +72,7 @@ function sensitiveRequestValues(
     credentials.privateKey,
     credentials.passphrase ?? '',
     authorization ?? '',
+    requestUrl,
   ].filter(Boolean)
 }
 
@@ -116,7 +118,11 @@ export async function sendOciRequest(params: {
   const opcRequestId = response.headers.get('opc-request-id') ?? undefined
   if (response.ok) return { response, opcRequestId }
 
-  const sensitiveValues = sensitiveRequestValues(params.credentials, signed.headers.authorization)
+  const sensitiveValues = sensitiveRequestValues(
+    params.credentials,
+    signed.headers.authorization,
+    signed.url
+  )
   const body = await response.text()
   const error = parseOciErrorBody(body, sensitiveValues)
   throw new OciRequestError({

apps/sim/lib/internal/oci/errors.ts

@@ -1,65 +1,118 @@
+import {
+  isSensitiveKey,
+  REDACTED_MARKER,
+  redactExactSensitiveValues,
+} from '@/lib/core/security/redaction'
+
 const MAX_OCI_ERROR_FIELD_LENGTH = 1024
-const MAX_OCI_ERROR_INPUT_LENGTH = 8192
+const MAX_OCI_ERROR_INPUT_LENGTH = 65_536
 const MAX_NESTED_JSON_DEPTH = 3
-const SENSITIVE_JSON_FIELDS = new Set([
-  'authorization',
-  'passphrase',
-  'privatekey',
-  'proxyauthorization',
-  'signingstring',
-])
+const OCI_SENSITIVE_JSON_FIELDS = new Set(['signingstring'])
+const ENCODED_DIAGNOSTIC_SENTINELS = ['-----BEGIN', 'https://']
+
+function normalizeJsonDiagnosticKey(key: string): string | undefined {
+  let normalized = key
+  for (let depth = 0; depth < MAX_NESTED_JSON_DEPTH; depth += 1) {
+    if (!normalized.includes('%')) return normalized
+    if (!/%[0-9a-f]{2}/i.test(normalized)) return undefined
+    try {
+      normalized = decodeURIComponent(normalized)
+    } catch {
+      return undefined
+    }
+  }
+  return normalized.includes('%') ? undefined : normalized
+}
+
+function looksLikeStructuredJson(value: string): boolean {
+  const first = value.trimStart()[0]
+  return first === '{' || first === '[' || first === '"'
+}
+
+function isSensitiveOciJsonKey(key: string): boolean {
+  const compactKey = key.replace(/[^a-z]/gi, '').toLowerCase()
+  return OCI_SENSITIVE_JSON_FIELDS.has(compactKey) || isSensitiveKey(key)
+}
+
+function containsEncodedDiagnosticSentinel(value: string): boolean {
+  const lowerValue = value.toLowerCase()
+  return ENCODED_DIAGNOSTIC_SENTINELS.some((sentinel) => {
+    let encoded = sentinel
+    for (let depth = 0; depth < MAX_NESTED_JSON_DEPTH; depth += 1) {
+      encoded = encodeURIComponent(encoded)
+      if (encoded !== sentinel && lowerValue.includes(encoded.toLowerCase())) return true
+    }
+    return false
+  })
+}
 
 function flattenJsonDiagnostic(value: unknown, depth = 0): string | undefined {
-  if (depth > MAX_NESTED_JSON_DEPTH || value === null) return undefined
-  if (typeof value === 'string') return value
+  if (depth > MAX_NESTED_JSON_DEPTH) return undefined
+  if (value === null) return 'null'
+  if (typeof value === 'string') {
+    if (!looksLikeStructuredJson(value)) return value
+    if (depth === MAX_NESTED_JSON_DEPTH) return undefined
+    try {
+      return flattenJsonDiagnostic(JSON.parse(value), depth + 1)
+    } catch {
+      return undefined
+    }
+  }
   if (typeof value === 'number' || typeof value === 'boolean') return String(value)
   if (Array.isArray(value)) {
-    return value
-      .map((entry) => flattenJsonDiagnostic(entry, depth + 1))
-      .filter((entry): entry is string => entry !== undefined)
-      .join(' ')
+    if (depth === MAX_NESTED_JSON_DEPTH) return undefined
+    const flattened = value.map((entry) => flattenJsonDiagnostic(entry, depth + 1))
+    if (flattened.some((entry) => entry === undefined)) return undefined
+    return flattened.join(' ')
   }
   if (typeof value !== 'object') return undefined
-  return Object.entries(value)
-    .map(([key, entry]) => {
-      const normalizedKey = key.replace(/[^a-z]/gi, '').toLowerCase()
-      if (SENSITIVE_JSON_FIELDS.has(normalizedKey)) return `${key}: [redacted]`
-      const flattened = flattenJsonDiagnostic(entry, depth + 1)
-      return flattened === undefined ? undefined : `${key}: ${flattened}`
-    })
-    .filter((entry): entry is string => entry !== undefined)
-    .join(' ')
+  if (depth === MAX_NESTED_JSON_DEPTH) return undefined
+  const flattened = Object.entries(value).map(([key, entry]) => {
+    const normalizedKey = normalizeJsonDiagnosticKey(key)
+    if (normalizedKey === undefined) return undefined
+    if (isSensitiveOciJsonKey(normalizedKey)) return `${key}: ${REDACTED_MARKER}`
+    const nested = flattenJsonDiagnostic(entry, depth + 1)
+    return nested === undefined ? undefined : `${key}: ${nested}`
+  })
+  if (flattened.some((entry) => entry === undefined)) return undefined
+  return flattened.join(' ')
 }
 
-function decodeNestedJsonDiagnostic(value: string): string {
-  let decoded = value.slice(0, MAX_OCI_ERROR_INPUT_LENGTH)
-  for (let depth = 0; depth < MAX_NESTED_JSON_DEPTH; depth += 1) {
-    let parsed: unknown
-    try {
-      parsed = JSON.parse(decoded)
-    } catch {
-      break
-    }
-    const flattened = flattenJsonDiagnostic(parsed)
-    if (flattened === undefined || flattened === decoded) break
-    decoded = flattened.slice(0, MAX_OCI_ERROR_INPUT_LENGTH)
+function decodeNestedJsonDiagnostic(value: string): string | undefined {
+  if (value.length > MAX_OCI_ERROR_INPUT_LENGTH) return undefined
+  if (!looksLikeStructuredJson(value)) return value
+  try {
+    return flattenJsonDiagnostic(JSON.parse(value))
+  } catch {
+    return undefined
   }
-  return decoded
 }
 
 function sanitizeOciErrorField(
   value: unknown,
   sensitiveValues: readonly string[] = []
 ): string | undefined {
   if (typeof value !== 'string') return undefined
-  let sanitized = decodeNestedJsonDiagnostic(value)
+  if (value.length > MAX_OCI_ERROR_INPUT_LENGTH) return undefined
+  if (containsEncodedDiagnosticSentinel(value)) return undefined
+  const decoded = decodeNestedJsonDiagnostic(value)
+  if (decoded === undefined) return undefined
+  const exactValues = sensitiveValues.flatMap((sensitiveValue) => {
+    const jsonEncoded = JSON.stringify(sensitiveValue).slice(1, -1)
+    return jsonEncoded === sensitiveValue ? [sensitiveValue] : [sensitiveValue, jsonEncoded]
+  })
+  let exactRedacted: string
+  try {
+    exactRedacted = redactExactSensitiveValues(decoded, exactValues)
+  } catch {
+    return undefined
+  }
+  const sanitized = exactRedacted
     .replace(/-----BEGIN[\s\S]*/gi, '[redacted-key]')
     .replace(/https?:\/\/[^\s"']+/gi, '[redacted-url]')
-    .replace(/Signature\s+version="1",[^\r\n]*/gi, '[redacted-authorization]')
-  for (const sensitiveValue of sensitiveValues) {
-    if (sensitiveValue.length > 0) sanitized = sanitized.split(sensitiveValue).join('[redacted]')
-  }
-  sanitized = sanitized.replace(/[\u0000-\u001f\u007f]/g, ' ').trim()
+    .replace(/Signature\s+version=\\*"1\\*",[^\r\n]*/gi, '[redacted-authorization]')
+    .replace(/[\u0000-\u001f\u007f]/g, ' ')
+    .trim()
   return sanitized ? sanitized.slice(0, MAX_OCI_ERROR_FIELD_LENGTH) : undefined
 }