Skip to content

Use Claude Code with your ChatGPT, Kimi, Cursor or Grok subscription via a local Anthropic-compatible proxy

Rust

codex: harden websocket transport

Raine Virta9d49b4916be1
diff --git a/src/providers/codex/client.rs b/src/providers/codex/client.rs
index c9de29c..d45caa5 100644
--- a/src/providers/codex/client.rs
+++ b/src/providers/codex/client.rs
@@ -86,64 +86,62 @@ pub fn build_codex_headers(
let mut headers = http::HeaderMap::new();
headers.insert(
http::header::CONTENT_TYPE,
- "application/json".parse().map_err(|_| CodexError {
- status: 500,
- message: "Failed to parse content-type header".to_string(),
- detail: None,
- retry_after: None,
- origin: CodexErrorOrigin::Http,
- })?,
+ header_value("content-type", "application/json")?,
);
headers.insert(
http::header::ACCEPT,
- "text/event-stream".parse().map_err(|_| CodexError {
- status: 500,
- message: "Failed to parse accept header".to_string(),
- detail: None,
- retry_after: None,
- origin: CodexErrorOrigin::Http,
- })?,
+ header_value("accept", "text/event-stream")?,
);
let bearer = format!("Bearer {}", auth.access);
headers.insert(
http::header::AUTHORIZATION,
- bearer.parse().map_err(|_| CodexError {
- status: 500,
- message: "Failed to parse authorization header".to_string(),
- detail: None,
- retry_after: None,
- origin: CodexErrorOrigin::Http,
- })?,
+ header_value("authorization", &bearer)?,
);
let originator = config::codex_originator(ORIGINATOR);
+ headers.insert("originator", header_value("originator", &originator)?);
headers.insert(
- "originator",
- originator.parse().map_err(|_| CodexError {
- status: 500,
- message: "Failed to parse originator header".to_string(),
- detail: None,
- retry_after: None,
- origin: CodexErrorOrigin::Http,
- })?,
+ "openai-beta",
+ header_value("openai-beta", "responses=experimental")?,
);
- headers.insert("openai-beta", "responses=experimental".parse().unwrap());
if let Some(ref account_id) = auth.account_id {
- headers.insert("ChatGPT-Account-Id", account_id.parse().unwrap());
+ headers.insert(
+ "ChatGPT-Account-Id",
+ header_value("ChatGPT-Account-Id", account_id)?,
+ );
}
if let Some(ref session_id) = ctx.session_id {
- headers.insert("session_id", session_id.parse().unwrap());
- headers.insert("x-client-request-id", session_id.parse().unwrap());
+ headers.insert("session_id", header_value("session_id", session_id)?);
+ headers.insert(
+ "x-client-request-id",
+ header_value("x-client-request-id", session_id)?,
+ );
let window_id = format!("{session_id}:0");
- headers.insert("x-codex-window-id", window_id.parse().unwrap());
+ headers.insert(
+ "x-codex-window-id",
+ header_value("x-codex-window-id", &window_id)?,
+ );
}
let user_agent =
config::codex_user_agent(&format!("claude-code-proxy/{}", env!("CARGO_PKG_VERSION")));
if !user_agent.is_empty() {
- headers.insert(http::header::USER_AGENT, user_agent.parse().unwrap());
+ headers.insert(
+ http::header::USER_AGENT,
+ header_value("user-agent", &user_agent)?,
+ );
}
Ok(headers)
}
+fn header_value(name: &str, value: &str) -> Result<http::HeaderValue, CodexError> {
+ http::HeaderValue::from_str(value).map_err(|e| CodexError {
+ status: 500,
+ message: format!("Failed to parse {name} header"),
+ detail: Some(e.to_string()),
+ retry_after: None,
+ origin: CodexErrorOrigin::Http,
+ })
+}
+
// ---------------------------------------------------------------------------
// WebSocket request shaping
// ---------------------------------------------------------------------------
@@ -353,25 +351,35 @@ impl CodexHttpClient {
}
};
- match result {
- Ok(response) if response.status == 401 && transport_attempt == 0 => {
- // First 401: try refresh
- match self.auth_manager.force_refresh() {
- Ok(new_auth) => {
- auth = new_auth;
- continue;
- }
- Err(e) => {
- return Err(CodexError {
- status: 401,
- message: "Unauthorized".to_string(),
- detail: Some(e.to_string()),
- retry_after: None,
- origin: CodexErrorOrigin::Http,
- });
- }
+ if should_refresh_after_unauthorized(&result, transport_attempt) {
+ match self.auth_manager.force_refresh() {
+ Ok(new_auth) => {
+ auth = new_auth;
+ continue;
+ }
+ Err(e) => {
+ return Err(CodexError {
+ status: 401,
+ message: "Unauthorized".to_string(),
+ detail: Some(e.to_string()),
+ retry_after: None,
+ origin: CodexErrorOrigin::Http,
+ });
}
}
+ }
+
+ match result {
+ Ok(response) if response.status == 401 => {
+ let detail = String::from_utf8_lossy(&response.body).to_string();
+ return Err(CodexError {
+ status: 401,
+ message: "Unauthorized".to_string(),
+ detail: Some(detail),
+ retry_after: None,
+ origin: CodexErrorOrigin::Http,
+ });
+ }
Ok(response) if response.status == 403 => {
let detail = String::from_utf8_lossy(&response.body).to_string();
return Err(CodexError {
@@ -690,6 +698,19 @@ fn is_retryable_reqwest_error(err: &reqwest::Error) -> bool {
|| msg.contains("epipe")
}
+fn should_refresh_after_unauthorized(
+ result: &Result<CodexResponse, CodexError>,
+ transport_attempt: u32,
+) -> bool {
+ if transport_attempt != 0 {
+ return false;
+ }
+ match result {
+ Ok(response) => response.status == 401,
+ Err(err) => err.status == 401,
+ }
+}
+
fn websocket_pool_key<'a>(
ctx: &'a RequestContext,
continuation: Option<&super::continuation::ContinuationCandidate>,
@@ -772,6 +793,26 @@ mod tests {
assert!(headers.get("x-client-request-id").is_none());
}
+ #[test]
+ fn codex_headers_return_error_for_invalid_session_header() {
+ let auth = StoredAuth {
+ access: "tok".into(),
+ refresh: String::new(),
+ account_id: None,
+ expires: u64::MAX,
+ };
+ let ctx = RequestContext {
+ req_id: "r".into(),
+ session_id: Some("bad\nsession".into()),
+ session_seq: None,
+ provider: "codex".into(),
+ traffic: None,
+ };
+ let err = build_codex_headers(&auth, &ctx).unwrap_err();
+ assert_eq!(err.status, 500);
+ assert!(err.message.contains("session_id"));
+ }
+
#[test]
fn build_websocket_request_removes_stream() {
let input = vec![
@@ -910,4 +951,35 @@ mod tests {
let display = format!("{err}");
assert!(display.contains("connection reset"));
}
+
+ #[test]
+ fn unauthorized_retry_check_covers_http_and_websocket_results() {
+ let http_unauthorized = Ok(CodexResponse {
+ body: Vec::new(),
+ status: 401,
+ headers: Vec::new(),
+ });
+ let websocket_unauthorized = Err(CodexError {
+ status: 401,
+ message: "WebSocket connect error".to_string(),
+ detail: None,
+ retry_after: None,
+ origin: CodexErrorOrigin::WebSocket,
+ });
+ let forbidden = Err(CodexError {
+ status: 403,
+ message: "Forbidden".to_string(),
+ detail: None,
+ retry_after: None,
+ origin: CodexErrorOrigin::WebSocket,
+ });
+
+ assert!(should_refresh_after_unauthorized(&http_unauthorized, 0));
+ assert!(should_refresh_after_unauthorized(
+ &websocket_unauthorized,
+ 0
+ ));
+ assert!(!should_refresh_after_unauthorized(&forbidden, 0));
+ assert!(!should_refresh_after_unauthorized(&http_unauthorized, 1));
+ }
}
diff --git a/src/providers/codex/websocket.rs b/src/providers/codex/websocket.rs
index 12d3324..ce2a68a 100644
--- a/src/providers/codex/websocket.rs
+++ b/src/providers/codex/websocket.rs
@@ -303,22 +303,28 @@ pub async fn codex_websocket_request(
} else {
// Connection is alive, send the request through it
let ws_msg = Message::Text(body_json.clone());
- ws_guard.send(ws_msg).await.map_err(|e| CodexError {
- status: 0,
- message: format!("WebSocket send error: {e}"),
- detail: None,
- retry_after: None,
- origin: CodexErrorOrigin::WebSocket,
+ ws_guard.send(ws_msg).await.map_err(|e| {
+ if let Some(key) = pool_key {
+ invalidate_codex_websocket_pool_key(key);
+ }
+ CodexError {
+ status: 0,
+ message: format!("WebSocket send error: {e}"),
+ detail: None,
+ retry_after: None,
+ origin: CodexErrorOrigin::WebSocket,
+ }
})?;
// Collect events
let (sse_body, terminal_event) =
collect_ws_events(&mut ws_guard, idle_timeout_ms, pool_key, traffic).await?;
+ let Some(terminal_event) = terminal_event else {
+ return Err(missing_terminal_error());
+ };
// Handle previous response missing
- if let Some(terminal) = &terminal_event
- && is_previous_response_missing(&terminal.payload)
- {
+ if is_previous_response_missing(&terminal_event.payload) {
return Err(CodexError {
status: 0,
message: "Previous response not found".to_string(),
@@ -329,12 +335,8 @@ pub async fn codex_websocket_request(
}
// Extract status from error events
- let status = if let Some(terminal) = &terminal_event {
- if terminal.event_type == "error" {
- extract_status_from_error(&terminal.payload).unwrap_or(500)
- } else {
- 200
- }
+ let status = if terminal_event.event_type == "error" {
+ extract_status_from_error(&terminal_event.payload).unwrap_or(500)
} else {
200
};
@@ -375,10 +377,11 @@ pub async fn codex_websocket_request(
let (sse_body, terminal_event) =
collect_ws_events(&mut ws_guard, idle_timeout_ms, pool_key, traffic).await?;
+ let Some(terminal_event) = terminal_event else {
+ return Err(missing_terminal_error());
+ };
- if let Some(terminal) = &terminal_event
- && is_previous_response_missing(&terminal.payload)
- {
+ if is_previous_response_missing(&terminal_event.payload) {
if let Some(key) = pool_key {
invalidate_codex_websocket_pool_key(key);
}
@@ -393,21 +396,14 @@ pub async fn codex_websocket_request(
// Pool the connection if we have a key and it was successful
if let Some(key) = pool_key {
- let should_pool = terminal_event
- .as_ref()
- .map(|t| t.event_type == "response.completed")
- .unwrap_or(false);
+ let should_pool = terminal_event.event_type == "response.completed";
if should_pool {
pool_insert(key.to_string(), entry.clone());
}
}
- let status = if let Some(terminal) = &terminal_event {
- if terminal.event_type == "error" {
- extract_status_from_error(&terminal.payload).unwrap_or(500)
- } else {
- 200
- }
+ let status = if terminal_event.event_type == "error" {
+ extract_status_from_error(&terminal_event.payload).unwrap_or(500)
} else {
200
};
@@ -426,6 +422,16 @@ pub async fn codex_websocket_request(
}
}
+fn missing_terminal_error() -> CodexError {
+ CodexError {
+ status: 0,
+ message: "WebSocket connection closed before terminal Codex response event".to_string(),
+ detail: None,
+ retry_after: None,
+ origin: CodexErrorOrigin::WebSocket,
+ }
+}
+
fn write_websocket_metadata_capture(
traffic: &TrafficCapture,
ws_url: &str,
@@ -496,13 +502,11 @@ async fn connect_with_timeout(
CodexError,
> {
// Build an http::Request with the given headers for the WebSocket upgrade
+ let host = websocket_host_header(url);
let mut req_builder = http::Request::builder()
.uri(url)
.method("GET")
- .header(
- "Host",
- url::Url::parse(url).map_or("".to_string(), |u| u.host_str().unwrap_or("").to_string()),
- )
+ .header("Host", host)
.header("Connection", "Upgrade")
.header("Upgrade", "websocket")
.header("Sec-WebSocket-Version", "13")
@@ -565,6 +569,13 @@ async fn connect_with_timeout(
})
}
+fn websocket_host_header(url: &str) -> String {
+ let Ok(parsed) = url::Url::parse(url) else {
+ return String::new();
+ };
+ parsed[url::Position::BeforeHost..url::Position::AfterPort].to_string()
+}
+
// ---------------------------------------------------------------------------
// Event collection
// ---------------------------------------------------------------------------
@@ -642,6 +653,9 @@ async fn collect_ws_events(
}
Some(Ok(Message::Binary(_))) => {
// Reject binary frames
+ if let Some(key) = pool_key {
+ invalidate_codex_websocket_pool_key(key);
+ }
return Err(CodexError {
status: 0,
message: "WebSocket binary frames not supported".to_string(),
@@ -745,6 +759,19 @@ mod tests {
assert!(to_websocket_url("ftp://example.test/codex").is_err());
}
+ #[test]
+ fn websocket_host_header_preserves_explicit_port() {
+ assert_eq!(
+ websocket_host_header("wss://chatgpt.com/backend-api/codex/responses"),
+ "chatgpt.com"
+ );
+ assert_eq!(
+ websocket_host_header("ws://127.0.0.1:4141/backend-api/codex/responses"),
+ "127.0.0.1:4141"
+ );
+ assert_eq!(websocket_host_header("ws://[::1]:4141/path"), "[::1]:4141");
+ }
+
#[test]
fn websocket_headers_rewrite_beta() {
let mut headers = http::HeaderMap::new();
@@ -839,6 +866,95 @@ mod tests {
assert!(!WS_POOL.lock().unwrap().contains_key("test-session"));
}
+ #[tokio::test]
+ async fn websocket_connect_401_is_statusful_auth_error() {
+ use tokio::io::{AsyncReadExt, AsyncWriteExt};
+ use tokio::net::TcpListener;
+
+ let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
+ let addr = listener.local_addr().unwrap();
+ tokio::spawn(async move {
+ let (mut socket, _) = listener.accept().await.unwrap();
+ let mut buf = [0_u8; 2048];
+ let _ = socket.read(&mut buf).await;
+ socket
+ .write_all(b"HTTP/1.1 401 Unauthorized\r\nContent-Length: 0\r\n\r\n")
+ .await
+ .unwrap();
+ });
+
+ let err = match connect_with_timeout(
+ &format!("ws://{addr}/backend-api/codex/responses"),
+ &HeaderMap::new(),
+ 1_000,
+ )
+ .await
+ {
+ Ok(_) => panic!("expected unauthorized websocket handshake to fail"),
+ Err(err) => err,
+ };
+
+ assert_eq!(err.status, 401);
+ assert_eq!(err.detail, None);
+ assert_eq!(err.origin, CodexErrorOrigin::WebSocket);
+ }
+
+ #[tokio::test]
+ async fn binary_frame_invalidates_pool_key() {
+ clear_codex_websocket_pool_for_tests();
+ let pooled_stream = create_dummy_stream_async().await;
+ {
+ let mut guard = WS_POOL.lock().unwrap();
+ guard.insert(
+ "binary-session".to_string(),
+ Arc::new(PoolEntry {
+ ws: AsyncMutex::new(pooled_stream),
+ created_at: now_ms(),
+ }),
+ );
+ }
+
+ let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
+ let addr = listener.local_addr().unwrap();
+ tokio::spawn(async move {
+ let (stream, _) = listener.accept().await.unwrap();
+ let mut ws = tokio_tungstenite::accept_async(stream).await.unwrap();
+ ws.send(Message::Binary(vec![1, 2, 3])).await.unwrap();
+ });
+
+ let (mut ws, _) = tokio_tungstenite::connect_async(format!("ws://{addr}/"))
+ .await
+ .unwrap();
+ let err = match collect_ws_events(&mut ws, 1_000, Some("binary-session"), None).await {
+ Ok(_) => panic!("expected binary frame to fail"),
+ Err(err) => err,
+ };
+
+ assert!(err.message.contains("binary frames"));
+ assert!(!WS_POOL.lock().unwrap().contains_key("binary-session"));
+ }
+
+ async fn create_dummy_stream_async() -> WebSocketStream<MaybeTlsStream<TcpStream>> {
+ use tokio::net::TcpListener;
+
+ let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
+ let addr = listener.local_addr().unwrap();
+ tokio::spawn(async move {
+ let (socket, _) = listener.accept().await.unwrap();
+ let _ = tokio_tungstenite::accept_async(socket).await;
+ futures_util::future::pending::<()>().await;
+ });
+ let url = format!("ws://{addr}/");
+ let (ws, _) = tokio::time::timeout(
+ Duration::from_millis(1000),
+ tokio_tungstenite::connect_async(&url),
+ )
+ .await
+ .unwrap()
+ .unwrap();
+ ws
+ }
+
fn create_dummy_stream() -> WebSocketStream<MaybeTlsStream<TcpStream>> {
// Use a connected TcpStream pair with connect_async which returns
// WebSocketStream<MaybeTlsStream<TcpStream>>