1pub use dive_eval::inputs::{HostAccess, InputRecord, InputRequest, InputResponse, RecordedInputs};
4use serde_json::{Value, json};
5
6#[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
23pub 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}