Skip to main content

vibe/web_runtime/form_state/
serialize_privacy.rs

1//! Form Serialization (Record, URL Params, RDF 1.2 Turtle, 48-byte `QuinRef`, Provider JSON Scoping),
2//! Four-Boundary Disclosure Filtering, and Zero-Knowledge Field Proofs (`form.*`).
3
4use 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
15/// Handle form serialization, provider namespace scoping, disclosure filtering, and ZK proofs.
16pub(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}