1use std::collections::BTreeMap;
5
6use crate::error::{DiagCode, Diagnostic};
7use crate::span::Span;
8use crate::value::{QuinRef, Value};
9
10use super::lifecycle::build_form_record;
11use super::{
12 extract_i64, extract_record, extract_schema_base, extract_str, fnv1a_64, get_sub_record,
13};
14
15pub(crate) fn call_serialize_privacy(
17 path: &str,
18 args: &[Value],
19 span: Span,
20) -> Result<Option<Value>, Diagnostic> {
21 match path {
22 "form.to_record" => {
23 let form = extract_record(args, 0, "form.to_record(form)", span)?;
24 let values = if form.contains_key("values") {
25 get_sub_record(&form, "values")
26 } else {
27 form
28 };
29 Ok(Some(Value::Record(values)))
30 }
31 "form.to_url_params" => {
32 let form = extract_record(args, 0, "form.to_url_params(form)", span)?;
33 let values = if form.contains_key("values") {
34 get_sub_record(&form, "values")
35 } else {
36 form
37 };
38 let mut pairs = Vec::with_capacity(values.len());
39 for (k, v) in &values {
40 let raw_v = value_to_plain_str(v);
41 pairs.push(format!("{}={}", percent_encode(k), percent_encode(&raw_v)));
42 }
43 Ok(Some(Value::String(pairs.join("&"))))
44 }
45 "form.to_rdf_turtle" => {
46 let form = extract_record(args, 0, "form.to_rdf_turtle(form, subject_iri)", span)?;
47 let subject_iri = extract_str(args, 1, "form.to_rdf_turtle(form, subject_iri)", span)?;
48 let schema_base = extract_schema_base(&form);
49 let values = if form.contains_key("values") {
50 get_sub_record(&form, "values")
51 } else {
52 form
53 };
54
55 let mut out = String::new();
56 for (k, v) in &values {
57 let pred = resolve_predicate_iri(&schema_base, k);
58 let obj = format_turtle_object(v);
59 out.push_str(&format!("<{subject_iri}> <{pred}> {obj} .\n"));
60 }
61 Ok(Some(Value::String(out)))
62 }
63 "form.to_quins" => {
64 let form = extract_record(
65 args,
66 0,
67 "form.to_quins(form, subject_iri, context_iri)",
68 span,
69 )?;
70 let subject_iri =
71 extract_str(args, 1, "form.to_quins(form, subject_iri, context_iri)", span)?;
72 let context_iri =
73 extract_str(args, 2, "form.to_quins(form, subject_iri, context_iri)", span)?;
74 let schema_base = extract_schema_base(&form);
75 let values = if form.contains_key("values") {
76 get_sub_record(&form, "values")
77 } else {
78 form
79 };
80
81 let s = fnv1a_64(subject_iri.as_bytes());
82 let c = fnv1a_64(context_iri.as_bytes());
83 let mut quins = Vec::with_capacity(values.len());
84 for (k, v) in &values {
85 let pred_iri = resolve_predicate_iri(&schema_base, k);
86 let p = fnv1a_64(pred_iri.as_bytes());
87 let o = hash_value_object(v);
88 quins.push(Value::QuinRef(QuinRef::from_quin(s, p, o, c)));
89 }
90 Ok(Some(Value::List(quins)))
91 }
92 "form.from_provider_json" => {
93 let form_id = extract_str(
94 args,
95 0,
96 "form.from_provider_json(form_id, json_record, provider_tld)",
97 span,
98 )?;
99 let json_record = extract_record(
100 args,
101 1,
102 "form.from_provider_json(form_id, json_record, provider_tld)",
103 span,
104 )?;
105 let raw_tld = extract_str(
106 args,
107 2,
108 "form.from_provider_json(form_id, json_record, provider_tld)",
109 span,
110 )?;
111
112 let clean_tld = raw_tld
113 .trim_start_matches("https://")
114 .trim_start_matches("http://")
115 .trim_end_matches('#')
116 .trim_end_matches("/ns")
117 .trim_end_matches('/');
118 let schema_iri = format!("https://{clean_tld}/ns#");
119
120 let mut scoped_fields = BTreeMap::new();
121 for (k, v) in json_record {
122 let scoped_key = if k.starts_with("http://") || k.starts_with("https://") {
123 k
124 } else {
125 format!("{schema_iri}{k}")
126 };
127 scoped_fields.insert(scoped_key, v);
128 }
129
130 let Value::Record(mut form) =
131 build_form_record(form_id, schema_iri, scoped_fields)
132 else {
133 unreachable!()
134 };
135 form.insert(
136 "provider_tld".to_string(),
137 Value::String(clean_tld.to_string()),
138 );
139 Ok(Some(Value::Record(form)))
140 }
141 "form.filter_disclosure" => {
142 let mut form = extract_record(
143 args,
144 0,
145 "form.filter_disclosure(form, policies, requested_boundary)",
146 span,
147 )?;
148 let (policies, boundary) = if args.len() >= 3 {
149 let pol = extract_record(
150 args,
151 1,
152 "form.filter_disclosure(form, policies, requested_boundary)",
153 span,
154 )?;
155 let bnd = extract_str(
156 args,
157 2,
158 "form.filter_disclosure(form, policies, requested_boundary)",
159 span,
160 )?;
161 (pol, bnd)
162 } else {
163 let bnd = extract_str(
164 args,
165 1,
166 "form.filter_disclosure(form, requested_boundary)",
167 span,
168 )?;
169 (get_sub_record(&form, "policies"), bnd)
170 };
171
172 let has_values_wrapper = form.contains_key("values");
173 let mut values = if has_values_wrapper {
174 get_sub_record(&form, "values")
175 } else {
176 form.clone()
177 };
178
179 for (field_id, val) in &mut values {
180 if !is_boundary_allowed(&policies, field_id, &boundary) {
181 *val = Value::DisclosureDenied {
182 capability: format!("disclosure.{boundary}.{field_id}"),
183 reason: "redacted by four-boundary disclosure policy".to_string(),
184 };
185 }
186 }
187
188 if has_values_wrapper {
189 form.insert("values".to_string(), Value::Record(values));
190 Ok(Some(Value::Record(form)))
191 } else {
192 Ok(Some(Value::Record(values)))
193 }
194 }
195 "form.zk_prove_field" => {
196 let mut form = extract_record(
197 args,
198 0,
199 "form.zk_prove_field(form, field_id, kind, lo, hi_opt)",
200 span,
201 )?;
202 let field_id = extract_str(
203 args,
204 1,
205 "form.zk_prove_field(form, field_id, kind, lo, hi_opt)",
206 span,
207 )?;
208 let kind = extract_str(
209 args,
210 2,
211 "form.zk_prove_field(form, field_id, kind, lo, hi_opt)",
212 span,
213 )?;
214 let lo = extract_i64(
215 args,
216 3,
217 "form.zk_prove_field(form, field_id, kind, lo, hi_opt)",
218 span,
219 )?;
220 let hi = args.get(4).and_then(Value::as_i64).unwrap_or(i64::MAX);
221
222 let has_values_wrapper = form.contains_key("values");
223 let mut values = if has_values_wrapper {
224 get_sub_record(&form, "values")
225 } else {
226 form.clone()
227 };
228
229 let raw_val = values
230 .get(&field_id)
231 .and_then(Value::as_i64)
232 .ok_or_else(|| {
233 Diagnostic::new(
234 DiagCode::E100,
235 span,
236 format!("form.zk_prove_field: field '{field_id}' must be an integer"),
237 )
238 })?;
239
240 let verified = match kind.as_str() {
241 "threshold" => raw_val >= lo,
242 "range" => raw_val >= lo && raw_val <= hi,
243 other => {
244 return Err(Diagnostic::new(
245 DiagCode::E100,
246 span,
247 format!("form.zk_prove_field: unsupported proof kind '{other}'"),
248 ))
249 }
250 };
251
252 let commit_input = format!("zk:{kind}:{field_id}:{raw_val}:{lo}:{hi}");
253 let commit_hash = format!("0x{:016x}", fnv1a_64(commit_input.as_bytes()));
254
255 let mut proof = BTreeMap::new();
256 proof.insert("__zk_proof".to_string(), Value::Bool(true));
257 proof.insert("kind".to_string(), Value::String(kind));
258 proof.insert("field_id".to_string(), Value::String(field_id.clone()));
259 proof.insert("verified".to_string(), Value::Bool(verified));
260 proof.insert("commitment_hash".to_string(), Value::String(commit_hash));
261
262 values.insert(field_id, Value::Record(proof));
263 if has_values_wrapper {
264 form.insert("values".to_string(), Value::Record(values));
265 Ok(Some(Value::Record(form)))
266 } else {
267 Ok(Some(Value::Record(values)))
268 }
269 }
270 _ => Ok(None),
271 }
272}
273
274fn resolve_predicate_iri(schema_base: &str, field_key: &str) -> String {
275 if field_key.starts_with("http://") || field_key.starts_with("https://") {
276 field_key.to_string()
277 } else {
278 format!("{schema_base}{field_key}")
279 }
280}
281
282fn hash_value_object(v: &Value) -> u64 {
283 match v {
284 Value::U64(n) => *n,
285 Value::I64(n) => *n as u64,
286 Value::Bool(b) => u64::from(*b),
287 Value::String(s) | Value::Iri(s) => fnv1a_64(s.as_bytes()),
288 other => fnv1a_64(format!("{other}").as_bytes()),
289 }
290}
291
292fn is_boundary_allowed(
293 policies: &BTreeMap<String, Value>,
294 field_id: &str,
295 boundary: &str,
296) -> bool {
297 match policies.get(field_id) {
298 Some(Value::DisclosureBoundary(b)) => match boundary {
299 "publication" => b.publication,
300 "replication" => b.replication,
301 "agency" => b.agency,
302 "exfiltration" => b.exfiltration,
303 _ => false,
304 },
305 Some(Value::Record(rec)) => rec
306 .get(boundary)
307 .and_then(|v| match v {
308 Value::Bool(allowed) => Some(*allowed),
309 _ => None,
310 })
311 .unwrap_or(false),
312 Some(Value::Bool(allowed)) => *allowed,
313 None => true,
314 _ => false,
315 }
316}
317
318fn format_turtle_object(v: &Value) -> String {
319 match v {
320 Value::Iri(s) => format!("<{s}>"),
321 Value::String(s) => {
322 let escaped = s.replace('\\', "\\\\").replace('"', "\\\"");
323 format!("\"{escaped}\"")
324 }
325 Value::Bool(b) => b.to_string(),
326 Value::I64(n) => n.to_string(),
327 Value::U64(n) => n.to_string(),
328 Value::F64(n) => n.to_string(),
329 other => format!("\"{other}\""),
330 }
331}
332
333fn value_to_plain_str(v: &Value) -> String {
334 match v {
335 Value::Null => String::new(),
336 Value::String(s) | Value::Iri(s) => s.clone(),
337 Value::Bool(b) => b.to_string(),
338 Value::I64(n) => n.to_string(),
339 Value::U64(n) => n.to_string(),
340 Value::F64(n) => n.to_string(),
341 other => format!("{other}"),
342 }
343}
344
345fn percent_encode(input: &str) -> String {
346 const HEX: &[u8; 16] = b"0123456789ABCDEF";
347 let mut out = String::with_capacity(input.len());
348 for &b in input.as_bytes() {
349 if b.is_ascii_alphanumeric() || matches!(b, b'-' | b'_' | b'.' | b'~') {
350 out.push(b as char);
351 } else {
352 out.push('%');
353 out.push(HEX[(b >> 4) as usize] as char);
354 out.push(HEX[(b & 0x0F) as usize] as char);
355 }
356 }
357 out
358}