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// WASM ABI: `SealedOpenOrgInviteData` marshals as its wire string, matching the JSON wire form.
93#[cfg(feature = "wasm")]
94#[wasm_bindgen::prelude::wasm_bindgen(typescript_custom_section)]
95const TS_CUSTOM_TYPES: &'static str = r#"
96export type SealedOpenOrgInviteData = Tagged<string, "SealedOpenOrgInviteData">;
97"#;
98
99#[cfg(feature = "wasm")]
100impl wasm_bindgen::describe::WasmDescribe for SealedOpenOrgInviteData {
101    fn describe() {
102        <String as wasm_bindgen::describe::WasmDescribe>::describe();
103    }
104}
105
106#[cfg(feature = "wasm")]
107impl wasm_bindgen::convert::FromWasmAbi for SealedOpenOrgInviteData {
108    type Abi = <String as wasm_bindgen::convert::FromWasmAbi>::Abi;
109
110    unsafe fn from_abi(abi: Self::Abi) -> Self {
111        use wasm_bindgen::UnwrapThrowExt;
112        let string = unsafe { String::from_abi(abi) };
113        SealedOpenOrgInviteData::from_str(&string).unwrap_throw()
114    }
115}
116
117#[cfg(feature = "wasm")]
118impl wasm_bindgen::convert::OptionFromWasmAbi for SealedOpenOrgInviteData {
119    fn is_none(abi: &Self::Abi) -> bool {
120        <String as wasm_bindgen::convert::OptionFromWasmAbi>::is_none(abi)
121    }
122}
123
124#[cfg(feature = "wasm")]
125impl wasm_bindgen::convert::IntoWasmAbi for SealedOpenOrgInviteData {
126    type Abi = <String as wasm_bindgen::convert::IntoWasmAbi>::Abi;
127
128    fn into_abi(self) -> Self::Abi {
129        String::from(self).into_abi()
130    }
131}
132
133#[cfg(test)]
134mod tests {
135    use bitwarden_encoding::B64Url;
136
137    use super::*;
138    use crate::registration::open_org_invite_crypto::{OpenOrgInvite, SealedOpenOrgInviteData};
139
140    fn sample_input() -> OpenOrgInvite {
141        OpenOrgInvite {
142            organization_id: "1bc9ac1e-f5aa-45f2-94bf-b181009709b8".to_string(),
143            invite_link_code: "abcd1234efgh5678".to_string(),
144            invite_secret: "raw-invite-secret-material-base64url".to_string(),
145        }
146    }
147
148    #[test]
149    fn sealed_data_wire_is_valid_base64url() {
150        let (sealed_data, _) =
151            SealedOpenOrgInviteData::seal(sample_input()).expect("seal should succeed");
152
153        let wire = String::from(&sealed_data);
154        let decoded =
155            B64Url::try_from(wire.as_str()).expect("sealed_data wire must be valid base64url");
156        assert_eq!(B64Url::from(decoded.as_bytes()).to_string(), wire);
157    }
158
159    #[test]
160    fn parse_rejects_truncated_wire() {
161        let (sealed_data, _) =
162            SealedOpenOrgInviteData::seal(sample_input()).expect("seal should succeed");
163
164        let mut wire = String::from(&sealed_data);
165        wire.truncate(wire.len() / 2);
166
167        let err = wire
168            .parse::<SealedOpenOrgInviteData>()
169            .expect_err("truncated wire must be rejected at parse time");
170        assert!(matches!(err, SealedOpenOrgInviteDataError::Malformed));
171    }
172
173    #[test]
174    fn parse_rejects_malformed_base64url() {
175        let err = "not-valid-base64url!"
176            .parse::<SealedOpenOrgInviteData>()
177            .expect_err("malformed base64url must be rejected at parse time");
178        assert!(matches!(err, SealedOpenOrgInviteDataError::Malformed));
179
180        assert!(B64Url::try_from("not-valid-base64url!").is_err());
181    }
182
183    #[test]
184    fn parse_rejects_valid_cbor_with_bad_key_envelope_bytes() {
185        // Well-formed base64url + CBOR wire whose `k` field bytes don't parse as a
186        // SecretProtectedKeyEnvelope — exercises the parse-envelope failure path.
187        #[derive(serde::Serialize)]
188        struct FakeWire<'a> {
189            #[serde(rename = "d", with = "serde_bytes")]
190            d: &'a [u8],
191            #[serde(rename = "k", with = "serde_bytes")]
192            k: &'a [u8],
193        }
194        let fake = FakeWire {
195            d: &[1, 2, 3, 4],       // DataEnvelope::from is an infallible byte-wrap; that's fine
196            k: &[0xff, 0xff, 0xff], // won't parse as SecretProtectedKeyEnvelope
197        };
198        let mut buf = Vec::new();
199        ciborium::ser::into_writer(&fake, &mut buf).unwrap();
200        let wire = B64Url::from(buf).to_string();
201
202        let err = wire
203            .parse::<SealedOpenOrgInviteData>()
204            .expect_err("bad key-envelope bytes must be rejected at parse time");
205        assert!(matches!(err, SealedOpenOrgInviteDataError::Malformed));
206    }
207}
bitwarden_auth/registration/open_org_invite_crypto/serialization.rs

bitwarden_auth/registration/open_org_invite_crypto/
serialization.rs
