Skip to main content

dive_api/
host_inputs.rs

1//! The optional report context for explicit external input assumptions.
2
3pub use dive_eval::inputs::{HostAccess, InputRecord, InputRequest, InputResponse, RecordedInputs};
4use serde_json::{Value, json};
5
6/// Encodes external assumptions in the existing report envelope. No trace
7/// version or past-host authenticity claim is introduced.
8#[must_use]
9pub(crate) fn inputs_json(inputs: &RecordedInputs) -> Value {
10    json!({
11        "scope": "source-binding",
12        "assumption": "recorded external values; past host truth is not independently proven",
13        "grants": inputs.grants.names(),
14        "limits": { "records": dive_eval::inputs::MAX_INPUT_RECORDS, "utf8_bytes": dive_eval::inputs::MAX_INPUT_BYTES, "environment_entries": dive_eval::inputs::MAX_ENV_ENTRIES },
15        "records": inputs.records.iter().map(|record| match (&record.request, &record.response) {
16            (InputRequest::Environment, InputResponse::Environment(entries)) => json!({ "operation":"IOUtils!IOEnv", "environment":entries }),
17            (InputRequest::TextFile(path), InputResponse::Text(text)) => json!({ "operation":"IOUtils!Deserialize", "path":path, "text":text }),
18            _ => json!({ "operation":"invalid-input-kind" }),
19        }).collect::<Vec<_>>()
20    })
21}
22
23/// Reads explicit external assumptions from a schema-3 check report, without
24/// host access. Supply the result to [`crate::trace::TraceOptions::inputs`].
25/// The source binder must independently demand every record in order.
26///
27/// # Errors
28/// An unsupported report envelope, malformed records or input bounds.
29pub fn inputs_from_report(report: &Value) -> Result<RecordedInputs, crate::ApiError> {
30    let invalid = || crate::ApiError::Rejected {
31        message: "DIVE-A0110: malformed external input report context".into(),
32    };
33    if report["schema_version"].as_u64() != Some(u64::from(crate::REPORT_SCHEMA_VERSION))
34        || report["command"].as_str() != Some("check")
35    {
36        return Err(invalid());
37    }
38    let context = &report["external_inputs"];
39    if context["scope"].as_str() != Some("source-binding") {
40        return Err(invalid());
41    }
42    let categories = context["grants"].as_array().ok_or_else(invalid)?;
43    if categories.len() > 3 {
44        return Err(invalid());
45    }
46    let names = categories
47        .iter()
48        .map(|name| name.as_str().ok_or_else(invalid))
49        .collect::<Result<Vec<_>, _>>()?;
50    let grants = if names.is_empty() {
51        HostAccess::NONE
52    } else {
53        HostAccess::parse(&names.join(",")).map_err(|_| invalid())?
54    };
55    let records = context["records"].as_array().ok_or_else(invalid)?;
56    if records.len() > dive_eval::inputs::MAX_INPUT_RECORDS {
57        return Err(invalid());
58    }
59    let mut bytes = 0usize;
60    for record in records {
61        let additional = match record["operation"].as_str() {
62            Some("IOUtils!IOEnv") => {
63                let entries = record["environment"].as_object().ok_or_else(invalid)?;
64                if entries.len() > dive_eval::inputs::MAX_ENV_ENTRIES {
65                    return Err(invalid());
66                }
67                entries.iter().try_fold(0usize, |n, (name, value)| {
68                    Ok::<_, crate::ApiError>(
69                        n.saturating_add(name.len())
70                            .saturating_add(value.as_str().ok_or_else(invalid)?.len()),
71                    )
72                })?
73            }
74            Some("IOUtils!Deserialize") => record["path"]
75                .as_str()
76                .ok_or_else(invalid)?
77                .len()
78                .saturating_add(record["text"].as_str().ok_or_else(invalid)?.len()),
79            _ => return Err(invalid()),
80        };
81        bytes = bytes.saturating_add(additional);
82        if bytes > dive_eval::inputs::MAX_INPUT_BYTES {
83            return Err(invalid());
84        }
85    }
86    let mut inputs = RecordedInputs {
87        grants,
88        records: Vec::with_capacity(records.len()),
89    };
90    for record in records {
91        let (request, response) = match record["operation"].as_str() {
92            Some("IOUtils!IOEnv") => {
93                let entries = record["environment"].as_object().ok_or_else(invalid)?;
94                let entries = entries
95                    .iter()
96                    .map(|(key, value)| {
97                        Ok((key.clone(), value.as_str().ok_or_else(invalid)?.to_owned()))
98                    })
99                    .collect::<Result<_, crate::ApiError>>()?;
100                (
101                    InputRequest::Environment,
102                    InputResponse::Environment(entries),
103                )
104            }
105            Some("IOUtils!Deserialize") => (
106                InputRequest::TextFile(record["path"].as_str().ok_or_else(invalid)?.to_owned()),
107                InputResponse::Text(record["text"].as_str().ok_or_else(invalid)?.to_owned()),
108            ),
109            _ => return Err(invalid()),
110        };
111        inputs.records.push(InputRecord { request, response });
112    }
113    inputs
114        .validate()
115        .map_err(|error| crate::ApiError::Rejected {
116            message: format!("DIVE-A0110: {}", error.message),
117        })?;
118    Ok(inputs)
119}