arachne_security/
profile.rs1use super::{MemberProfile, SUITE, Workspace, bootstrap};
3use openmls_traits::{OpenMlsProvider, crypto::OpenMlsCrypto, signatures::Signer};
4
5const HEADER: &[u8; 5] = b"DFMP\x01";
6const SERVICE_HEADER: &[u8; 5] = b"DFMP\x02";
7pub const MAX_MEMBER_PROFILE: usize = 5 + 32 + 32 + 1 + 256 + 64;
8
9#[derive(Clone, Debug)]
10pub struct MemberIdentity {
11 pub id: [u8; 32],
12 pub endpoint: [u8; 32],
13 pub administrator: bool,
14}
15
16impl Workspace {
17 pub fn member_roster(&self) -> Result<Vec<MemberIdentity>, &'static str> {
18 let admins = bootstrap::authority(self.group.extensions())?;
19 self.group
20 .members()
21 .map(|m| {
22 let (id, endpoint) = bootstrap::binding(&m.credential)?;
23 Ok(MemberIdentity {
24 id,
25 endpoint,
26 administrator: admins.contains(&m.signature_key),
27 })
28 })
29 .collect()
30 }
31
32 pub fn sign_member_profile(&self) -> Result<Vec<u8>, &'static str> {
35 self.sign_profile(false)
36 }
37
38 pub fn sign_service_profile(&self) -> Result<Vec<u8>, &'static str> {
39 self.sign_profile(true)
40 }
41
42 fn sign_profile(&self, service: bool) -> Result<Vec<u8>, &'static str> {
43 let member = self.member().ok_or("member profile required")?;
44 let mut bytes = if service {
45 SERVICE_HEADER.to_vec()
46 } else {
47 HEADER.to_vec()
48 };
49 bytes.extend(self.id());
50 bytes.extend(member.id());
51 if service {
52 bytes.push(1);
53 }
54 bytes.extend(member.display_name().as_bytes());
55 let signature = self
56 ._signer
57 .sign(&bytes)
58 .map_err(|_| "profile signing failed")?;
59 bytes.extend(signature);
60 Ok(bytes)
61 }
62
63 pub fn verify_member_profile(&self, bytes: &[u8]) -> Result<MemberProfile, &'static str> {
64 let (name_start, service) = if bytes.starts_with(HEADER) {
65 (69, false)
66 } else if bytes.starts_with(SERVICE_HEADER) && bytes.get(69) == Some(&1) {
67 (70, true)
68 } else {
69 return Err("invalid member profile scope or size");
70 };
71 if bytes.len() < name_start + 1 + 64
72 || bytes.len() > MAX_MEMBER_PROFILE
73 || bytes[5..37] != self.id()
74 {
75 return Err("invalid member profile scope or size");
76 }
77 let id: [u8; 32] = bytes[37..69].try_into().unwrap();
78 let end = bytes.len() - 64;
79 let name =
80 std::str::from_utf8(&bytes[name_start..end]).map_err(|_| "invalid profile text")?;
81 let profile = MemberProfile::new_kind(id, name, service)?;
82 if profile.display_name() != name {
83 return Err("noncanonical member profile");
84 }
85 let member = self
86 .group
87 .members()
88 .find(|m| bootstrap::binding(&m.credential).is_ok_and(|(bound, _)| bound == id))
89 .ok_or("profile author is not a current member")?;
90 self.provider
91 .crypto()
92 .verify_signature(
93 SUITE.signature_algorithm(),
94 &bytes[..end],
95 &member.signature_key,
96 &bytes[end..],
97 )
98 .map_err(|_| "invalid member profile signature")?;
99 Ok(profile)
100 }
101}
102
103#[test]
104fn profiles_bind_names_to_current_workspace_members() {
105 let mut admin = Workspace::create([91; 32], "Alex Morgan").unwrap();
106 let outsider = Workspace::create([92; 32], "Alex Morgan").unwrap();
107 let signed = admin.sign_member_profile().unwrap();
108 assert_eq!(
109 admin.verify_member_profile(&signed).unwrap(),
110 admin.member().unwrap().clone()
111 );
112 assert!(outsider.verify_member_profile(&signed).is_err());
113 for cut in 0..signed.len() {
114 assert!(admin.verify_member_profile(&signed[..cut]).is_err());
115 }
116 for i in 0..signed.len() {
117 let mut bad = signed.clone();
118 bad[i] ^= 1;
119 assert!(admin.verify_member_profile(&bad).is_err());
120 }
121 let (invitation, checkpoint) = admin.issue_invitation().unwrap();
122 let pending =
123 super::PendingJoin::from_invitation(&invitation, &checkpoint, [93; 32], "Alex Morgan")
124 .unwrap();
125 let request = pending.admission_request().unwrap();
126 let prepared = admin.prepare_admission([93; 32], request).unwrap();
127 admin = prepared.workspace;
128 let reply = admin
129 .retained_admission([93; 32], request)
130 .unwrap()
131 .unwrap();
132 let mut proof = pending.join_proof().unwrap();
133 proof
134 .apply_add(&reply.authorization, &reply.commit)
135 .unwrap();
136 let member = pending.prepare_workspace(&proof, &reply.welcome).unwrap();
137 let second = member.sign_member_profile().unwrap();
138 let profile = admin.verify_member_profile(&second).unwrap();
139 let mut forged = second[..second.len() - 64].to_vec();
140 forged.extend(admin._signer.sign(&forged).unwrap());
141 assert!(admin.verify_member_profile(&forged).is_err());
142 let mut invalid_name = signed[..69].to_vec();
143 invalid_name.extend("Alex\u{202e}Morgan".as_bytes());
144 invalid_name.extend(admin._signer.sign(&invalid_name).unwrap());
145 assert!(admin.verify_member_profile(&invalid_name).is_err());
146
147 assert_eq!(profile.display_name(), "Alex Morgan");
148 assert_ne!(profile.id(), admin.member().unwrap().id());
149 assert_eq!(
150 admin
151 .member_roster()
152 .unwrap()
153 .iter()
154 .filter(|m| m.administrator)
155 .count(),
156 1
157 );
158 admin = admin
159 .prepare_management(super::ManagementAction::Promote(profile.id()))
160 .unwrap()
161 .workspace;
162 assert_eq!(
163 admin
164 .member_roster()
165 .unwrap()
166 .iter()
167 .filter(|m| m.administrator)
168 .count(),
169 2
170 );
171 admin = admin
172 .prepare_management(super::ManagementAction::Remove(profile.id()))
173 .unwrap()
174 .workspace;
175 assert!(admin.verify_member_profile(&second).is_err());
176}