Skip to main content

arachne_security/
profile.rs

1//! Self-authored workspace presentation; never an authorization source.
2use 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    /// A stable chosen name, shareable only within this workspace. Rename ordering
33    /// is not implemented; a valid signature alone would not prove the latest name.
34    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}