1pub mod catalog;
4pub mod current;
5pub mod inbox;
6pub mod receive;
7pub mod wire;
8
9use arachne_routing::{PublicationContext, Topic};
10use arachne_security::{MAX_APPLICATION_CIPHERTEXT, MAX_RECOVERY_PACKETS, RecoveryRequest};
11use sha2::{Digest, Sha256};
12use std::collections::{BTreeMap, BTreeSet, VecDeque};
13
14const MAGIC: &[u8] = b"DFRL\x01";
15const SEQUENCED_MAGIC: &[u8] = b"DFRL\x02";
16pub const MAX_TOPICS: usize = 64;
17pub const MAX_PACKETS_PER_TOPIC: usize = 32;
18pub const MAX_RETAINED_BYTES: usize = 512 * 1024;
19pub const MAX_SNAPSHOT_BYTES: usize = MAX_RETAINED_BYTES + 16 * 1024;
20
21#[derive(Clone, Debug, PartialEq, Eq)]
22pub struct RetainedPublication {
23 pub sequence: u64,
24 pub context: PublicationContext,
25 pub ciphertext: Vec<u8>,
26}
27impl RetainedPublication {
28 fn weight(&self) -> usize {
29 self.context.authenticated_bytes().len() + self.ciphertext.len() + 12
30 }
31}
32#[derive(Clone, Default)]
33struct History {
34 evicted_through: u64,
35 records: VecDeque<RetainedPublication>,
36}
37
38#[derive(Clone)]
42pub struct PublisherLog {
43 workspace: [u8; 32],
44 author: [u8; 32],
45 epoch: u64,
46 head: u64,
47 bytes: usize,
48 topics: BTreeMap<Topic, History>,
49}
50
51#[derive(Debug, PartialEq, Eq)]
52pub enum RangeError {
53 Invalid,
54 Unavailable,
55 Empty,
56 TooLarge,
57}
58impl std::fmt::Display for RangeError {
59 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
60 write!(f, "{self:?}")
61 }
62}
63impl std::error::Error for RangeError {}
64
65#[derive(Clone)]
68pub struct RangeQuery {
69 pub workspace: [u8; 32],
70 pub author: [u8; 32],
71 pub epoch: u64,
72 pub policy_revision: u64,
73 pub after: u64,
74 pub through: u64,
75 pub topics: BTreeSet<Topic>,
76}
77
78#[derive(Debug, PartialEq, Eq)]
79pub enum RetrievalError {
80 Denied,
81 History(RangeError),
82}
83impl std::fmt::Display for RetrievalError {
84 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
85 write!(f, "{self:?}")
86 }
87}
88impl std::error::Error for RetrievalError {}
89
90pub struct RetainedRange<'a> {
91 request: RecoveryRequest,
92 records: Vec<&'a RetainedPublication>,
93}
94impl RetainedRange<'_> {
95 pub fn request(&self) -> &RecoveryRequest {
96 &self.request
97 }
98 pub fn records(&self) -> &[&RetainedPublication] {
99 &self.records
100 }
101 pub fn sign_offer(&self, owner: &arachne_security::Workspace) -> Result<Vec<u8>, &'static str> {
102 let contexts: Vec<_> = self
103 .records
104 .iter()
105 .map(|r| r.context.authenticated_bytes())
106 .collect();
107 let packets: Vec<_> = contexts
108 .iter()
109 .zip(&self.records)
110 .map(|(context, record)| (context.as_slice(), record.ciphertext.as_slice()))
111 .collect();
112 owner.sign_recovery_offer(&self.request, &packets)
113 }
114}
115impl PublisherLog {
116 pub fn new(workspace: [u8; 32], author: [u8; 32], epoch: u64) -> Self {
117 Self {
118 workspace,
119 author,
120 epoch,
121 head: 0,
122 bytes: 0,
123 topics: BTreeMap::new(),
124 }
125 }
126 pub fn head(&self) -> u64 {
127 self.head
128 }
129
130 pub fn seal(
133 &self,
134 owner: &arachne_security::Workspace,
135 key: &arachne_security::StorageKey,
136 ) -> Result<Vec<u8>, &'static str> {
137 self.validate_owner(owner)?;
138 owner.seal_with_attachment(key, &self.snapshot())
139 }
140
141 fn validate_owner(&self, owner: &arachne_security::Workspace) -> Result<(), &'static str> {
142 if owner.id() != self.workspace
143 || owner.epoch() != self.epoch
144 || owner.member().map(|m| m.id()) != Some(self.author)
145 {
146 return Err("publisher index does not match security owner");
147 }
148 Ok(())
149 }
150
151 pub fn restore_sealed(
152 key: &arachne_security::StorageKey,
153 endpoint: [u8; 32],
154 workspace: [u8; 32],
155 sealed: &[u8],
156 ) -> Result<(arachne_security::Workspace, Self), &'static str> {
157 let (owner, attachment) =
158 arachne_security::Workspace::restore_with_attachment(key, endpoint, workspace, sealed)?;
159 let log = Self::restore(
160 owner.id(),
161 owner
162 .member()
163 .ok_or("publisher requires member identity")?
164 .id(),
165 owner.epoch(),
166 &attachment,
167 )?;
168 Ok((owner, log))
169 }
170
171 pub fn append(
174 &mut self,
175 context: PublicationContext,
176 ciphertext: Vec<u8>,
177 ) -> Result<u64, &'static str> {
178 if context.workspace != self.workspace
179 || ciphertext.is_empty()
180 || ciphertext.len() > MAX_APPLICATION_CIPHERTEXT
181 {
182 return Err("invalid retained publication");
183 }
184 if !self.topics.contains_key(&context.topic) && self.topics.len() == MAX_TOPICS {
185 return Err("retention topic limit");
186 }
187 if self
188 .topics
189 .values()
190 .flat_map(|h| &h.records)
191 .any(|r| r.context.id == context.id)
192 {
193 return Err("publication already retained");
194 }
195 let sequence = self
196 .head
197 .checked_add(1)
198 .ok_or("publisher sequence exhausted")?;
199 if context
200 .sequence
201 .is_some_and(|number| number.get() != sequence)
202 {
203 return Err("authenticated sequence does not match publisher index");
204 }
205 let topic = context.topic.clone();
206 let record = RetainedPublication {
207 sequence,
208 context,
209 ciphertext,
210 };
211 self.bytes += record.weight();
212 self.topics
213 .entry(topic.clone())
214 .or_default()
215 .records
216 .push_back(record);
217 self.head = sequence;
218 if self.topics[&topic].records.len() > MAX_PACKETS_PER_TOPIC {
219 self.evict(&topic);
220 }
221 while self.bytes > MAX_RETAINED_BYTES {
223 assert!(self.evict_oldest());
224 }
225 Ok(sequence)
226 }
227 fn evict_oldest(&mut self) -> bool {
228 let oldest = self
229 .topics
230 .iter()
231 .filter_map(|(topic, h)| h.records.front().map(|r| (r.sequence, topic)))
232 .min_by_key(|(seq, _)| *seq)
233 .map(|(_, topic)| topic.clone());
234 if let Some(topic) = oldest {
235 self.evict(&topic);
236 true
237 } else {
238 false
239 }
240 }
241 fn evict(&mut self, topic: &Topic) {
242 let history = self.topics.get_mut(topic).unwrap();
243 let record = history.records.pop_front().unwrap();
244 history.evicted_through = record.sequence;
245 self.bytes -= record.weight();
246 }
247
248 pub fn authorized_range(
252 &self,
253 owner: &arachne_security::Workspace,
254 policy: &arachne_routing::RoutingTable,
255 requester: [u8; 32],
256 query: &RangeQuery,
257 ) -> Result<RetainedRange<'_>, RetrievalError> {
258 self.authorize_history(
259 owner,
260 policy,
261 requester,
262 (query.workspace, query.author, query.epoch),
263 query.policy_revision,
264 &query.topics,
265 )?;
266 self.select(query.after, query.through, &query.topics)
267 .map_err(RetrievalError::History)
268 }
269
270 fn authorize_history(
271 &self,
272 owner: &arachne_security::Workspace,
273 policy: &arachne_routing::RoutingTable,
274 requester: [u8; 32],
275 scope: ([u8; 32], [u8; 32], u64),
276 revision: u64,
277 topics: &BTreeSet<Topic>,
278 ) -> Result<(), RetrievalError> {
279 if owner.id() != self.workspace
280 || owner.epoch() != self.epoch
281 || owner.member().map(|m| m.id()) != Some(self.author)
282 || scope.0 != self.workspace
283 || scope.1 != self.author
284 || scope.2 != self.epoch
285 {
286 return Err(RetrievalError::Denied);
287 }
288 authorize_history(owner, policy, requester, self.author, revision, topics)
289 }
290
291 pub fn select(
295 &self,
296 after: u64,
297 through: u64,
298 topics: &BTreeSet<Topic>,
299 ) -> Result<RetainedRange<'_>, RangeError> {
300 if after >= through || through > self.head || topics.is_empty() || topics.len() > MAX_TOPICS
301 {
302 return Err(RangeError::Invalid);
303 }
304 let mut records = Vec::new();
305 for topic in topics {
306 if let Some(history) = self.topics.get(topic) {
307 if after < history.evicted_through {
308 return Err(RangeError::Unavailable);
309 }
310 records.extend(
311 history
312 .records
313 .iter()
314 .filter(|r| r.sequence > after && r.sequence <= through),
315 );
316 if records.len() > MAX_RECOVERY_PACKETS {
317 return Err(RangeError::TooLarge);
318 }
319 }
320 }
321 records.sort_by_key(|r| r.sequence);
322 Ok(RetainedRange {
323 request: RecoveryRequest {
324 workspace: self.workspace,
325 author: self.author,
326 epoch: self.epoch,
327 selection: selection_digest(topics),
328 after,
329 through,
330 },
331 records,
332 })
333 }
334
335 pub fn snapshot(&self) -> Vec<u8> {
338 let sequenced = self
339 .topics
340 .values()
341 .flat_map(|h| &h.records)
342 .any(|r| r.context.sequence.is_some());
343 let mut bytes = if sequenced { SEQUENCED_MAGIC } else { MAGIC }.to_vec();
344 bytes.extend(self.workspace);
345 bytes.extend(self.author);
346 bytes.extend(self.epoch.to_be_bytes());
347 bytes.extend(self.head.to_be_bytes());
348 bytes.extend((self.topics.len() as u16).to_be_bytes());
349 for (topic, history) in &self.topics {
350 bytes.push(topic.as_str().len() as u8);
351 bytes.extend(topic.as_str().as_bytes());
352 bytes.extend(history.evicted_through.to_be_bytes());
353 bytes.extend((history.records.len() as u16).to_be_bytes());
354 for record in &history.records {
355 bytes.extend(record.sequence.to_be_bytes());
356 if sequenced {
357 bytes.push(u8::from(record.context.sequence.is_some()));
358 }
359 bytes.extend(record.context.revision.to_be_bytes());
360 bytes.extend(record.context.id);
361 bytes.extend((record.ciphertext.len() as u32).to_be_bytes());
362 bytes.extend(&record.ciphertext);
363 }
364 }
365 debug_assert!(bytes.len() <= MAX_SNAPSHOT_BYTES);
366 bytes
367 }
368
369 pub fn restore(
372 workspace: [u8; 32],
373 author: [u8; 32],
374 epoch: u64,
375 bytes: &[u8],
376 ) -> Result<Self, &'static str> {
377 if bytes.len() > MAX_SNAPSHOT_BYTES {
378 return Err("retention snapshot exceeds bounds");
379 }
380 let mut input = bytes;
381 let magic = take(&mut input, 5)?;
382 if (magic != MAGIC && magic != SEQUENCED_MAGIC)
383 || take(&mut input, 32)? != workspace
384 || take(&mut input, 32)? != author
385 || number64(&mut input)? != epoch
386 {
387 return Err("wrong retention snapshot scope");
388 }
389 let mut log = Self::new(workspace, author, epoch);
390 log.head = number64(&mut input)?;
391 let count = number16(&mut input)?;
392 if count > MAX_TOPICS {
393 return Err("retention topic limit");
394 }
395 let mut previous = None;
396 let mut sequences = BTreeSet::new();
397 let mut ids = BTreeSet::new();
398 let mut highest = 0;
399 for _ in 0..count {
400 let length = take(&mut input, 1)?[0] as usize;
401 let topic = Topic::new(
402 std::str::from_utf8(take(&mut input, length)?)
403 .map_err(|_| "invalid topic encoding")?,
404 )
405 .map_err(|_| "invalid retained topic")?;
406 if previous.as_ref().is_some_and(|p| p >= &topic) {
407 return Err("noncanonical retention topics");
408 }
409 previous = Some(topic.clone());
410 let evicted_through = number64(&mut input)?;
411 if evicted_through > log.head
412 || (evicted_through != 0 && !sequences.insert(evicted_through))
413 {
414 return Err("invalid or duplicate eviction watermark");
415 }
416 highest = highest.max(evicted_through);
417 let count = number16(&mut input)?;
418 if count > MAX_PACKETS_PER_TOPIC {
419 return Err("retention packet limit");
420 }
421 let mut history = History {
422 evicted_through,
423 records: VecDeque::new(),
424 };
425 let mut last = evicted_through;
426 for _ in 0..count {
427 let sequence = number64(&mut input)?;
428 let authenticated_sequence = if magic == SEQUENCED_MAGIC {
429 match take(&mut input, 1)?[0] {
430 0 => None,
431 1 => Some(
432 std::num::NonZeroU64::new(sequence).ok_or("zero publisher sequence")?,
433 ),
434 _ => return Err("invalid sequence marker"),
435 }
436 } else {
437 None
438 };
439 let revision = number64(&mut input)?;
440 let id = take(&mut input, 16)?.try_into().unwrap();
441 let length = u32::from_be_bytes(take(&mut input, 4)?.try_into().unwrap()) as usize;
442 if sequence <= last
443 || sequence > log.head
444 || !sequences.insert(sequence)
445 || !ids.insert(id)
446 || length == 0
447 || length > MAX_APPLICATION_CIPHERTEXT
448 {
449 return Err("invalid retained packet");
450 }
451 let record = RetainedPublication {
452 sequence,
453 context: PublicationContext {
454 sequence: authenticated_sequence,
455 workspace,
456 revision,
457 topic: topic.clone(),
458 id,
459 },
460 ciphertext: take(&mut input, length)?.to_vec(),
461 };
462 log.bytes += record.weight();
463 if log.bytes > MAX_RETAINED_BYTES {
464 return Err("retained bytes exceed limit");
465 }
466 last = sequence;
467 highest = highest.max(sequence);
468 history.records.push_back(record);
469 }
470 if history.records.is_empty() && evicted_through == 0 {
471 return Err("empty unobserved topic");
472 }
473 log.topics.insert(topic, history);
474 }
475 if !input.is_empty() || highest != log.head {
476 return Err("invalid retention tail or head");
477 }
478 Ok(log)
479 }
480}
481
482pub(crate) fn authorize_history(
485 owner: &arachne_security::Workspace,
486 policy: &arachne_routing::RoutingTable,
487 requester: [u8; 32],
488 author: [u8; 32],
489 revision: u64,
490 topics: &BTreeSet<Topic>,
491) -> Result<(), RetrievalError> {
492 if topics.is_empty() || topics.len() > MAX_TOPICS {
493 return Err(RetrievalError::Denied);
494 }
495 let endpoints = owner
496 .member_endpoints()
497 .map_err(|_| RetrievalError::Denied)?;
498 let author_endpoint = owner
499 .endpoints_for_members(&[author])
500 .map_err(|_| RetrievalError::Denied)?[0];
501 if !endpoints.contains(&requester) {
502 return Err(RetrievalError::Denied);
503 }
504 for topic in topics {
505 let publishers = policy
506 .publishers(owner.id(), revision, requester, topic)
507 .map_err(|_| RetrievalError::Denied)?;
508 if !publishers.contains(&author_endpoint) {
509 return Err(RetrievalError::Denied);
510 }
511 }
512 Ok(())
513}
514pub fn selection_digest(topics: &BTreeSet<Topic>) -> [u8; 32] {
517 let mut hash = Sha256::new();
518 hash.update(b"data-fabric/exact-topic-selection/v1\0");
519 hash.update((topics.len() as u16).to_be_bytes());
520 for topic in topics {
521 hash.update([topic.as_str().len() as u8]);
522 hash.update(topic.as_str().as_bytes());
523 }
524 hash.finalize().into()
525}
526
527fn take<'a>(bytes: &mut &'a [u8], count: usize) -> Result<&'a [u8], &'static str> {
528 let (head, tail) = bytes
529 .split_at_checked(count)
530 .ok_or("truncated retention snapshot")?;
531 *bytes = tail;
532 Ok(head)
533}
534fn number64(bytes: &mut &[u8]) -> Result<u64, &'static str> {
535 Ok(u64::from_be_bytes(take(bytes, 8)?.try_into().unwrap()))
536}
537fn number16(bytes: &mut &[u8]) -> Result<usize, &'static str> {
538 Ok(u16::from_be_bytes(take(bytes, 2)?.try_into().unwrap()) as usize)
539}
540
541#[test]
542fn retention_watermarks_scope_and_snapshot_bounds() {
543 let mut log = PublisherLog::new([1; 32], [2; 32], 3);
544 let context = |topic: &str, id: u128| PublicationContext {
545 sequence: None,
546 workspace: [1; 32],
547 revision: 7,
548 topic: Topic::new(topic).unwrap(),
549 id: id.to_be_bytes(),
550 };
551 let quiet = BTreeSet::from([Topic::new("quiet").unwrap()]);
552 let busy = BTreeSet::from([Topic::new("busy").unwrap()]);
553 log.append(context("quiet", 1), vec![1]).unwrap();
554 for id in 2..52 {
555 log.append(context("busy", id), vec![2]).unwrap();
556 }
557 log.append(context("quiet", 52), vec![3]).unwrap();
558 let range = log.select(0, 52, &quiet).unwrap();
559 assert_eq!(
560 range
561 .records()
562 .iter()
563 .map(|r| r.sequence)
564 .collect::<Vec<_>>(),
565 [1, 52]
566 );
567 assert_eq!(
568 log.select(0, 52, &busy).err(),
569 Some(RangeError::Unavailable)
570 );
571 assert!(log.select(0, 53, &quiet).is_err());
572 let snapshot = log.snapshot();
573 let restored = PublisherLog::restore([1; 32], [2; 32], 3, &snapshot).unwrap();
574 assert_eq!(snapshot, restored.snapshot());
575 assert_eq!(restored.select(0, 52, &quiet).unwrap().records().len(), 2);
576 assert!(restored.select(0, 52, &busy).is_err());
577 for cut in [0, 4, 5, 37, 69, 85, snapshot.len() - 1] {
578 assert!(PublisherLog::restore([1; 32], [2; 32], 3, &snapshot[..cut]).is_err());
579 }
580 let mut collision = snapshot.clone();
581 let floor_offset = 5 + 32 + 32 + 8 + 8 + 2 + 1 + "busy".len();
584 collision[floor_offset..floor_offset + 8].copy_from_slice(&1u64.to_be_bytes());
585 assert!(PublisherLog::restore([1; 32], [2; 32], 3, &collision).is_err());
586 let mut trailing = snapshot.clone();
587 trailing.push(0);
588 assert!(PublisherLog::restore([1; 32], [2; 32], 3, &trailing).is_err());
589 assert!(PublisherLog::restore([9; 32], [2; 32], 3, &snapshot).is_err());
590 assert!(PublisherLog::restore([1; 32], [9; 32], 3, &snapshot).is_err());
591 assert!(PublisherLog::restore([1; 32], [2; 32], 4, &snapshot).is_err());
592 assert!(PublisherLog::restore([1; 32], [2; 32], 3, &vec![0; MAX_SNAPSHOT_BYTES + 1]).is_err());
593 assert!(log.append(context("quiet", 52), vec![4]).is_err());
594 assert!(log.append(context("quiet", 53), vec![]).is_err());
595 assert_eq!(log.head(), 52);
596 for id in 53..90 {
597 log.append(context("large", id), vec![5; MAX_APPLICATION_CIPHERTEXT])
598 .unwrap();
599 }
600 assert!(log.bytes <= MAX_RETAINED_BYTES);
601 assert!(log.snapshot().len() <= MAX_SNAPSHOT_BYTES);
602 assert!(log.select(0, log.head(), &quiet).is_err()); let restored = PublisherLog::restore([1; 32], [2; 32], 3, &log.snapshot()).unwrap();
604 assert!(restored.select(0, restored.head(), &quiet).is_err());
605 let mut many = PublisherLog::new([1; 32], [2; 32], 3);
606 for id in 0..MAX_TOPICS {
607 many.append(context(&format!("topic/{id:02}"), id as u128), vec![1])
608 .unwrap();
609 }
610 assert!(many.append(context("overflow", 999), vec![1]).is_err());
611 let all = many.topics.keys().cloned().collect();
612 assert_eq!(
613 many.select(0, many.head(), &all).err(),
614 Some(RangeError::TooLarge)
615 );
616 let before = many.snapshot();
617 let mut wrong = context("topic/00", 999);
618 wrong.workspace = [9; 32];
619 assert!(many.append(wrong, vec![1]).is_err());
620 assert_eq!(before, many.snapshot());
621 many.head = u64::MAX;
622 assert!(many.append(context("topic/00", 999), vec![1]).is_err());
623}
624
625#[test]
626fn restored_index_builds_offer_for_selected_real_mls_packets() {
627 use arachne_security::{PendingJoin, StorageKey, Workspace};
628 let admin = Workspace::create([1; 32], "Publisher").unwrap();
629 let (invite, checkpoint) = admin.issue_invitation().unwrap();
630 let pending = PendingJoin::from_invitation(&invite, &checkpoint, [2; 32], "Reader").unwrap();
631 let prepared = admin
632 .prepare_admission([2; 32], pending.admission_request().unwrap())
633 .unwrap();
634 let mut proof = pending.join_proof().unwrap();
635 proof
636 .apply_add(&prepared.authorization, &prepared.commit)
637 .unwrap();
638 let mut receiver = pending
639 .prepare_workspace(&proof, &prepared.welcome)
640 .unwrap();
641 let mut sender = prepared.workspace;
642 let key = StorageKey::derive(&[9; 32]).unwrap();
643 let mut log = PublisherLog::new(sender.id(), sender.member().unwrap().id(), sender.epoch());
644 let mut pair = log.seal(&sender, &key).unwrap();
645 for id in 1..=52u128 {
646 let topic = if id == 1 || id == 52 { "quiet" } else { "busy" };
647 let context = PublicationContext {
648 sequence: None,
649 workspace: sender.id(),
650 revision: 7,
651 topic: Topic::new(topic).unwrap(),
652 id: id.to_be_bytes(),
653 };
654 let packet = sender
655 .protect_application(&context.authenticated_bytes(), &id.to_be_bytes())
656 .unwrap();
657 log.append(context, packet).unwrap();
658 pair = log.seal(&sender, &key).unwrap();
660 }
661 let (sender, log) = PublisherLog::restore_sealed(&key, [1; 32], sender.id(), &pair).unwrap();
662 let mut damaged = pair.clone();
663 *damaged.last_mut().unwrap() ^= 1;
664 assert!(PublisherLog::restore_sealed(&key, [1; 32], sender.id(), &damaged).is_err());
665 let wrong = PublisherLog::new(sender.id(), [99; 32], sender.epoch());
666 assert!(wrong.seal(&sender, &key).is_err());
667 let mismatch = sender
669 .seal_with_attachment(&key, &wrong.snapshot())
670 .unwrap();
671 assert!(PublisherLog::restore_sealed(&key, [1; 32], sender.id(), &mismatch).is_err());
672 let topics = BTreeSet::from([Topic::new("quiet").unwrap()]);
673 let mut policy = arachne_routing::RoutingTable::default();
674 let owner_access = arachne_routing::Permissions::Selected {
675 publish: BTreeSet::from([Topic::new("quiet").unwrap(), Topic::new("busy").unwrap()]),
676 subscribe: BTreeSet::new(),
677 };
678 let reader_access = arachne_routing::Permissions::Selected {
679 publish: BTreeSet::new(),
680 subscribe: topics.clone(),
681 };
682 policy
684 .install_verified_policy(
685 sender.id(),
686 7,
687 BTreeMap::from([
688 (sender.endpoint(), owner_access.clone()),
689 (receiver.endpoint(), reader_access.clone()),
690 ([99; 32], reader_access.clone()),
691 ]),
692 )
693 .unwrap();
694 let cutoff = wire::CutoffQuery {
695 workspace: sender.id(),
696 author: sender.member().unwrap().id(),
697 epoch: sender.epoch(),
698 policy_revision: 7,
699 topics: topics.clone(),
700 nonce: [62; 32],
701 };
702 let signed_head =
703 wire::serve_cutoff(&log, &sender, &policy, receiver.endpoint(), &cutoff).unwrap();
704 assert_eq!(
705 wire::verify_cutoff_reply(&receiver, &cutoff, &signed_head).unwrap(),
706 Some(52)
707 );
708 assert_eq!(
709 wire::serve_cutoff(&log, &sender, &policy, [99; 32], &cutoff).unwrap(),
710 wire::denied_reply()
711 );
712 let mut unreadable = cutoff.clone();
713 unreadable.topics.insert(Topic::new("busy").unwrap());
714 assert_eq!(
715 wire::serve_cutoff(&log, &sender, &policy, receiver.endpoint(), &unreadable).unwrap(),
716 wire::denied_reply()
717 );
718 let mut query = RangeQuery {
719 workspace: sender.id(),
720 author: sender.member().unwrap().id(),
721 epoch: sender.epoch(),
722 policy_revision: 7,
723 after: 0,
724 through: 52,
725 topics: topics.clone(),
726 };
727 assert_eq!(
728 log.authorized_range(&sender, &policy, [99; 32], &query)
729 .err(),
730 Some(RetrievalError::Denied)
731 );
732 query.topics.insert(Topic::new("busy").unwrap());
733 assert_eq!(
735 log.authorized_range(&sender, &policy, receiver.endpoint(), &query)
736 .err(),
737 Some(RetrievalError::Denied)
738 );
739 query.topics = topics.clone();
740 query.workspace = [99; 32];
741 assert_eq!(
742 log.authorized_range(&sender, &policy, receiver.endpoint(), &query)
743 .err(),
744 Some(RetrievalError::Denied)
745 );
746 query.workspace = sender.id();
747 query.epoch += 1;
748 assert_eq!(
749 log.authorized_range(&sender, &policy, receiver.endpoint(), &query)
750 .err(),
751 Some(RetrievalError::Denied)
752 );
753 query.epoch = sender.epoch();
754 query.policy_revision = 6;
755 assert_eq!(
756 log.authorized_range(&sender, &policy, receiver.endpoint(), &query)
757 .err(),
758 Some(RetrievalError::Denied)
759 );
760 query.policy_revision = 7;
761 let empty_query = RangeQuery {
764 workspace: query.workspace,
765 author: query.author,
766 epoch: query.epoch,
767 policy_revision: query.policy_revision,
768 after: 1,
769 through: 51,
770 topics: query.topics.clone(),
771 };
772 let empty_response =
773 wire::serve_range(&log, &sender, &policy, receiver.endpoint(), &empty_query).unwrap();
774 let wire::RangeReply::Offered(empty_proof) =
775 wire::verify_reply(&receiver, &empty_query, &empty_response).unwrap()
776 else {
777 panic!("empty selected range must be author-authenticated");
778 };
779 assert!(empty_proof.packets().is_empty());
780 assert!(wire::verify_reply(&receiver, &query, &empty_response).is_err());
781 let mut damaged_empty = empty_response.clone();
782 let signature_byte = damaged_empty.len() - 2;
784 damaged_empty[signature_byte] ^= 1;
785 assert!(wire::verify_reply(&receiver, &empty_query, &damaged_empty).is_err());
786 assert!(matches!(
787 wire::verify_reply(&receiver, &empty_query, b"DFRP\x01\x04").unwrap(),
788 wire::RangeReply::Rejected(RetrievalError::History(RangeError::Empty))
789 ));
790 let denied_empty = wire::serve_range(&log, &sender, &policy, [99; 32], &empty_query).unwrap();
791 assert!(matches!(
792 wire::verify_reply(&receiver, &empty_query, &denied_empty).unwrap(),
793 wire::RangeReply::Rejected(RetrievalError::Denied)
794 ));
795 let range = log
796 .authorized_range(&sender, &policy, receiver.endpoint(), &query)
797 .unwrap();
798 let encoded = range.sign_offer(&sender).unwrap();
799 let encoded_query = query.to_wire().unwrap();
800 let wire_query = RangeQuery::from_wire(&encoded_query).unwrap();
801 assert_eq!(wire_query.to_wire().unwrap(), encoded_query);
802 let response =
803 wire::serve_range(&log, &sender, &policy, receiver.endpoint(), &wire_query).unwrap();
804 let wire::RangeReply::Offered(wire_proof) =
805 wire::verify_reply(&receiver, &query, &response).unwrap()
806 else {
807 panic!("expected range")
808 };
809 assert_eq!(wire_proof.packets().len(), 2);
810 for (decoded, retained) in wire_proof.packets().iter().zip(range.records()) {
811 assert_eq!(decoded.context, retained.context);
812 assert_eq!(decoded.ciphertext, retained.ciphertext);
813 }
814 for cut in [0, 5, 6, 8, response.len() - 1] {
815 assert!(wire::verify_reply(&receiver, &query, &response[..cut]).is_err());
816 }
817 let mut corrupt = response.clone();
818 *corrupt.last_mut().unwrap() ^= 1;
819 assert!(wire::verify_reply(&receiver, &query, &corrupt).is_err());
820 corrupt = response.clone();
821 corrupt.push(0);
822 assert!(wire::verify_reply(&receiver, &query, &corrupt).is_err());
823 let count_at = 8 + u16::from_be_bytes(response[6..8].try_into().unwrap()) as usize;
824 let mut omitted_all = response[..count_at + 1].to_vec();
825 omitted_all[count_at] = 0;
826 assert!(wire::verify_reply(&receiver, &query, &omitted_all).is_err());
827 let first = count_at + 1;
828 let ciphertext_length_at = first + 8 + 1 + response[first + 8] as usize + 16;
829 let second = ciphertext_length_at
830 + 4
831 + u32::from_be_bytes(
832 response[ciphertext_length_at..ciphertext_length_at + 4]
833 .try_into()
834 .unwrap(),
835 ) as usize;
836 let mut omitted = response[..second].to_vec();
837 omitted[count_at] = 1;
838 assert!(wire::verify_reply(&receiver, &query, &omitted).is_err());
839 let mut reordered = response[..first].to_vec();
840 reordered.extend(&response[second..]);
841 reordered.extend(&response[first..second]);
842 assert!(wire::verify_reply(&receiver, &query, &reordered).is_err());
843 let mut large = PublisherLog::new(sender.id(), sender.member().unwrap().id(), sender.epoch());
844 for id in 1u128..=8 {
845 large
846 .append(
847 PublicationContext {
848 sequence: None,
849 workspace: sender.id(),
850 revision: 7,
851 topic: Topic::new("quiet").unwrap(),
852 id: id.to_be_bytes(),
853 },
854 vec![1; MAX_APPLICATION_CIPHERTEXT],
855 )
856 .unwrap();
857 }
858 let large_query = RangeQuery {
859 through: 8,
860 ..RangeQuery::from_wire(&encoded_query).unwrap()
861 };
862 let rejected =
863 wire::serve_range(&large, &sender, &policy, receiver.endpoint(), &large_query).unwrap();
864 assert!(matches!(
865 wire::verify_reply(&receiver, &large_query, &rejected).unwrap(),
866 wire::RangeReply::Rejected(RetrievalError::History(RangeError::TooLarge))
867 ));
868 let denied = wire::serve_range(&log, &sender, &policy, [99; 32], &query).unwrap();
869 assert!(matches!(
870 wire::verify_reply(&receiver, &query, &denied).unwrap(),
871 wire::RangeReply::Rejected(RetrievalError::Denied)
872 ));
873
874 let verified = receiver
875 .verify_recovery_offer(range.request(), &encoded)
876 .unwrap();
877 let contexts: Vec<_> = range
878 .records()
879 .iter()
880 .map(|r| r.context.authenticated_bytes())
881 .collect();
882 let packets: Vec<_> = contexts
883 .iter()
884 .zip(range.records())
885 .map(|(c, r)| (c.as_slice(), r.ciphertext.as_slice()))
886 .collect();
887 verified.verify_packets(&packets).unwrap();
888 assert!(verified.verify_packets(&packets[1..]).is_err());
889 let receiver_key = StorageKey::derive(&[8; 32]).unwrap();
890 let mut candidate = Workspace::restore(
891 &receiver_key,
892 [2; 32],
893 receiver.id(),
894 &receiver.seal(&receiver_key).unwrap(),
895 )
896 .unwrap();
897 for ((context, packet), id) in packets.iter().zip([1u128, 52]) {
898 let message = candidate.unprotect_application(context, packet).unwrap();
899 verified.verify_origin(&message).unwrap();
900 wire_proof.verify_origin(&message).unwrap();
901 assert_eq!(message.payload, id.to_be_bytes());
902 }
903 drop(verified);
904 drop(wire_proof);
905 receiver = Workspace::restore(
906 &receiver_key,
907 [2; 32],
908 receiver.id(),
909 &candidate.seal(&receiver_key).unwrap(),
910 )
911 .unwrap();
912 assert!(
913 receiver
914 .unprotect_application(packets[0].0, packets[0].1)
915 .is_err()
916 );
917 policy
918 .install_verified_policy(
919 sender.id(),
920 8,
921 BTreeMap::from([
922 (sender.endpoint(), owner_access.clone()),
923 (
924 receiver.endpoint(),
925 arachne_routing::Permissions::Selected {
926 publish: BTreeSet::new(),
927 subscribe: BTreeSet::from([Topic::new("busy").unwrap()]),
928 },
929 ),
930 ]),
931 )
932 .unwrap();
933 query.policy_revision = 8;
934 assert_eq!(
935 log.authorized_range(&sender, &policy, receiver.endpoint(), &query)
936 .err(),
937 Some(RetrievalError::Denied)
938 );
939 query.topics = BTreeSet::from([Topic::new("busy").unwrap()]);
940 assert_eq!(
941 log.authorized_range(&sender, &policy, receiver.endpoint(), &query)
942 .err(),
943 Some(RetrievalError::History(RangeError::Unavailable))
944 );
945 policy
946 .install_verified_policy(
947 sender.id(),
948 9,
949 BTreeMap::from([
950 (sender.endpoint(), arachne_routing::Permissions::default()),
951 (receiver.endpoint(), reader_access),
952 ]),
953 )
954 .unwrap();
955 query.policy_revision = 9;
956 query.topics = topics;
957 assert_eq!(
958 log.authorized_range(&sender, &policy, receiver.endpoint(), &query)
959 .err(),
960 Some(RetrievalError::Denied)
961 );
962}
963
964#[test]
965fn publisher_order_migrates_without_inventing_legacy_authentication() {
966 let mut log = PublisherLog::new([1; 32], [2; 32], 3);
967 let mut context = PublicationContext {
968 workspace: [1; 32],
969 revision: 1,
970 topic: Topic::new("sample").unwrap(),
971 id: [1; 16],
972 sequence: None,
973 };
974 let old_aad = context.authenticated_bytes();
975 log.append(context.clone(), vec![1]).unwrap();
976 let legacy = log.snapshot();
977 assert_eq!(&legacy[..5], MAGIC);
978 let mut log = PublisherLog::restore([1; 32], [2; 32], 3, &legacy).unwrap();
979 context.id = [2; 16];
980 context.sequence = std::num::NonZeroU64::new(3);
981 assert_eq!(
982 log.append(context.clone(), vec![2]),
983 Err("authenticated sequence does not match publisher index")
984 );
985 assert_eq!(log.snapshot(), legacy);
986 context.sequence = std::num::NonZeroU64::new(2);
987 log.append(context, vec![2]).unwrap();
988 let mixed = log.snapshot();
989 assert_eq!(&mixed[..5], SEQUENCED_MAGIC);
990 let restored = PublisherLog::restore([1; 32], [2; 32], 3, &mixed).unwrap();
991 assert_eq!(restored.snapshot(), mixed);
992 let range = restored
993 .select(0, 2, &BTreeSet::from([Topic::new("sample").unwrap()]))
994 .unwrap();
995 assert_eq!(range.records()[0].context.sequence, None);
996 assert_eq!(range.records()[0].context.authenticated_bytes(), old_aad);
997 assert_eq!(range.records()[1].context.sequence.unwrap().get(), 2);
998 let mut invalid = mixed.clone();
1000 invalid[112] = 2;
1001 assert!(PublisherLog::restore([1; 32], [2; 32], 3, &invalid).is_err());
1002 let mut truncated = mixed;
1003 truncated.pop();
1004 assert!(PublisherLog::restore([1; 32], [2; 32], 3, &truncated).is_err());
1005}