bitwarden_auth/registration/open_org_invite_crypto/
serialization.rs

1//! Wire encoding for [`SealedOpenOrgInviteData`]. Its two internal envelopes are packed with
2//! CBOR (compact binary format) then base64url-wrapped so it crosses every boundary as one
3//! opaque string — via serde on the Rust side and the WASM ABI (wasm-bindgen's Rust↔JS
4//! conversion layer) into TypeScript.
5
6use std::str::FromStr;
7
8use bitwarden_crypto::safe::{DataEnvelope, SecretProtectedKeyEnvelope};
9use bitwarden_encoding::{B64Url, FromStrVisitor};
10use serde::{Deserialize, Serialize};
11use thiserror::Error;
12
13use super::SealedOpenOrgInviteData;
14
15/// Intermediate shape used to (de)serialize [`SealedOpenOrgInviteData`] to and from its wire
16/// bytes. Each envelope is carried as raw bytes under a short field name for compactness.
17#[derive(Serialize, Deserialize)]
18struct SealedOpenOrgInviteDataWire {
19    // Without serde_bytes, Vec<u8> encodes as a CBOR array of integers (~2x the size).
20    /// Bytes of the data envelope (OpenOrgInvite plaintext encrypted under a fresh CEK).
21    #[serde(rename = "d", with = "serde_bytes")]
22    data_envelope: Vec<u8>,
23    /// Bytes of the key envelope (the CEK encrypted under the caller's HighEntropySecret).
24    #[serde(rename = "k", with = "serde_bytes")]
25    key_envelope: Vec<u8>,
26}
27
28/// Errors returned when parsing a [`SealedOpenOrgInviteData`] from its wire form.
29#[derive(Debug, Error)]
30pub enum SealedOpenOrgInviteDataError {
31    /// The wire string could not be decoded.
32    #[error("Sealed open org invite data is malformed")]
33    Malformed,
34}
35
36impl FromStr for SealedOpenOrgInviteData {
37    type Err = SealedOpenOrgInviteDataError;
38
39    fn from_str(s: &str) -> Result<Self, Self::Err> {
40        let outer = B64Url::try_from(s).map_err(|_| SealedOpenOrgInviteDataError::Malformed)?;
41        let wire: SealedOpenOrgInviteDataWire = ciborium::de::from_reader(outer.as_bytes())
42            .map_err(|_| SealedOpenOrgInviteDataError::Malformed)?;
43        let data_envelope = DataEnvelope::from(wire.data_envelope);
44        let key_envelope = SecretProtectedKeyEnvelope::try_from(&wire.key_envelope)
45            .map_err(|_| SealedOpenOrgInviteDataError::Malformed)?;
46        Ok(SealedOpenOrgInviteData {
47            data_envelope,
48            key_envelope,
49        })
50    }
51}
52
53impl From<&SealedOpenOrgInviteData> for String {
54    fn from(val: &SealedOpenOrgInviteData) -> Self {
55        let data_bytes: Vec<u8> = (&val.data_envelope).into();
56        let key_bytes: Vec<u8> = (&val.key_envelope).into();
57        let wire = SealedOpenOrgInviteDataWire {
58            data_envelope: data_bytes,
59            key_envelope: key_bytes,
60        };
61        let mut buf = Vec::new();
62        ciborium::ser::into_writer(&wire, &mut buf)
63            .expect("CBOR encoding of two byte fields cannot fail");
64        B64Url::from(buf).to_string()
65    }
66}
67
68impl From<SealedOpenOrgInviteData> for String {
69    fn from(val: SealedOpenOrgInviteData) -> Self {
70        (&val).into()
71    }
72}
73
74impl Serialize for SealedOpenOrgInviteData {
75    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
76    where
77        S: serde::Serializer,
78    {
79        serializer.serialize_str(&String::from(self))
80    }
81}
82
83impl<'de> Deserialize<'de> for SealedOpenOrgInviteData {
84    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
85    where
86        D: serde::Deserializer<'de>,
87    {
88        deserializer.deserialize_str(FromStrVisitor::new())
89    }
90}
91
92#[cfg(feature = "wasm")]
93impl wasm_bindgen::describe::WasmDescribe for SealedOpenOrgInviteData {
94    fn describe() {
95        <String as wasm_bindgen::describe::WasmDescribe>::describe();
96    }
97}
98
99#[cfg(feature = "wasm")]
100impl wasm_bindgen::convert::FromWasmAbi for SealedOpenOrgInviteData {
101    type Abi = <String as wasm_bindgen::convert::FromWasmAbi>::Abi;
102
103    unsafe fn from_abi(abi: Self::Abi) -> Self {
104        use wasm_bindgen::UnwrapThrowExt;
105        let string = unsafe { String::from_abi(abi) };
106        SealedOpenOrgInviteData::from_str(&string).unwrap_throw()
107    }
108}
109
110#[cfg(feature = "wasm")]
111impl wasm_bindgen::convert::OptionFromWasmAbi for SealedOpenOrgInviteData {
112    fn is_none(abi: &Self::Abi) -> bool {
113        <String as wasm_bindgen::convert::OptionFromWasmAbi>::is_none(abi)
114    }
115}
116
117#[cfg(feature = "wasm")]
118impl wasm_bindgen::convert::IntoWasmAbi for SealedOpenOrgInviteData {
119    type Abi = <String as wasm_bindgen::convert::IntoWasmAbi>::Abi;
120
121    fn into_abi(self) -> Self::Abi {
122        String::from(self).into_abi()
123    }
124}
125
126#[cfg(test)]
127mod tests {
128    use bitwarden_encoding::B64Url;
129
130    use super::*;
131    use crate::registration::open_org_invite_crypto::{OpenOrgInvite, SealedOpenOrgInviteData};
132
133    fn sample_input() -> OpenOrgInvite {
134        OpenOrgInvite {
135            organization_id: "1bc9ac1e-f5aa-45f2-94bf-b181009709b8".to_string(),
136            invite_link_code: "abcd1234efgh5678".to_string(),
137            invite_secret: "raw-invite-secret-material-base64url".to_string(),
138        }
139    }
140
141    #[test]
142    fn sealed_data_wire_is_valid_base64url() {
143        let (sealed_data, _) =
144            SealedOpenOrgInviteData::seal(sample_input()).expect("seal should succeed");
145
146        let wire = String::from(&sealed_data);
147        let decoded =
148            B64Url::try_from(wire.as_str()).expect("sealed_data wire must be valid base64url");
149        assert_eq!(B64Url::from(decoded.as_bytes()).to_string(), wire);
150    }
151
152    #[test]
153    fn parse_rejects_truncated_wire() {
154        let (sealed_data, _) =
155            SealedOpenOrgInviteData::seal(sample_input()).expect("seal should succeed");
156
157        let mut wire = String::from(&sealed_data);
158        wire.truncate(wire.len() / 2);
159
160        let err = wire
161            .parse::<SealedOpenOrgInviteData>()
162            .expect_err("truncated wire must be rejected at parse time");
163        assert!(matches!(err, SealedOpenOrgInviteDataError::Malformed));
164    }
165
166    #[test]
167    fn parse_rejects_malformed_base64url() {
168        let err = "not-valid-base64url!"
169            .parse::<SealedOpenOrgInviteData>()
170            .expect_err("malformed base64url must be rejected at parse time");
171        assert!(matches!(err, SealedOpenOrgInviteDataError::Malformed));
172
173        assert!(B64Url::try_from("not-valid-base64url!").is_err());
174    }
175
176    #[test]
177    fn parse_rejects_valid_cbor_with_bad_key_envelope_bytes() {
178        // Well-formed base64url + CBOR wire whose `k` field bytes don't parse as a
179        // SecretProtectedKeyEnvelope — exercises the parse-envelope failure path.
180        #[derive(serde::Serialize)]
181        struct FakeWire<'a> {
182            #[serde(rename = "d", with = "serde_bytes")]
183            d: &'a [u8],
184            #[serde(rename = "k", with = "serde_bytes")]
185            k: &'a [u8],
186        }
187        let fake = FakeWire {
188            d: &[1, 2, 3, 4],       // DataEnvelope::from is an infallible byte-wrap; that's fine
189            k: &[0xff, 0xff, 0xff], // won't parse as SecretProtectedKeyEnvelope
190        };
191        let mut buf = Vec::new();
192        ciborium::ser::into_writer(&fake, &mut buf).unwrap();
193        let wire = B64Url::from(buf).to_string();
194
195        let err = wire
196            .parse::<SealedOpenOrgInviteData>()
197            .expect_err("bad key-envelope bytes must be rejected at parse time");
198        assert!(matches!(err, SealedOpenOrgInviteDataError::Malformed));
199    }
200}
bitwarden_auth/registration/open_org_invite_crypto/serialization.rs

bitwarden_auth/registration/open_org_invite_crypto/
serialization.rs
