1use crate::sqlite::StoreSql;
13use crate::store_call::StoreCall;
14use crate::write_encoding::{decoded, encoded};
15use crate::write_schema::WriteSchema;
16use crate::DbError;
17use coven_crypto::AuthorshipHasher;
18use coven_format::authorship::{CellKind, KeptLeaf, Leaf, Multiproof, WriteEvidence};
19use coven_format::merge_fields;
20use coven_format::write::WriteDisposition;
21use coven_format::write_stream::WriteHeaderFrame;
22use coven_foundation::id_source::{KeyId, MemberId};
23use coven_merge::{Audience, ColumnValue, RowId, WriteId};
24use sqlive::rusqlite::params;
25use std::collections::{BTreeMap, BTreeSet};
26
27pub trait Authorship: Send + Sync {
29 fn header(&self, evidence: &WriteEvidence) -> Result<WriteHeaderFrame, DbError>;
33
34 fn hasher(&self, audience: &Audience, key: KeyId) -> Result<AuthorshipHasher, DbError>;
36}
37
38#[derive(Clone, Debug, PartialEq, Eq)]
41pub struct HeaderEvidence {
42 pub prefix: Vec<u8>,
44 pub header: Vec<u8>,
46 pub roots: Vec<[u8; 32]>,
48 pub signature: [u8; coven_crypto::SIGNATURE_LEN],
50}
51
52fn hash_bytes(hashes: &[[u8; 32]]) -> Vec<u8> {
55 hashes.iter().flatten().copied().collect()
56}
57
58fn hash_list(bytes: &[u8]) -> Result<Vec<[u8; 32]>, DbError> {
61 let (hashes, rest) = bytes.as_chunks::<32>();
62 if !rest.is_empty() {
63 return Err(DbError::DamagedDatabase);
64 }
65 Ok(hashes.to_vec())
66}
67
68pub(crate) fn retain_header(
69 db: &StoreSql,
70 write: WriteId,
71 evidence: &HeaderEvidence,
72) -> Result<(), DbError> {
73 let roots = hash_bytes(&evidence.roots);
74 db.execute(
75 "INSERT INTO _coven_write_evidence(write_id,prefix,header,roots,signature) VALUES(?1,?2,?3,?4,?5) ON CONFLICT(write_id) DO NOTHING",
76 params![
77 encoded(merge_fields::encode_write_id(&write))?,
78 evidence.prefix,
79 evidence.header,
80 roots,
81 evidence.signature.as_slice()
82 ],
83 )?;
84 Ok(())
85}
86
87fn header(db: &StoreSql, write: WriteId) -> Result<Option<HeaderEvidence>, DbError> {
90 let damaged = |column| {
91 crate::write_encoding::decode_failure(
92 column,
93 sqlive::rusqlite::types::Type::Blob,
94 DbError::DamagedDatabase,
95 )
96 };
97 Ok(db
98 .query(
99 "SELECT prefix,header,roots,signature FROM _coven_write_evidence WHERE write_id=?1",
100 [encoded(merge_fields::encode_write_id(&write))?],
101 |r| {
102 let roots: Vec<u8> = r.get(2)?;
103 let signature: Vec<u8> = r.get(3)?;
104 Ok(HeaderEvidence {
105 prefix: r.get(0)?,
106 header: r.get(1)?,
107 roots: hash_list(&roots).map_err(|_damaged| damaged(2))?,
108 signature: signature.try_into().map_err(|_wrong_width| damaged(3))?,
109 })
110 },
111 )?
112 .pop())
113}
114
115pub(crate) fn retain_leaves(
117 db: &StoreSql,
118 write: WriteId,
119 audience: &Audience,
120 hashes: &[[u8; 32]],
121) -> Result<(), DbError> {
122 let hashes = hash_bytes(hashes);
123 db.execute(
124 "INSERT INTO _coven_part_leaves(write_id,audience,hashes) VALUES(?1,?2,?3) ON CONFLICT(write_id,audience) DO NOTHING",
125 params![
126 encoded(merge_fields::encode_write_id(&write))?,
127 audience,
128 hashes
129 ],
130 )?;
131 Ok(())
132}
133
134pub(crate) fn holds_leaves(
137 db: &StoreSql,
138 write: WriteId,
139 audience: &Audience,
140) -> Result<bool, DbError> {
141 Ok(db.query_row(
142 "SELECT EXISTS(SELECT 1 FROM _coven_part_leaves WHERE write_id=?1 AND audience=?2)",
143 params![encoded(merge_fields::encode_write_id(&write))?, audience],
144 |r| r.get(0),
145 )?)
146}
147
148pub(crate) fn forget_part(
152 db: &StoreSql,
153 write: WriteId,
154 audience: &Audience,
155) -> Result<(), DbError> {
156 let id = encoded(merge_fields::encode_write_id(&write))?;
157 db.execute(
158 "DELETE FROM _coven_part_leaves WHERE write_id=?1 AND audience=?2",
159 params![id, audience],
160 )?;
161 db.execute(
162 "DELETE FROM _coven_write_evidence WHERE write_id=?1
163 AND NOT EXISTS(SELECT 1 FROM _coven_part_leaves WHERE write_id=?1)
164 AND NOT EXISTS(SELECT 1 FROM _coven_part_proofs WHERE write_id=?1)",
165 [id],
166 )?;
167 Ok(())
168}
169
170#[derive(Default)]
172struct Needs {
173 creations: BTreeSet<RowId>,
174 cells: Vec<(RowId, String, ColumnValue<coven_format::value::Value>, u64)>,
176}
177
178fn missing(write: WriteId) -> DbError {
181 tracing::error!(?write, "another member's write lacks retained authorship evidence");
182 DbError::Invariant { what: "another member's write that set an owned row keeps its evidence" }
183}
184
185fn written(
187 db: &StoreSql,
188 write: WriteId,
189) -> Result<Option<coven_format::write::WriteHeader>, DbError> {
190 if let Some(frame) = crate::write_headers::read(db, write)? {
191 return Ok(Some(frame.header));
192 }
193 let header: Option<Vec<u8>> = db
194 .query(
195 "SELECT header FROM _coven_authored_parts WHERE write_id=?1 LIMIT 1",
196 [encoded(merge_fields::encode_write_id(&write))?],
197 |r| r.get(0),
198 )?
199 .pop();
200 header.map(|bytes| Ok(merge_fields::decode_write_header(&bytes)?)).transpose()
201}
202
203#[derive(Clone, Copy, Debug)]
206pub(crate) struct Author {
207 pub(crate) device: coven_foundation::id_source::DeviceId,
208 pub(crate) member: Option<MemberId>,
209}
210
211fn by_another_member(db: &StoreSql, author: Author, write: WriteId) -> Result<bool, DbError> {
214 Ok(write.device != author.device
215 && (author.member.is_none()
216 || crate::store_state_tables::device_member(db, write.device)? != author.member))
217}
218
219pub(crate) fn keeps_evidence(
225 db: &StoreSql,
226 call: &StoreCall<'_>,
227 write: WriteId,
228) -> Result<bool, DbError> {
229 let device = call
230 .local_device()
231 .ok_or(DbError::Invariant { what: "a writer connection observes this device" })?;
232 by_another_member(
233 db,
234 Author { device, member: crate::store_state_tables::device_member(db, device)? },
235 write,
236 )
237}
238
239fn same_row(
241 db: &StoreSql,
242 version: u32,
243 current: u32,
244 leaf: &RowId,
245 row: &RowId,
246) -> Result<bool, DbError> {
247 Ok(leaf.key == row.key
248 && leaf.audience == row.audience
249 && crate::source_names::table(db, version, &leaf.table, current)?.as_deref()
250 == Some(row.table.as_str()))
251}
252
253fn proves(
256 db: &StoreSql,
257 version: u32,
258 current: u32,
259 leaf: &Leaf,
260 needs: &Needs,
261 creators: &BTreeMap<RowId, Option<coven_format::write_sources::ChangeId>>,
262) -> Result<bool, DbError> {
263 match leaf {
264 Leaf::Creation { row, generation: 0, creator } => {
265 for needed in &needs.creations {
266 if same_row(db, version, current, row, needed)?
267 && creators.get(needed) == Some(creator)
268 {
269 return Ok(true);
270 }
271 }
272 Ok(false)
273 }
274 Leaf::Cell { row, generation, kind, column, value } => {
275 let incarnation = match kind {
276 CellKind::Insert => generation + 1,
277 CellKind::Update => *generation,
278 };
279 for (needed, name, needed_value, present) in &needs.cells {
280 if *present == incarnation
281 && value == needed_value
282 && same_row(db, version, current, row, needed)?
283 && crate::source_names::column(
284 db,
285 version,
286 &row.table,
287 column,
288 current,
289 &needed.table,
290 )?
291 .as_deref()
292 == Some(name.as_str())
293 {
294 return Ok(true);
295 }
296 }
297 Ok(false)
298 }
299 _ => Ok(false),
300 }
301}
302
303pub(crate) fn evidence(
308 db: &StoreSql,
309 call: &StoreCall<'_>,
310 schema: &WriteSchema,
311 audience: &Audience,
312 author: Author,
313) -> Result<Vec<WriteEvidence>, DbError> {
314 let mut needs = BTreeMap::<WriteId, Needs>::new();
315 let mut creators = BTreeMap::new();
316 let other = |write: WriteId| by_another_member(db, author, write);
317 crate::snapshot_view::creations::<DbError>(db, audience, |creation| {
318 let row = creation.row.clone();
319 if crate::ownership::owner_table(schema, &row.table) && other(creation.write)? {
320 let claim =
321 (creation.creator.write != creation.write).then(|| creation.creator.clone());
322 creators.insert(row.clone(), claim);
323 needs.entry(creation.write).or_default().creations.insert(row);
324 }
325 Ok(())
326 })?;
327 crate::snapshot_view::rows(db, call, schema, audience, |merged| {
328 let state = merged.state;
329 let row = state.row();
330 if crate::ownership::owner_table(schema, &row.table) && state.present() {
331 for (column, cell) in state.cells() {
332 if other(cell.write)? {
333 needs.entry(cell.write).or_default().cells.push((
334 row.clone(),
335 column.clone(),
336 cell.value.clone(),
337 state.generation(),
338 ));
339 }
340 }
341 }
342 Ok::<_, DbError>(())
343 })?;
344 let current = crate::transaction_constants::schema_version(db, call)?;
345 let mut evidence = Vec::new();
346 for (write, needs) in needs {
347 let original = header(db, write)?.ok_or(missing(write))?;
348 let plain = written(db, write)?.ok_or(missing(write))?;
349 let proof = if plain.disposition == WriteDisposition::Migration {
350 Multiproof { leaves: 0, revealed: Vec::new(), hidden: Vec::new() }
351 } else {
352 open(db, write, audience, plain.schema_version, current, &needs, &creators)?
353 };
354 evidence.push(WriteEvidence {
355 write,
356 prefix: original.prefix,
357 header: original.header,
358 roots: original.roots,
359 signature: original.signature,
360 proof,
361 });
362 }
363 Ok(evidence)
364}
365
366fn open(
371 db: &StoreSql,
372 write: WriteId,
373 audience: &Audience,
374 version: u32,
375 current: u32,
376 needs: &Needs,
377 creators: &BTreeMap<RowId, Option<coven_format::write_sources::ChangeId>>,
378) -> Result<Multiproof, DbError> {
379 let id = encoded(merge_fields::encode_write_id(&write))?;
380 let hashes: Option<Vec<u8>> = db.query_row(
381 "SELECT (SELECT hashes FROM _coven_part_leaves WHERE write_id=?1 AND audience=?2)",
382 params![id, audience],
383 |r| r.get(0),
384 )?;
385 if let Some(hashes) = hashes {
386 let hashes = hash_list(&hashes)?;
387 let mut leaves = Vec::new();
388 db.for_each::<_, DbError>(
389 "SELECT record FROM _coven_authored_changes WHERE write_id=?1 AND audience=?2 ORDER BY table_name,key",
390 params![id, audience],
391 |r| {
392 let record = coven_format::snapshot_rows::KeptRecord::decode(
393 &r.get::<_, Vec<u8>>(0)?,
394 )?;
395 leaves.extend(coven_format::authorship::kept_leaves(&record));
396 Ok(())
397 },
398 )?;
399 if leaves.len() != hashes.len() {
400 return Err(DbError::DamagedDatabase);
401 }
402 let mut opened = Vec::with_capacity(leaves.len());
403 for leaf in &leaves {
404 opened.push(opening(db, version, current, leaf, needs, creators)?);
405 }
406 return Ok(Multiproof::from_hashes(&hashes, opened));
407 }
408 let (proof, hashes) = db
409 .query(
410 "SELECT proof,hashes FROM _coven_part_proofs WHERE write_id=?1 AND audience=?2",
411 params![id, audience],
412 |r| Ok((r.get::<_, Vec<u8>>(0)?, r.get::<_, Vec<u8>>(1)?)),
413 )?
414 .pop()
415 .ok_or_else(|| missing(write))?;
416 let proof = decoded(merge_fields::decode_multiproof(&proof))?;
417 let hashes = hash_list(&hashes)?;
418 let keep = proof
419 .opened()?
420 .iter()
421 .map(|leaf| proves(db, version, current, leaf, needs, creators))
422 .collect::<Result<Vec<_>, _>>()?;
423 Ok(proof.retain_opened(&hashes, &keep))
424}
425
426fn opening(
429 db: &StoreSql,
430 version: u32,
431 current: u32,
432 leaf: &KeptLeaf,
433 needs: &Needs,
434 creators: &BTreeMap<RowId, Option<coven_format::write_sources::ChangeId>>,
435) -> Result<Option<Vec<u8>>, DbError> {
436 let candidates = match leaf {
437 KeptLeaf::Known(leaf) => vec![leaf.clone()],
438 KeptLeaf::Digest { .. } => {
439 let mut candidates = Vec::new();
440 for (_, _, value, _) in &needs.cells {
441 candidates.extend(leaf.with_value(value)?);
442 }
443 candidates
444 }
445 KeptLeaf::Step => Vec::new(),
446 };
447 for candidate in candidates {
448 if proves(db, version, current, &candidate, needs, creators)? {
449 return Ok(Some(candidate.encode()?));
450 }
451 }
452 Ok(None)
453}
454
455pub(crate) struct AuthenticatedEvidence {
459 pub(crate) opened: WriteHeaderFrame,
460 pub(crate) leaves: Vec<Leaf>,
461 pub(crate) hashes: Vec<[u8; 32]>,
462 pub(crate) part: bool,
463}
464
465pub(crate) fn authenticate(
466 authorship: &dyn Authorship,
467 audience: &Audience,
468 evidence: &WriteEvidence,
469) -> Result<AuthenticatedEvidence, DbError> {
470 let opened = authorship.header(evidence)?;
471 if opened.header.position != evidence.write {
472 return Err(crate::snapshot_error::invalid("write evidence names another write"));
473 }
474 let prefix = coven_format::sealed_write::WriteObjectPrefix::decode(&evidence.prefix)?;
475 let part = opened.parts.iter().position(|part| part.audience == *audience);
476 let (leaves, hashes) = match part {
477 Some(index) => {
478 let hasher = authorship.hasher(audience, prefix.part_keys[index])?;
479 let (root, hashes) = evidence.proof.root_with_leaf_hashes(&hasher)?;
480 if root != evidence.roots[index] {
481 return Err(crate::snapshot_error::invalid(
482 "write evidence opening differs from its signed root",
483 ));
484 }
485 (evidence.proof.opened()?, hashes)
486 }
487 None if evidence.proof.leaves == 0 => (Vec::new(), Vec::new()),
488 None => {
489 return Err(crate::snapshot_error::invalid(
490 "write evidence opens a part the write does not have",
491 ))
492 }
493 };
494 Ok(AuthenticatedEvidence { opened, leaves, hashes, part: part.is_some() })
495}
496
497pub(crate) fn load(
501 db: &StoreSql,
502 call: &StoreCall<'_>,
503 audience: &Audience,
504 evidence: &WriteEvidence,
505 verified: &AuthenticatedEvidence,
506) -> Result<(), DbError> {
507 crate::write_headers::retain(db, &verified.opened)?;
508 if !keeps_evidence(db, call, evidence.write)? {
509 return Ok(());
510 }
511 retain_header(
512 db,
513 evidence.write,
514 &HeaderEvidence {
515 prefix: evidence.prefix.clone(),
516 header: evidence.header.clone(),
517 roots: evidence.roots.clone(),
518 signature: evidence.signature,
519 },
520 )?;
521 if verified.part {
522 let hashes = hash_bytes(&verified.hashes);
523 db.execute(
524 "INSERT INTO _coven_part_proofs(write_id,audience,proof,hashes) VALUES(?1,?2,?3,?4) ON CONFLICT(write_id,audience) DO UPDATE SET proof=excluded.proof,hashes=excluded.hashes",
525 params![
526 encoded(merge_fields::encode_write_id(&evidence.write))?,
527 audience,
528 encoded(merge_fields::encode_multiproof(&evidence.proof))?,
529 hashes
530 ],
531 )?;
532 }
533 Ok(())
534}
535
536pub(crate) fn check(
540 db: &StoreSql,
541 call: &StoreCall<'_>,
542 schema: &WriteSchema,
543 audience: &Audience,
544 author: Author,
545 authenticated: &BTreeMap<WriteId, AuthenticatedEvidence>,
546) -> Result<(), DbError> {
547 let current = crate::transaction_constants::schema_version(db, call)?;
548 let refused = || {
549 crate::snapshot_error::invalid(
550 "snapshot names another member's authorship without its write's evidence",
551 )
552 };
553 let other = |write: WriteId| by_another_member(db, author, write);
554 let mut needs = BTreeMap::<WriteId, Needs>::new();
555 let mut creators = BTreeMap::new();
556 crate::ownership::visit::<DbError>(db, audience, |row, creation| {
557 if crate::ownership::owner_table(schema, &row.table) && other(creation.write)? {
558 let claim =
559 (creation.creator.write != creation.write).then(|| creation.creator.clone());
560 creators.insert(row.clone(), claim);
561 needs.entry(creation.write).or_default().creations.insert(row);
562 }
563 Ok(())
564 })?;
565 let loaded = BTreeSet::from([audience.clone()]);
567 let store = crate::merge_store::MergeStore::from_snapshot(db, call, &schema.schema, &loaded);
568 for declaration in
569 schema.declarations.iter().filter(|d| d.permission == crate::WritePermission::Owner)
570 {
571 let rows = db.query(
572 "SELECT DISTINCT table_name,key,audience FROM _coven_rows WHERE audience=?1 AND table_name=?2",
573 params![audience, declaration.name],
574 crate::row_queries::read_identity,
575 )?;
576 for row in rows {
577 let state = store.row_without_losses(&row)?.state;
578 if !state.present() {
579 continue;
580 }
581 for (column, cell) in state.cells() {
582 if other(cell.write)? {
583 needs.entry(cell.write).or_default().cells.push((
584 row.clone(),
585 column.clone(),
586 cell.value.clone(),
587 state.generation(),
588 ));
589 }
590 }
591 }
592 }
593 for (write, needs) in needs {
594 let Some(verified) = authenticated.get(&write) else {
595 return Err(refused());
596 };
597 if verified.opened.header.disposition == WriteDisposition::Migration {
598 continue;
599 }
600 let version = verified.opened.header.schema_version;
601 let leaves = &verified.leaves;
602 for row in &needs.creations {
603 let single = Needs { creations: BTreeSet::from([row.clone()]), cells: Vec::new() };
604 let mut found = false;
605 for leaf in leaves {
606 found |= proves(db, version, current, leaf, &single, &creators)?;
607 }
608 if !found {
609 return Err(refused());
610 }
611 }
612 for cell in &needs.cells {
613 let single = Needs { creations: BTreeSet::new(), cells: vec![cell.clone()] };
614 let mut found = false;
615 for leaf in leaves {
616 found |= proves(db, version, current, leaf, &single, &creators)?;
617 }
618 if !found {
619 return Err(refused());
620 }
621 }
622 }
623 Ok(())
624}
625
626pub(crate) struct PartRoot {
629 hasher: AuthorshipHasher,
630 root: [u8; 32],
631 hashes: Vec<[u8; 32]>,
632}
633
634impl PartRoot {
635 pub(crate) fn new(hasher: AuthorshipHasher, root: [u8; 32]) -> Self {
636 Self { hasher, root, hashes: Vec::new() }
637 }
638
639 pub(crate) fn record(
641 &mut self,
642 record: coven_format::write::PartRecord<'_>,
643 ) -> Result<(), DbError> {
644 for leaf in coven_format::authorship::record_leaves(record) {
645 self.hashes.push(self.hasher.leaf(&leaf.encode()?));
646 }
647 Ok(())
648 }
649
650 pub(crate) fn finish(self) -> Result<Vec<[u8; 32]>, DbError> {
652 if coven_format::authorship::root_of_hashes(&self.hashes) != self.root {
653 return Err(crate::snapshot_error::invalid(
654 "write part differs from its signed authorship root",
655 ));
656 }
657 Ok(self.hashes)
658 }
659}
660
661#[cfg(test)]
662#[path = "authorship_tests.rs"]
663pub(crate) mod tests;