Skip to main content

arachne_delivery/
lib.rs

1//! Bounded publisher retention index. No transport, disk writes or payload parsing.
2//! Its snapshot must commit atomically with the matching sender security snapshot.
3pub 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/// Append-only sequence within one author/workspace/epoch, with bounded retention.
39/// Eviction watermarks never disappear: a missing range cannot become "complete"
40/// merely because all its old packets were evicted. Clone to stage with security.
41#[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/// Expected publisher scope and requested exact-topic history. Transport must
66/// bind the requester separately; a peer field in this query would not authenticate it.
67#[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    /// Produce one authenticated host record. Caller owns atomic save/readback
131    /// before adopting this index and owner or releasing their publications.
132    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    /// New publications only. Retransmit existing ciphertext without appending.
172    /// Duplicate-ID detection covers retained records, not all historical IDs.
173    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        // ponytail: scan at most 64 topic heads; replace only if profiling requires it.
222        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    /// Authorize before disclosing retained data OR history availability. The
249    /// host supplies current accepted membership/policy and a transport-bound peer.
250    /// No active subscription is required or installed by a historical request.
251    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    /// Exact-topic selection over a fixed (after, through] range. Topic ACLs are
292    /// the caller's responsibility. Include required progress topics explicitly.
293    /// Empty selections succeed; unavailable/overlarge ranges never become partial success.
294    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    /// Encoding contains ciphertext plus sensitive metadata. Authenticate/encrypt
336    /// the complete host record, including the paired security snapshot, at rest.
337    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    /// Expected scope must come from accepted security state. This validates the
370    /// codec, not authenticity of arbitrary bytes or correctness of a hostile index.
371    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
482/// Authorize historical disclosure independently of which current member holds
483/// the publisher-signed bytes. The holder never becomes the packet author.
484pub(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}
514/// Canonical exact-topic selection binding. Query validation separately enforces
515/// nonempty selections and topic-count bounds before signing or network use.
516pub 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    // First canonical topic is "busy"; its eviction sequence cannot also be
582    // the sequence of the still-retained first quiet publication.
583    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()); // Byte-budget eviction cannot erase the watermark.
603    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        // Authenticated combined record in RAM, not yet a disk transaction.
659        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    // Even authenticated attachments must be checked against the restored owner.
668    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    // A stale routing entry for a nonmember cannot establish membership.
683    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    // Hidden missing history must not leak as Unavailable to an unauthorized reader.
734    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    // Busy publications exist in (1, 51], but no selected quiet publication.
762    // The receiver needs an author-signed empty selection, not an advisory status.
763    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    // Last byte is packet count; the preceding byte is part of the signature.
783    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    // Header 87, topic length/name 7, watermark/count 10, sequence 8.
999    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}