Skip to main content

arachne_security/
name.rs

1//! Administrator-signed presentation metadata; changing it never rotates data keys.
2use super::{MembershipVerifier, SUITE, Workspace, bootstrap, history::MembershipHistory};
3use openmls::prelude::{tls_codec::Serialize, *};
4use openmls_traits::{OpenMlsProvider, crypto::OpenMlsCrypto, signatures::Signer};
5use sha2::{Digest, Sha256};
6
7pub(super) const EXTENSION: u16 = 0xff01;
8const CURRENT: &[u8] = b"data-fabric/workspace-name/current/v1";
9const STEP: &[u8] = b"data-fabric/workspace-name/step/v1/";
10const CHECKPOINT: &[u8] = b"data-fabric/workspace-name/checkpoint/v1";
11const MISSING: &[u8] = b"data-fabric/workspace-name/missing/v1";
12const MAGIC: &[u8] = b"DFNM\x01";
13const CHECKPOINT_MAGIC: &[u8] = b"DFNC\x01";
14pub const MAX_WORKSPACE_NAME_RECORD: usize = 5 + 32 + 8 + 32 + 32 + 8 + 32 + 320 + 64;
15pub const MAX_WORKSPACE_NAME_CHECKPOINT: usize = MAX_WORKSPACE_NAME_RECORD;
16
17pub fn validate_workspace_name(name: &str) -> Result<&str, &'static str> {
18    if name.chars().any(|c| {
19        c.is_control()
20            || matches!(c,
21        '\u{061c}' | '\u{200e}' | '\u{200f}' | '\u{202a}'..='\u{202e}' | '\u{2066}'..='\u{2069}')
22    }) {
23        return Err(
24            "workspace name must be 1–80 characters without control or bidirectional formatting characters",
25        );
26    }
27    let name = name.trim();
28    if name.is_empty() || name.len() > 320 || name.chars().count() > 80 {
29        return Err(
30            "workspace name must be 1–80 characters without control or bidirectional formatting characters",
31        );
32    }
33    Ok(name)
34}
35
36#[derive(Clone, Default)]
37pub(super) struct NameState {
38    pub revision: u64,
39    pub head: [u8; 32],
40    pub name: Option<String>,
41}
42impl NameState {
43    pub fn decode(bytes: &[u8]) -> Result<Self, &'static str> {
44        if bytes.len() < 41 || bytes.len() > 361 || bytes[0] != 1 {
45            return Err("invalid workspace name checkpoint");
46        }
47        let revision = u64::from_be_bytes(bytes[1..9].try_into().unwrap());
48        let head = bytes[9..41].try_into().unwrap();
49        let name = std::str::from_utf8(&bytes[41..]).map_err(|_| "invalid workspace name text")?;
50        if revision == 0 && head == [0; 32] && name.is_empty() {
51            return Ok(Self::default());
52        }
53        if revision == 0 || head == [0; 32] || validate_workspace_name(name)? != name {
54            return Err("invalid workspace name checkpoint");
55        }
56        Ok(Self {
57            revision,
58            head,
59            name: Some(name.to_owned()),
60        })
61    }
62    pub fn encode(&self) -> Vec<u8> {
63        let mut bytes = vec![1];
64        bytes.extend(self.revision.to_be_bytes());
65        bytes.extend(self.head);
66        if let Some(name) = &self.name {
67            bytes.extend(name.as_bytes());
68        }
69        bytes
70    }
71}
72
73pub struct PreparedWorkspaceName {
74    pub workspace: Workspace,
75    pub record: Vec<u8>,
76}
77
78pub struct PreparedWorkspaceNameCheckpoint {
79    pub workspace: Workspace,
80    pub missing: u64,
81}
82
83fn branch(context: &GroupContext) -> Result<[u8; 32], &'static str> {
84    Ok(Sha256::digest(
85        context
86            .tls_serialize_detached()
87            .map_err(|_| "group context encoding failed")?,
88    )
89    .into())
90}
91
92impl Workspace {
93    pub(super) fn name_state(&self) -> Result<NameState, &'static str> {
94        let state = self
95            .provider
96            .storage()
97            .values
98            .read()
99            .map_err(|_| "storage unavailable")?;
100        state
101            .get(CURRENT)
102            .map(|bytes| NameState::decode(bytes))
103            .transpose()
104            .map(|n| n.unwrap_or_default())
105    }
106    pub fn workspace_name(&self) -> Result<Option<String>, &'static str> {
107        Ok(self.name_state()?.name)
108    }
109    pub fn workspace_name_head(&self) -> Result<[u8; 32], &'static str> {
110        Ok(self.name_state()?.head)
111    }
112    pub fn workspace_name_revision(&self) -> Result<u64, &'static str> {
113        Ok(self.name_state()?.revision)
114    }
115    pub fn workspace_name_missing_history(&self) -> Result<u64, &'static str> {
116        let state = self
117            .provider
118            .storage()
119            .values
120            .read()
121            .map_err(|_| "storage unavailable")?;
122        state.get(MISSING).map_or(Ok(0), |bytes| {
123            bytes
124                .as_slice()
125                .try_into()
126                .map(u64::from_be_bytes)
127                .map_err(|_| "invalid workspace name missing-history count")
128        })
129    }
130    pub(super) fn initialize_name_checkpoint(&self, state: &NameState) -> Result<(), &'static str> {
131        self.provider
132            .storage()
133            .values
134            .write()
135            .map_err(|_| "storage unavailable")?
136            .insert(CURRENT.to_vec(), state.encode());
137        Ok(())
138    }
139    pub(super) fn name_checkpoint_extension(&self) -> Result<Vec<Extension>, &'static str> {
140        let state = self.name_state()?;
141        Ok(if state.name.is_some() {
142            vec![Extension::Unknown(
143                EXTENSION,
144                UnknownExtension(state.encode()),
145            )]
146        } else {
147            vec![]
148        })
149    }
150    pub fn prepare_workspace_name(
151        &self,
152        name: &str,
153    ) -> Result<PreparedWorkspaceName, &'static str> {
154        let name = validate_workspace_name(name)?;
155        let prior = self.name_state()?;
156        if prior.name.as_deref() == Some(name) {
157            return Err("workspace already has this name");
158        }
159        let mut record = MAGIC.to_vec();
160        record.extend(self.id());
161        record.extend(
162            prior
163                .revision
164                .checked_add(1)
165                .ok_or("workspace name revision exhausted")?
166                .to_be_bytes(),
167        );
168        record.extend(prior.head);
169        record.extend(self.member().ok_or("member profile required")?.id());
170        record.extend(self.epoch().to_be_bytes());
171        record.extend(branch(
172            MembershipVerifier::from_workspace(self)?
173                .group
174                .group_context(),
175        )?);
176        record.extend(name.as_bytes());
177        record.extend(
178            self._signer
179                .sign(&record)
180                .map_err(|_| "workspace name signing failed")?,
181        );
182        let workspace = self.prepare_workspace_name_update(&record)?;
183        let checkpoint = workspace.sign_workspace_name_checkpoint()?;
184        workspace
185            .provider
186            .storage()
187            .values
188            .write()
189            .map_err(|_| "storage unavailable")?
190            .insert(CHECKPOINT.to_vec(), checkpoint);
191        Ok(PreparedWorkspaceName { workspace, record })
192    }
193
194    pub fn sign_workspace_name_checkpoint(&self) -> Result<Vec<u8>, &'static str> {
195        let state = self.name_state()?;
196        let member = self.member().ok_or("member profile required")?;
197        if state.name.is_none()
198            || !self
199                .member_roster()?
200                .iter()
201                .any(|entry| entry.id == member.id() && entry.administrator)
202        {
203            return Err("workspace name checkpoint requires a current administrator");
204        }
205        let mut bytes = CHECKPOINT_MAGIC.to_vec();
206        bytes.extend(self.id());
207        bytes.extend(state.revision.to_be_bytes());
208        bytes.extend(state.head);
209        bytes.extend(member.id());
210        bytes.extend(self.epoch().to_be_bytes());
211        bytes.extend(branch(
212            MembershipVerifier::from_workspace(self)?
213                .group
214                .group_context(),
215        )?);
216        bytes.extend(state.name.unwrap().as_bytes());
217        bytes.extend(
218            self._signer
219                .sign(&bytes)
220                .map_err(|_| "workspace name checkpoint signing failed")?,
221        );
222        Ok(bytes)
223    }
224
225    fn verify_workspace_name_checkpoint(&self, bytes: &[u8]) -> Result<NameState, &'static str> {
226        if bytes.len() < 214
227            || bytes.len() > MAX_WORKSPACE_NAME_CHECKPOINT
228            || !bytes.starts_with(CHECKPOINT_MAGIC)
229            || bytes[5..37] != self.id()
230        {
231            return Err("invalid workspace name checkpoint");
232        }
233        let revision = u64::from_be_bytes(bytes[37..45].try_into().unwrap());
234        let head: [u8; 32] = bytes[45..77].try_into().unwrap();
235        let author: [u8; 32] = bytes[77..109].try_into().unwrap();
236        let epoch = u64::from_be_bytes(bytes[109..117].try_into().unwrap());
237        let end = bytes.len() - 64;
238        let name = std::str::from_utf8(&bytes[149..end])
239            .map_err(|_| "invalid workspace name checkpoint text")?;
240        if revision == 0
241            || head == [0; 32]
242            || validate_workspace_name(name)? != name
243            || epoch != self.epoch()
244            || bytes[117..149]
245                != branch(
246                    MembershipVerifier::from_workspace(self)?
247                        .group
248                        .group_context(),
249                )?
250        {
251            return Err("workspace name checkpoint does not match current membership");
252        }
253        let admins = bootstrap::authority(self.group.extensions())?;
254        let members: Vec<_> = self.group.members().collect();
255        let member = members
256            .iter()
257            .find(|member| bootstrap::binding(&member.credential).is_ok_and(|(id, _)| id == author))
258            .ok_or("workspace name checkpoint author is not a current member")?;
259        if !admins.contains(&member.signature_key) {
260            return Err("workspace name checkpoint author is not a current administrator");
261        }
262        self.provider
263            .crypto()
264            .verify_signature(
265                SUITE.signature_algorithm(),
266                &bytes[..end],
267                &member.signature_key,
268                &bytes[end..],
269            )
270            .map_err(|_| "workspace name checkpoint signature invalid")?;
271        Ok(NameState {
272            revision,
273            head,
274            name: Some(name.to_owned()),
275        })
276    }
277
278    pub fn workspace_name_checkpoint(&self) -> Result<Option<Vec<u8>>, &'static str> {
279        if let Ok(checkpoint) = self.sign_workspace_name_checkpoint() {
280            return Ok(Some(checkpoint));
281        }
282        let stored = self
283            .provider
284            .storage()
285            .values
286            .read()
287            .map_err(|_| "storage unavailable")?
288            .get(CHECKPOINT)
289            .cloned();
290        Ok(stored.filter(|bytes| {
291            self.verify_workspace_name_checkpoint(bytes)
292                .is_ok_and(|state| {
293                    self.name_state()
294                        .is_ok_and(|current| state.encode() == current.encode())
295                })
296        }))
297    }
298
299    pub fn prepare_workspace_name_checkpoint(
300        &self,
301        checkpoint: &[u8],
302    ) -> Result<PreparedWorkspaceNameCheckpoint, &'static str> {
303        let state = self.verify_workspace_name_checkpoint(checkpoint)?;
304        let previous = self.name_state()?;
305        let missing = state
306            .revision
307            .checked_sub(previous.revision)
308            .filter(|missing| *missing > 0)
309            .ok_or("workspace name checkpoint does not advance accepted name")?;
310        let total = self
311            .workspace_name_missing_history()?
312            .checked_add(missing)
313            .ok_or("workspace name missing-history count exhausted")?;
314        let candidate = self.provisional_copy()?;
315        let mut values = candidate
316            .provider
317            .storage()
318            .values
319            .write()
320            .map_err(|_| "storage unavailable")?;
321        values.insert(CURRENT.to_vec(), state.encode());
322        values.insert(CHECKPOINT.to_vec(), checkpoint.to_vec());
323        values.insert(MISSING.to_vec(), total.to_be_bytes().to_vec());
324        drop(values);
325        Ok(PreparedWorkspaceNameCheckpoint {
326            workspace: candidate,
327            missing,
328        })
329    }
330    fn name_authority_at(&self, epoch: u64) -> Result<MembershipVerifier, &'static str> {
331        if epoch == self.epoch() {
332            return MembershipVerifier::from_workspace(self);
333        }
334        let history = self
335            .join_history
336            .as_ref()
337            .ok_or("workspace name authority history unavailable")?;
338        let mut verifier = history.verifier(self.id())?;
339        if verifier.epoch() > epoch {
340            return Err("workspace name predates accepted history");
341        }
342        for (auth, commit) in &history.steps {
343            if verifier.epoch() == epoch {
344                break;
345            }
346            verifier.apply_transition(auth, commit)?;
347        }
348        if verifier.epoch() != epoch {
349            return Err("workspace name authority history unavailable");
350        }
351        Ok(verifier)
352    }
353    /// Accept exactly the next name on this branch. No caller may install a peer's
354    /// checkpoint over existing accepted state; only a new join has that baseline.
355    pub fn prepare_workspace_name_update(&self, record: &[u8]) -> Result<Workspace, &'static str> {
356        if record.len() < 214
357            || record.len() > MAX_WORKSPACE_NAME_RECORD
358            || !record.starts_with(MAGIC)
359            || record[5..37] != self.id()
360        {
361            return Err("invalid workspace name record");
362        }
363        let previous = self.name_state()?;
364        let revision = u64::from_be_bytes(record[37..45].try_into().unwrap());
365        if previous.revision.checked_add(1) != Some(revision) || record[45..77] != previous.head {
366            return Err("workspace name update does not extend accepted name");
367        }
368        let author: [u8; 32] = record[77..109].try_into().unwrap();
369        if !self
370            .member_roster()?
371            .iter()
372            .any(|m| m.id == author && m.administrator)
373        {
374            return Err("workspace name author is not a current administrator");
375        }
376        let epoch = u64::from_be_bytes(record[109..117].try_into().unwrap());
377        let end = record.len() - 64;
378        let name =
379            std::str::from_utf8(&record[149..end]).map_err(|_| "invalid workspace name text")?;
380        if validate_workspace_name(name)? != name || previous.name.as_deref() == Some(name) {
381            return Err("invalid workspace name change");
382        }
383        let verifier = self.name_authority_at(epoch)?;
384        if record[117..149] != branch(verifier.group.group_context())? {
385            return Err("workspace name membership branch mismatch");
386        }
387        let admins = bootstrap::authority(verifier.group.group_context().extensions())?;
388        let members: Vec<_> = verifier.group.members().collect();
389        let member = members
390            .iter()
391            .find(|m| bootstrap::binding(&m.credential).is_ok_and(|(id, _)| id == author))
392            .ok_or("workspace name author is not a member")?;
393        if !admins.contains(&member.signature_key)
394            || members
395                .iter()
396                .filter(|m| m.signature_key == member.signature_key)
397                .count()
398                != 1
399        {
400            return Err("workspace name author is not an administrator");
401        }
402        self.provider
403            .crypto()
404            .verify_signature(
405                SUITE.signature_algorithm(),
406                &record[..end],
407                &member.signature_key,
408                &record[end..],
409            )
410            .map_err(|_| "workspace name signature invalid")?;
411        let mut candidate = self.provisional_copy()?;
412        // Preserve the authority branch needed after a later role/membership change.
413        if candidate.join_history.is_none() {
414            candidate.join_history = Some(MembershipHistory::from_workspace(self)?);
415        }
416        candidate.initialize_name_checkpoint(&NameState {
417            revision,
418            head: Sha256::digest(record).into(),
419            name: Some(name.to_owned()),
420        })?;
421        candidate
422            .provider
423            .storage()
424            .values
425            .write()
426            .map_err(|_| "storage unavailable")?
427            .insert([STEP, &previous.head].concat(), record.to_vec());
428        candidate
429            .provider
430            .storage()
431            .values
432            .write()
433            .map_err(|_| "storage unavailable")?
434            .remove(CHECKPOINT);
435        Ok(candidate)
436    }
437    /// One bounded next record, regardless of how many changes the workspace has made.
438    pub fn next_workspace_name(&self, after: [u8; 32]) -> Result<Option<Vec<u8>>, &'static str> {
439        Ok(self
440            .provider
441            .storage()
442            .values
443            .read()
444            .map_err(|_| "storage unavailable")?
445            .get([STEP, &after].concat().as_slice())
446            .cloned())
447    }
448}
449
450#[cfg(test)]
451mod tests {
452    use super::*;
453    use crate::{ManagementAction, PendingJoin, PreparedManagementUpdate, StorageKey};
454
455    fn accept_role(owner: &Workspace, change: &crate::PreparedManagement) -> Workspace {
456        let PreparedManagementUpdate::Active(next) = owner
457            .prepare_management_update(change.action, &change.commit)
458            .unwrap()
459        else {
460            panic!("unexpected removal")
461        };
462        *next
463    }
464    fn pair() -> (Workspace, Workspace) {
465        let admin = Workspace::create_named([1; 32], "Alex", Some("Storm Assessment")).unwrap();
466        let (invite, checkpoint) = admin.issue_invitation().unwrap();
467        let pending =
468            PendingJoin::from_invitation(&invite, &checkpoint, [2; 32], "Jordan").unwrap();
469        let add = admin
470            .prepare_admission([2; 32], pending.admission_request().unwrap())
471            .unwrap();
472        let mut proof = pending.join_proof().unwrap();
473        proof.apply_add(&add.authorization, &add.commit).unwrap();
474        let member = pending.prepare_workspace(&proof, &add.welcome).unwrap();
475        (add.workspace, member)
476    }
477    #[test]
478    fn names_validate_original_text_and_preserve_distinct_workspace_identity() {
479        for name in [
480            "",
481            " ",
482            "\nStorm",
483            "Storm\t",
484            "Storm\u{202e}",
485            "\u{061c}Storm",
486            "Storm\u{2069}",
487        ] {
488            assert!(validate_workspace_name(name).is_err(), "{name:?}");
489        }
490        assert!(validate_workspace_name(&"x".repeat(81)).is_err());
491        assert!(validate_workspace_name(&"🌲".repeat(80)).is_ok());
492        let a = Workspace::create_named([1; 32], "Alex", Some(" Storm Assessment ")).unwrap();
493        let b = Workspace::create_named([2; 32], "Alex", Some("Storm Assessment")).unwrap();
494        assert_eq!(
495            a.workspace_name().unwrap().as_deref(),
496            Some("Storm Assessment")
497        );
498        assert_ne!(a.id(), b.id());
499        assert_eq!(a.epoch(), 0);
500    }
501    #[test]
502    fn current_admin_checkpoint_recovers_missing_name_without_trusting_demoted_signer() {
503        let (mut admin, member) = pair();
504        let member_id = member.member().unwrap().id();
505        let promotion = admin
506            .prepare_management(ManagementAction::Promote(member_id))
507            .unwrap();
508        let member = accept_role(&member, &promotion);
509        admin = promotion.workspace;
510
511        // The returning member retains the old label while its still-authorized
512        // key creates the legitimate next record for the online administrator.
513        let renamed = member.prepare_workspace_name("Valley Recovery").unwrap();
514        admin = admin
515            .prepare_workspace_name_update(&renamed.record)
516            .unwrap();
517        let demotion = admin
518            .prepare_management(ManagementAction::Demote(member_id))
519            .unwrap();
520        let member = accept_role(&member, &demotion);
521        admin = demotion.workspace;
522        assert_eq!(
523            member.prepare_workspace_name_update(&renamed.record).err(),
524            Some("workspace name author is not a current administrator")
525        );
526
527        let checkpoint = admin.sign_workspace_name_checkpoint().unwrap();
528        let mut forged = checkpoint.clone();
529        forged[77..109].copy_from_slice(&member_id);
530        let end = forged.len() - 64;
531        forged.truncate(end);
532        let signature = member._signer.sign(&forged).unwrap();
533        forged.extend(signature);
534        assert_eq!(
535            member.prepare_workspace_name_checkpoint(&forged).err(),
536            Some("workspace name checkpoint author is not a current administrator")
537        );
538
539        let key = StorageKey::derive(&[72; 32]).unwrap();
540        let stale = Workspace::restore(
541            &key,
542            member.endpoint(),
543            member.id(),
544            &member.seal(&key).unwrap(),
545        )
546        .unwrap();
547        let recovered = member
548            .prepare_workspace_name_checkpoint(&checkpoint)
549            .unwrap();
550        assert_eq!(recovered.missing, 1);
551        assert_eq!(
552            recovered.workspace.workspace_name().unwrap().as_deref(),
553            Some("Valley Recovery")
554        );
555        assert_eq!(
556            recovered
557                .workspace
558                .workspace_name_missing_history()
559                .unwrap(),
560            1
561        );
562
563        // A non-administrator can relay the exact current-admin checkpoint; it
564        // cannot sign or replace it.
565        let relayed = recovered
566            .workspace
567            .workspace_name_checkpoint()
568            .unwrap()
569            .unwrap();
570        assert_eq!(relayed, checkpoint);
571        let relayed = stale.prepare_workspace_name_checkpoint(&relayed).unwrap();
572        assert_eq!(relayed.missing, 1);
573        assert_eq!(
574            relayed.workspace.workspace_name_missing_history().unwrap(),
575            1
576        );
577    }
578    #[test]
579    fn authority_replay_conflict_legacy_and_restart_preserve_keys_and_history() {
580        let (mut admin, mut member) = pair();
581        let id = admin.id();
582        let creator = admin.member().unwrap().id();
583        let key = StorageKey::derive(&[71; 32]).unwrap();
584        assert!(member.prepare_workspace_name("Unauthorized").is_err());
585        let retained = admin.protect_object(b"chat", b"Keep this history").unwrap();
586        let fingerprint = admin.epoch_fingerprint();
587        let change = admin.prepare_workspace_name("Valley Recovery").unwrap();
588        assert_eq!(
589            admin.workspace_name().unwrap().as_deref(),
590            Some("Storm Assessment")
591        );
592        assert_eq!(change.workspace.epoch_fingerprint(), fingerprint);
593        let mut forged = change.record.clone();
594        let end = forged.len() - 64;
595        forged[77..109].copy_from_slice(&member.member().unwrap().id());
596        let signature = member._signer.sign(&forged[..end]).unwrap();
597        forged[end..].copy_from_slice(&signature);
598        assert!(member.prepare_workspace_name_update(&forged).is_err());
599        member = member
600            .prepare_workspace_name_update(&change.record)
601            .unwrap();
602        assert!(
603            member
604                .prepare_workspace_name_update(&change.record)
605                .is_err()
606        );
607        assert_eq!(
608            member
609                .unprotect_object(b"chat", &retained)
610                .unwrap()
611                .message
612                .payload,
613            b"Keep this history"
614        );
615        admin = change.workspace;
616        assert_eq!(admin.id(), id);
617        assert_eq!(admin.member().unwrap().id(), creator);
618        let promotion = admin
619            .prepare_management(ManagementAction::Promote(member.member().unwrap().id()))
620            .unwrap();
621        member = accept_role(&member, &promotion);
622        admin = promotion.workspace;
623        let concurrent = admin.prepare_workspace_name("Western Sector").unwrap();
624        let renamed = member.prepare_workspace_name("Mountain Search").unwrap();
625        admin = admin
626            .prepare_workspace_name_update(&renamed.record)
627            .unwrap();
628        assert!(
629            admin
630                .prepare_workspace_name_update(&concurrent.record)
631                .is_err()
632        );
633        member = renamed.workspace;
634        let records = member.export_records().unwrap();
635        member = Workspace::restore_records([2; 32], id, &records).unwrap();
636        member = Workspace::restore(&key, [2; 32], id, &member.seal(&key).unwrap()).unwrap();
637        assert_eq!(
638            member.workspace_name().unwrap().as_deref(),
639            Some("Mountain Search")
640        );
641        let (invite, checkpoint) = member.issue_invitation().unwrap();
642        assert_eq!(
643            invite
644                .join_proof(&checkpoint)
645                .unwrap()
646                .workspace_name()
647                .unwrap()
648                .as_deref(),
649            Some("Mountain Search")
650        );
651        let old = member
652            .prepare_workspace_name("Signed before demotion")
653            .unwrap();
654        let demotion = admin
655            .prepare_management(ManagementAction::Demote(member.member().unwrap().id()))
656            .unwrap();
657        member = accept_role(&member, &demotion);
658        admin = demotion.workspace;
659        assert!(member.prepare_workspace_name("Forbidden").is_err());
660        assert_eq!(
661            admin.prepare_workspace_name_update(&old.record).err(),
662            Some("workspace name author is not a current administrator")
663        );
664        // A removed/demoted signer cannot manufacture a backdated record either.
665        let mut backdated = old.record.clone();
666        let end = backdated.len() - 64;
667        let signature = member._signer.sign(&backdated[..end]).unwrap();
668        backdated[end..].copy_from_slice(&signature);
669        assert!(admin.prepare_workspace_name_update(&backdated).is_err());
670
671        let legacy = Workspace::create([3; 32], "Legacy admin").unwrap();
672        let legacy =
673            Workspace::restore(&key, [3; 32], legacy.id(), &legacy.seal(&key).unwrap()).unwrap();
674        assert_eq!(legacy.workspace_name().unwrap(), None);
675        let initialized = legacy.prepare_workspace_name("Existing Operation").unwrap();
676        assert_eq!(initialized.workspace.id(), legacy.id());
677        assert_eq!(
678            initialized.workspace.epoch_fingerprint(),
679            legacy.epoch_fingerprint()
680        );
681        assert_eq!(
682            initialized.workspace.workspace_name().unwrap().as_deref(),
683            Some("Existing Operation")
684        );
685    }
686
687    #[test]
688    fn admission_helper_cannot_replace_invitation_name_and_bad_saved_metadata_fails_restore() {
689        let (admin, helper) = pair();
690        let (invite, checkpoint) = admin.issue_invitation().unwrap();
691        let pending = PendingJoin::from_invitation(&invite, &checkpoint, [3; 32], "Sam").unwrap();
692        helper
693            .initialize_name_checkpoint(&NameState {
694                revision: 999,
695                head: [99; 32],
696                name: Some("Helper forgery".into()),
697            })
698            .unwrap();
699        let add = helper
700            .prepare_admission([3; 32], pending.admission_request().unwrap())
701            .unwrap();
702        let mut proof = pending.join_proof().unwrap();
703        proof.apply_add(&add.authorization, &add.commit).unwrap();
704        let joined = pending.prepare_workspace(&proof, &add.welcome).unwrap();
705        assert_eq!(
706            joined.workspace_name().unwrap().as_deref(),
707            Some("Storm Assessment")
708        );
709
710        let key = StorageKey::derive(&[77; 32]).unwrap();
711        let owner = admin.provisional_copy().unwrap();
712        owner
713            .provider
714            .storage()
715            .values
716            .write()
717            .unwrap()
718            .insert(CURRENT.to_vec(), vec![1]);
719        assert!(
720            Workspace::restore(
721                &key,
722                owner.endpoint(),
723                owner.id(),
724                &owner.seal(&key).unwrap()
725            )
726            .is_err()
727        );
728        assert!(
729            Workspace::restore_records(
730                owner.endpoint(),
731                owner.id(),
732                &owner.export_records().unwrap()
733            )
734            .is_err()
735        );
736    }
737}