fix(security): redact invalid Azure authentication credentials

src/beta/realtime/websocket.ts

@@ -1,4 +1,5 @@
 import type { AzureOpenAI } from '../../index';
+import { safeAzureCredentialHeaderValue } from '../../internal/azure';
 import { assertBedrockWebSocketOrigin } from '../../internal/bedrock';
 import { OpenAI } from '../../index';
 import { OpenAIError } from '../../error';
@@ -119,11 +120,12 @@ function createAzureWebSocket(
     throw new Error('Azure OpenAI Realtime requires an API key');
   }
 
+  const credential = safeAzureCredentialHeaderValue(apiKey);
   redactAzureCredentials(url, isBearerToken);
   const socketURL = new URL(url);
   socketURL.searchParams.delete('api-key');
   socketURL.searchParams.delete('Authorization');
-  const headers = isBearerToken ? { Authorization: `Bearer ${apiKey}` } : { 'api-key': apiKey };
+  const headers = isBearerToken ? { Authorization: `Bearer ${credential}` } : { 'api-key': credential };
 
   // @ts-ignore
   return new WebSocket(socketURL.toString(), { protocols, headers });
@@ -186,10 +188,11 @@ export class OpenAIRealtimeWebSocket extends OpenAIRealtimeEmitter {
   ) {
     super();
     const hasProvider = typeof (client as any)?._options?.apiKey === 'function';
+    const apiKey = client?.apiKey;
     const dangerouslyAllowBrowser =
       props.dangerouslyAllowBrowser ??
       (client as any)?._options?.dangerouslyAllowBrowser ??
-      (client?.apiKey?.startsWith('ek_') ? true : null);
+      (typeof apiKey === 'string' && apiKey.startsWith('ek_') ? true : null);
     if (!dangerouslyAllowBrowser && isRunningInBrowserOrBrowserWorker()) {
       throw new OpenAIError(
         "It looks like you're running in a browser-like environment.\n\nThis is disabled by default, as it risks exposing your secret API credentials to attackers.\n\nYou can avoid this error by creating an ephemeral session token:\nhttps://platform.openai.com/docs/api-reference/realtime-sessions\n",

src/beta/realtime/ws.ts

@@ -1,4 +1,5 @@
 import * as WS from 'ws';
+import { safeAzureCredentialHeaderValue, safeAzureWebSocketHeaders } from '../../internal/azure';
 import { assertBedrockWebSocketOrigin } from '../../internal/bedrock';
 import { protectWebSocketOptionsFromCredentialRedirects } from '../../internal/ws';
 import type { AzureOpenAI } from '../../index';
@@ -67,17 +68,22 @@ export class OpenAIRealtimeWS extends OpenAIRealtimeEmitter {
     this.url = buildRealtimeURL(client, props);
     assertTrustedRealtimeURL(client, this.url);
     assertBedrockWebSocketOrigin(client, this.url);
+    const azure = isAzure(client);
     const headers = {
       ...props.options?.headers,
-      ...(isAzure(client) && !props.__resolvedApiKey ? {} : { Authorization: `Bearer ${client.apiKey}` }),
+      ...(azure && !props.__resolvedApiKey
+        ? {}
+        : {
+            Authorization: `Bearer ${azure ? safeAzureCredentialHeaderValue(client.apiKey) : client.apiKey}`,
+          }),
       'OpenAI-Beta': 'realtime=v1',
     };
 
     this.socket = new WS.WebSocket(
       this.url,
       protectWebSocketOptionsFromCredentialRedirects({
         ...props.options,
-        headers,
+        headers: azure ? safeAzureWebSocketHeaders(headers) : headers,
       }),
     );
 

src/client.ts

@@ -251,7 +251,7 @@ import {
 } from './resources/chat/completions/completions';
 import { type Fetch } from './internal/builtin-types';
 import { isRunningInBrowser } from './internal/detect-platform';
-import { HeadersLike, NullableHeaders, buildHeaders } from './internal/headers';
+import { HeadersLike, NullableHeaders, buildHeaders, captureAzureHeaders } from './internal/headers';
 import { configureProvider, type Provider, type ProviderRuntime } from './internal/provider';
 import { FinalRequestOptions, RequestOptions } from './internal/request-options';
 import { readEnv } from './internal/utils/env';
@@ -1777,6 +1777,7 @@ export class OpenAI {
     x509Timeout: number | undefined;
     x509Tenant?: { organization: string | null; project: string | null } | undefined;
   }): Promise<Headers> {
+    const azureRequestHeaders = captureAzureHeaders(this, options);
     let idempotencyHeaders: HeadersLike = {};
     if (this.idempotencyHeader && method !== 'get') {
       if (!options.idempotencyKey) options.idempotencyKey = this.defaultIdempotencyKey();
@@ -1799,10 +1800,15 @@ export class OpenAI {
       },
       this._provider || this.#x509Authentication?.isPlanningRequest()
         ? undefined
-        : await this.authHeaders(options, options.__security ?? { bearerAuth: true }),
+        : azureRequestHeaders
+          ? await azureRequestHeaders.authenticate(
+              this.authHeaders,
+              options.__security ?? { bearerAuth: true },
+            )
+          : await this.authHeaders(options, options.__security ?? { bearerAuth: true }),
       x509Headers?.defaultHeaders ?? this._options.defaultHeaders,
       bodyHeaders,
-      x509Headers?.requestHeaders ?? options.headers,
+      x509Headers?.requestHeaders ?? (azureRequestHeaders ? azureRequestHeaders.headers() : options.headers),
     ]);
 
     if (!this._provider && !this.#x509Authentication?.isPlanningRequest()) {

src/internal/azure.ts

@@ -0,0 +1,84 @@
+/** Rejects invalid HTTP-field bytes without exposing a private Azure credential. */
+export function assertAzureCredentialHeaderValue(value: string): void {
+  for (const character of value) {
+    const code = character.codePointAt(0) ?? 0;
+    if ((code < 0x20 && code !== 0x09) || code === 0x7f || code > 0xff) {
+      throw new TypeError('Azure OpenAI credential contains an invalid HTTP header value.');
+    }
+  }
+}
+
+/** Coerces and validates an Azure credential without exposing errors from caller-defined hooks. */
+export function safeAzureCredentialHeaderValue(value: unknown): string {
+  let credential: string;
+  try {
+    credential = String(value);
+  } catch {
+    throw new TypeError('Azure OpenAI credential contains an invalid HTTP header value.');
+  }
+  assertAzureCredentialHeaderValue(credential);
+  return credential;
+}
+
+/** Identifies the two credential-bearing Azure HTTP header fields. */
+export function isAzureAuthenticationHeader(name: string): boolean {
+  const normalized = name.toLowerCase();
+  return normalized === 'authorization' || normalized === 'api-key';
+}
+
+/**
+ * Collapses case-insensitive WebSocket credential overrides before validating
+ * only the effective values. Callers supply SDK-created plain header records.
+ */
+export function safeAzureWebSocketHeaders<Headers extends Record<string, unknown>>(
+  headers: Headers,
+): Headers {
+  const safeHeaders = new Map<string, unknown>();
+  const authenticationNames = new Map<string, string>();
+
+  for (const [name, value] of Object.entries(headers)) {
+    if (!isAzureAuthenticationHeader(name)) {
+      safeHeaders.set(name, value);
+      continue;
+    }
+
+    const normalized = name.toLowerCase();
+    const previousName = authenticationNames.get(normalized);
+    if (previousName !== undefined) {
+      safeHeaders.delete(previousName);
+      authenticationNames.delete(normalized);
+    }
+    if (value === null || value === undefined) {
+      continue;
+    }
+    safeHeaders.set(name, value);
+    authenticationNames.set(normalized, name);
+  }
+
+  for (const name of authenticationNames.values()) {
+    const value = safeHeaders.get(name);
+    try {
+      if (Array.isArray(value)) {
+        const { length } = value;
+        if (!Number.isSafeInteger(length) || length < 0 || length > 1024) {
+          throw new TypeError('Azure OpenAI credential contains an invalid HTTP header value.');
+        }
+        const snapshot: unknown[] = [];
+        for (let index = 0; index < length; index += 1) {
+          const entry = value[index];
+          if (entry === null || entry === undefined) {
+            snapshot.push(entry);
+            continue;
+          }
+          snapshot.push(safeAzureCredentialHeaderValue(entry));
+        }
+        safeHeaders.set(name, snapshot);
+      } else {
+        safeHeaders.set(name, safeAzureCredentialHeaderValue(value));
+      }
+    } catch {
+      throw new TypeError('Azure OpenAI credential contains an invalid HTTP header value.');
+    }
+  }
+  return Object.fromEntries(safeHeaders) as Headers;
+}