1use 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 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 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 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 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 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 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}