mirror of
https://github.com/openai/codex.git
synced 2026-11-18 07:00:27 +00:00
Bound exec-server JSON-RPC decoding complexity (#33013)
## Why Compact JSON arrays can expand into millions of heap values during decoding, and duplicate object keys make a message ambiguous. ## What changed - Limit exec-server JSON-RPC messages to 256K JSON values and reject duplicate object keys. - Cap `fs/read_directory` results and retained `process/read` output at 50,000 entries or chunks so locally produced responses remain within the decoder budget. ## Testing Add coverage for all JSON-RPC variants, large scalar payloads, duplicate keys, compact array amplification, and retained process output at the chunk limit. GitOrigin-RevId: e31d1f25ab0a7e2272015c98174fd2b7cdd669d7
This commit is contained in:
1 parent
d7ba5ff955
commit
325cf16194
5 files changed
+380
-5
No files matched your search
@@ -7,10 +7,24 @@ use std::fmt;
|
||||
|
||||
use codex_protocol::protocol::W3cTraceContext;
|
||||
use serde::Deserialize;
|
||||
use serde::Deserializer;
|
||||
use serde::Serialize;
|
||||
use serde::de;
|
||||
use serde::de::DeserializeSeed;
|
||||
use serde::de::MapAccess;
|
||||
use serde::de::SeqAccess;
|
||||
use serde::de::Visitor;
|
||||
use serde_json::Map;
|
||||
use serde_json::Number;
|
||||
use serde_json::Value;
|
||||
|
||||
pub const JSONRPC_VERSION: &str = "2.0";
|
||||
|
||||
// A maximum-size fs/walk response has at most 50,000 entries and needs roughly
|
||||
// 150,000 JSON values. Keep ample headroom for legitimate protocol messages
|
||||
// while preventing compact arrays from expanding into millions of heap values.
|
||||
const MAX_JSONRPC_VALUE_NODES: usize = 256 * 1024;
|
||||
|
||||
#[derive(Debug, Clone, PartialEq, PartialOrd, Ord, Deserialize, Serialize, Hash, Eq)]
|
||||
#[serde(untagged)]
|
||||
pub enum RequestId {
|
||||
@@ -30,7 +44,7 @@ impl fmt::Display for RequestId {
|
||||
pub type Result = serde_json::Value;
|
||||
|
||||
/// Any valid exec-server JSON-RPC object that can be decoded from or encoded onto the wire.
|
||||
#[derive(Debug, Clone, PartialEq, Deserialize, Serialize)]
|
||||
#[derive(Debug, Clone, PartialEq, Serialize)]
|
||||
#[serde(untagged)]
|
||||
pub enum JSONRPCMessage {
|
||||
Request(JSONRPCRequest),
|
||||
@@ -39,6 +53,151 @@ pub enum JSONRPCMessage {
|
||||
Error(JSONRPCError),
|
||||
}
|
||||
|
||||
#[derive(Deserialize)]
|
||||
#[serde(untagged)]
|
||||
enum JSONRPCMessageRepr {
|
||||
Request(JSONRPCRequest),
|
||||
Notification(JSONRPCNotification),
|
||||
Response(JSONRPCResponse),
|
||||
Error(JSONRPCError),
|
||||
}
|
||||
|
||||
impl From<JSONRPCMessageRepr> for JSONRPCMessage {
|
||||
fn from(value: JSONRPCMessageRepr) -> Self {
|
||||
match value {
|
||||
JSONRPCMessageRepr::Request(request) => Self::Request(request),
|
||||
JSONRPCMessageRepr::Notification(notification) => Self::Notification(notification),
|
||||
JSONRPCMessageRepr::Response(response) => Self::Response(response),
|
||||
JSONRPCMessageRepr::Error(error) => Self::Error(error),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl<'de> Deserialize<'de> for JSONRPCMessage {
|
||||
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
|
||||
where
|
||||
D: Deserializer<'de>,
|
||||
{
|
||||
let mut remaining = MAX_JSONRPC_VALUE_NODES;
|
||||
let value = BoundedValueSeed {
|
||||
remaining: &mut remaining,
|
||||
}
|
||||
.deserialize(deserializer)?;
|
||||
JSONRPCMessageRepr::deserialize(value)
|
||||
.map(Self::from)
|
||||
.map_err(de::Error::custom)
|
||||
}
|
||||
}
|
||||
|
||||
struct BoundedValueSeed<'a> {
|
||||
remaining: &'a mut usize,
|
||||
}
|
||||
|
||||
impl<'de> DeserializeSeed<'de> for BoundedValueSeed<'_> {
|
||||
type Value = Value;
|
||||
|
||||
fn deserialize<D>(self, deserializer: D) -> std::result::Result<Self::Value, D::Error>
|
||||
where
|
||||
D: Deserializer<'de>,
|
||||
{
|
||||
let Some(remaining) = self.remaining.checked_sub(1) else {
|
||||
return Err(de::Error::custom(format!(
|
||||
"JSON-RPC message exceeds the limit of {MAX_JSONRPC_VALUE_NODES} JSON values"
|
||||
)));
|
||||
};
|
||||
*self.remaining = remaining;
|
||||
deserializer.deserialize_any(BoundedValueVisitor {
|
||||
remaining: self.remaining,
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
struct BoundedValueVisitor<'a> {
|
||||
remaining: &'a mut usize,
|
||||
}
|
||||
|
||||
impl<'de> Visitor<'de> for BoundedValueVisitor<'_> {
|
||||
type Value = Value;
|
||||
|
||||
fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
|
||||
formatter.write_str("a JSON value within the exec-server complexity limit")
|
||||
}
|
||||
|
||||
fn visit_bool<E>(self, value: bool) -> std::result::Result<Self::Value, E> {
|
||||
Ok(Value::Bool(value))
|
||||
}
|
||||
|
||||
fn visit_i64<E>(self, value: i64) -> std::result::Result<Self::Value, E> {
|
||||
Ok(Value::Number(value.into()))
|
||||
}
|
||||
|
||||
fn visit_u64<E>(self, value: u64) -> std::result::Result<Self::Value, E> {
|
||||
Ok(Value::Number(value.into()))
|
||||
}
|
||||
|
||||
fn visit_f64<E>(self, value: f64) -> std::result::Result<Self::Value, E> {
|
||||
Ok(Number::from_f64(value).map_or(Value::Null, Value::Number))
|
||||
}
|
||||
|
||||
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E> {
|
||||
Ok(Value::String(value.to_string()))
|
||||
}
|
||||
|
||||
fn visit_string<E>(self, value: String) -> std::result::Result<Self::Value, E> {
|
||||
Ok(Value::String(value))
|
||||
}
|
||||
|
||||
fn visit_none<E>(self) -> std::result::Result<Self::Value, E> {
|
||||
Ok(Value::Null)
|
||||
}
|
||||
|
||||
fn visit_some<D>(self, deserializer: D) -> std::result::Result<Self::Value, D::Error>
|
||||
where
|
||||
D: Deserializer<'de>,
|
||||
{
|
||||
BoundedValueSeed {
|
||||
remaining: self.remaining,
|
||||
}
|
||||
.deserialize(deserializer)
|
||||
}
|
||||
|
||||
fn visit_unit<E>(self) -> std::result::Result<Self::Value, E> {
|
||||
Ok(Value::Null)
|
||||
}
|
||||
|
||||
fn visit_seq<A>(self, mut sequence: A) -> std::result::Result<Self::Value, A::Error>
|
||||
where
|
||||
A: SeqAccess<'de>,
|
||||
{
|
||||
let mut values = Vec::new();
|
||||
while let Some(value) = sequence.next_element_seed(BoundedValueSeed {
|
||||
remaining: &mut *self.remaining,
|
||||
})? {
|
||||
values.push(value);
|
||||
}
|
||||
Ok(Value::Array(values))
|
||||
}
|
||||
|
||||
fn visit_map<A>(self, mut object: A) -> std::result::Result<Self::Value, A::Error>
|
||||
where
|
||||
A: MapAccess<'de>,
|
||||
{
|
||||
let mut values = Map::new();
|
||||
while let Some(key) = object.next_key::<String>()? {
|
||||
if values.contains_key(&key) {
|
||||
return Err(de::Error::custom(format!(
|
||||
"duplicate JSON object key `{key}`"
|
||||
)));
|
||||
}
|
||||
let value = object.next_value_seed(BoundedValueSeed {
|
||||
remaining: &mut *self.remaining,
|
||||
})?;
|
||||
values.insert(key, value);
|
||||
}
|
||||
Ok(Value::Object(values))
|
||||
}
|
||||
}
|
||||
|
||||
/// A request that expects a response.
|
||||
#[derive(Debug, Clone, PartialEq, Deserialize, Serialize)]
|
||||
pub struct JSONRPCRequest {
|
||||
@@ -79,3 +238,7 @@ pub struct JSONRPCErrorError {
|
||||
pub data: Option<serde_json::Value>,
|
||||
pub message: String,
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
#[path = "rpc_tests.rs"]
|
||||
mod tests;
|
||||
Reference in new issue
Block a user