use crate::{PlanError, PlanErrorCode, RefactorPlan, RefactorPlanLimits};
use serde::de::{DeserializeSeed, MapAccess, SeqAccess, Visitor};
use std::{collections::BTreeSet, fmt};
pub fn parse_refactor_plan(
bytes: &[u8],
limits: RefactorPlanLimits,
) -> Result<RefactorPlan, PlanError> {
limits.validate()?;
let byte_limit = parse_byte_limit(limits);
if bytes.len() > byte_limit {
return Err(PlanError::new(
PlanErrorCode::PlanTooLarge,
format!("serialized plan exceeds the {byte_limit}-byte parse limit"),
));
}
let mut budget = ParseBudget {
nodes: 0,
max_nodes: parse_node_limit(limits),
max_depth: limits.max_extension_depth.saturating_add(16),
max_key_bytes: limits.max_path_bytes,
};
let mut deserializer = serde_json::Deserializer::from_slice(bytes);
let value = CheckedValueSeed {
budget: &mut budget,
depth: 1,
}
.deserialize(&mut deserializer)
.map_err(|error| parse_error(&error))?;
deserializer.end().map_err(|error| parse_error(&error))?;
let plan = serde_json::from_value(value).map_err(|error| parse_error(&error))?;
crate::validate_consumer_plan(&plan, limits)?;
Ok(plan)
}
fn parse_byte_limit(limits: RefactorPlanLimits) -> usize {
limits
.max_total_create_bytes
.saturating_add(limits.max_total_text_bytes)
.saturating_add(limits.max_extension_bytes)
.saturating_add(limits.max_evidence_text_bytes)
.saturating_add(limits.max_paths.saturating_mul(limits.max_path_bytes))
.saturating_add(1024 * 1024)
}
fn parse_node_limit(limits: RefactorPlanLimits) -> usize {
limits
.max_extension_nodes
.saturating_add(limits.max_operations.saturating_mul(16))
.saturating_add(limits.max_total_edits.saturating_mul(16))
.saturating_add(limits.max_evidence_entries.saturating_mul(16))
.saturating_add(64)
}
struct ParseBudget {
nodes: usize,
max_nodes: usize,
max_depth: usize,
max_key_bytes: usize,
}
struct CheckedValueSeed<'a> {
budget: &'a mut ParseBudget,
depth: usize,
}
impl<'de> DeserializeSeed<'de> for CheckedValueSeed<'_> {
type Value = serde_json::Value;
fn deserialize<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
where
D: serde::Deserializer<'de>,
{
if self.depth > self.budget.max_depth {
return Err(serde::de::Error::custom(
"JSON nesting exceeds parse depth limit",
));
}
if self.budget.nodes >= self.budget.max_nodes {
return Err(serde::de::Error::custom(
"JSON value count exceeds parse node limit",
));
}
self.budget.nodes += 1;
deserializer.deserialize_any(CheckedValueVisitor {
budget: self.budget,
depth: self.depth,
})
}
}
struct CheckedValueVisitor<'a> {
budget: &'a mut ParseBudget,
depth: usize,
}
impl<'de> Visitor<'de> for CheckedValueVisitor<'_> {
type Value = serde_json::Value;
fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
formatter.write_str("a duplicate-free JSON value")
}
fn visit_bool<E>(self, value: bool) -> Result<Self::Value, E> {
Ok(serde_json::Value::Bool(value))
}
fn visit_i64<E>(self, value: i64) -> Result<Self::Value, E> {
Ok(serde_json::Value::Number(value.into()))
}
fn visit_u64<E>(self, value: u64) -> Result<Self::Value, E> {
Ok(serde_json::Value::Number(value.into()))
}
fn visit_f64<E>(self, value: f64) -> Result<Self::Value, E>
where
E: serde::de::Error,
{
serde_json::Number::from_f64(value)
.map(serde_json::Value::Number)
.ok_or_else(|| E::custom("non-finite JSON number"))
}
fn visit_str<E>(self, value: &str) -> Result<Self::Value, E> {
Ok(serde_json::Value::String(value.to_owned()))
}
fn visit_string<E>(self, value: String) -> Result<Self::Value, E> {
Ok(serde_json::Value::String(value))
}
fn visit_none<E>(self) -> Result<Self::Value, E> {
Ok(serde_json::Value::Null)
}
fn visit_unit<E>(self) -> Result<Self::Value, E> {
Ok(serde_json::Value::Null)
}
fn visit_seq<A>(self, mut sequence: A) -> Result<Self::Value, A::Error>
where
A: SeqAccess<'de>,
{
let mut values = Vec::with_capacity(sequence.size_hint().unwrap_or(0).min(1024));
while let Some(value) = sequence.next_element_seed(CheckedValueSeed {
budget: self.budget,
depth: self.depth + 1,
})? {
values.push(value);
}
Ok(serde_json::Value::Array(values))
}
fn visit_map<A>(self, mut object: A) -> Result<Self::Value, A::Error>
where
A: MapAccess<'de>,
{
let mut values = serde_json::Map::new();
let mut keys = BTreeSet::new();
while let Some(key) = object.next_key_seed(BoundedKeySeed {
max_bytes: self.budget.max_key_bytes,
})? {
if !keys.insert(key.clone()) {
return Err(serde::de::Error::custom("duplicate JSON object member"));
}
let value = object.next_value_seed(CheckedValueSeed {
budget: self.budget,
depth: self.depth + 1,
})?;
values.insert(key, value);
}
Ok(serde_json::Value::Object(values))
}
}
struct BoundedKeySeed {
max_bytes: usize,
}
impl<'de> DeserializeSeed<'de> for BoundedKeySeed {
type Value = String;
fn deserialize<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
where
D: serde::Deserializer<'de>,
{
deserializer.deserialize_str(BoundedKeyVisitor {
max_bytes: self.max_bytes,
})
}
}
struct BoundedKeyVisitor {
max_bytes: usize,
}
impl Visitor<'_> for BoundedKeyVisitor {
type Value = String;
fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
formatter.write_str("a bounded JSON object member name")
}
fn visit_borrowed_str<E>(self, value: &str) -> Result<Self::Value, E>
where
E: serde::de::Error,
{
self.check(value)
}
fn visit_str<E>(self, value: &str) -> Result<Self::Value, E>
where
E: serde::de::Error,
{
self.check(value)
}
fn visit_string<E>(self, value: String) -> Result<Self::Value, E>
where
E: serde::de::Error,
{
if value.len() > self.max_bytes {
return Err(E::custom("JSON object member name exceeds byte limit"));
}
Ok(value)
}
}
impl BoundedKeyVisitor {
fn check<E>(self, value: &str) -> Result<String, E>
where
E: serde::de::Error,
{
if value.len() > self.max_bytes {
return Err(E::custom("JSON object member name exceeds byte limit"));
}
Ok(value.to_owned())
}
}
fn parse_error(error: &serde_json::Error) -> PlanError {
PlanError::new(
PlanErrorCode::EvidenceMalformed,
format!("could not parse refactor plan: {error}"),
)
}
#[cfg(test)]
mod tests {
use super::parse_refactor_plan;
use crate::RefactorPlanLimits;
#[test]
fn rejects_duplicate_members_at_any_depth() {
for source in [
br#"{"schemaVersion":"a","schemaVersion":"b"}"#.as_slice(),
br#"{"outer":{"same":1,"same":2}}"#.as_slice(),
br#"[{"same":1,"same":2}]"#.as_slice(),
] {
assert!(parse_refactor_plan(source, RefactorPlanLimits::default()).is_err());
}
}
}