1use super::*;
7
8enum Admits {
10 Person(MemberRole),
12 MemberKeys(MemberId),
14}
15
16pub struct NewInvite {
19 admits: Admits,
20 access: InviteAccess,
21 lifetime: InviteLifetime,
22 inviter: String,
23}
24
25impl NewInvite {
26 pub fn person(
32 role: MemberRole,
33 access: InviteAccess,
34 lifetime: InviteLifetime,
35 inviter: String,
36 ) -> Self {
37 Self { admits: Admits::Person(role), access, lifetime, inviter }
38 }
39
40 pub fn member_keys(
44 member: MemberId,
45 access: InviteAccess,
46 lifetime: InviteLifetime,
47 inviter: String,
48 ) -> Self {
49 Self { admits: Admits::MemberKeys(member), access, lifetime, inviter }
50 }
51}
52
53pub(crate) fn make_invite(
70 sql: &SqlContext<'_, '_>,
71 device: DeviceId,
72 held: &MemberIdentity,
73 ids: &dyn IdSource,
74 now: SystemTime,
75 location: &coven_storage::StorageConfig,
76 custody: &crate::DeviceCredentials,
77 invite: NewInvite,
78) -> Result<(InviteId, MemberId, OperationId), SyncError> {
79 let NewInvite { admits, access, lifetime, inviter } = invite;
80 coven_format::value::name(&inviter)?;
81 if matches!(
82 location,
83 coven_storage::StorageConfig::Dropbox {
84 location: coven_storage::DropboxLocation::AppFolder,
85 ..
86 }
87 ) {
88 return Err(StorageFailure::DropboxAppFolderNotShareable.into());
89 }
90 let grant = invite_grant(access, location.provider(), custody)?;
91 let secret = InviteSecret::generate()?;
92 let secret = SecretText::new(serde_json::to_string(secret.to_secret_bytes().as_bytes())?);
93 let expires_at = now.checked_add(lifetime.duration()).ok_or(
94 StorageFailure::InvalidConfiguration
95 .with_source("the clock cannot represent the invite's expiry"),
96 )?;
97 let id = InviteId(ids.new_id());
98 let started_by = match admits {
99 Admits::Person(_) => "create_invite",
100 Admits::MemberKeys(_) => "add_device_for",
101 };
102 let made = sql.journal_step(|journal| {
103 let applied = journal.store_state()?;
104 let me = crate::sequence_sync::registered(&applied, device, held)?;
105 if !applied.active_admin(&me) {
106 return Err(SyncError::Rejected(OperationRejection::NotAllowed));
107 }
108 let (member, binding) = match admits {
109 Admits::Person(role) => (MemberId(ids.new_id()), InviteBinding::Add { role }),
110 Admits::MemberKeys(target) => {
111 let Some(existing) = applied.active_member(&target) else {
112 return Err(SyncError::Rejected(OperationRejection::TargetGone(
113 crate::EntryTarget::Member(target),
114 )));
115 };
116 if target == me {
119 return Err(SyncError::Rejected(OperationRejection::NotAllowed));
120 }
121 if let InviteGrant::Account { email } = &grant {
122 let account = MemberAccess::ProviderAccount(email.clone());
123 if !existing.access.as_ref().is_some_and(|held| held.same_credential(&account))
124 {
125 return Err(StorageFailure::InvalidConfiguration
126 .with_source(
127 "a replacement invite shares the member's recorded account",
128 )
129 .into());
130 }
131 }
132 (target, InviteBinding::Replace { expected: existing.keys })
133 }
134 };
135 let work = InviteWork {
136 id,
137 device,
138 member,
139 inviter,
140 binding,
141 access: grant,
142 secret,
143 expires_at,
144 state: InviteState::Requested,
145 };
146 let operation = journal.start_operation(&NewOperation {
147 kind: operation_kind::INVITE.into(),
148 data: serde_json::to_vec(&work)?,
149 started_by: started_by.into(),
150 pauses_writes: false,
151 })?;
152 Ok((id, member, operation))
153 })?;
154 Ok(made)
155}
156
157fn invite_grant(
161 access: InviteAccess,
162 provider: CloudProvider,
163 custody: &crate::DeviceCredentials,
164) -> Result<InviteGrant, SyncError> {
165 match access {
166 InviteAccess::ProviderAccount { email } => {
167 let email = MemberAccess::normalized_account(&email);
168 if email.is_empty() {
169 return Err(StorageFailure::InvalidConfiguration
170 .with_source("invite account is empty")
171 .into());
172 }
173 if provider == CloudProvider::S3 {
174 return Err(StorageFailure::InvalidConfiguration
175 .with_source("an S3 invitation needs its own access key")
176 .into());
177 }
178 Ok(InviteGrant::Account { email })
179 }
180 InviteAccess::S3AccessKey { .. } | InviteAccess::HeldS3AccessKey
181 if provider != CloudProvider::S3 =>
182 {
183 Err(StorageFailure::InvalidConfiguration
184 .with_source("an access-key invitation requires S3")
185 .into())
186 }
187 InviteAccess::S3AccessKey { access_key_id, secret_access_key } => {
188 let credentials = S3Credentials { access_key_id, secret_access_key };
189 credentials.validate()?;
190 Ok(InviteGrant::S3Key(credentials))
191 }
192 InviteAccess::HeldS3AccessKey => match custody.connection()? {
193 Some(coven_storage::ConnectionCredentials {
194 credentials: coven_storage::StorageCredentials::S3(key),
195 ..
196 }) => Ok(InviteGrant::S3Key(key)),
197 Some(_) | None => Err(StorageFailure::InvalidConfiguration
198 .with_source("this device holds no S3 key to give")
199 .into()),
200 },
201 }
202}
203
204pub(crate) fn approve_request(
219 sql: &SqlContext<'_, '_>,
220 now: SystemTime,
221 request: &JoinRequest,
222) -> Result<(OperationId, OperationId), SyncError> {
223 sql.journal_step(|journal| {
224 let (record, mut work) = invite_record(journal, request.invite)?;
225 if work.expired(now) {
226 return Err(SyncError::InvitationChanged);
227 }
228 let InviteState::Waiting { code, request: Some(stored) } = &work.state else {
229 return Err(SyncError::InvitationChanged);
230 };
231 let (code, stored) = (code.clone(), stored.clone());
232 if work.present_request(&stored)? != *request {
233 return Err(SyncError::InvitationChanged);
234 }
235 let admission = work.binding_admission(&stored)?;
236 let binding =
237 SequenceOperation::admission(admission).start(journal, operation_kind::INVITE)?;
238 work.state = InviteState::Approving { code, request: stored, binding };
239 journal.advance_operation(&work.update(&record)?)?;
240 Ok((record.id, binding))
241 })
242}
243
244pub(crate) fn end_invite(
249 sql: &SqlContext<'_, '_>,
250 now: SystemTime,
251 invite: InviteId,
252 request: Option<&JoinRequest>,
253) -> Result<OperationId, SyncError> {
254 sql.journal_step(|journal| {
255 let (record, mut work) = invite_record(journal, invite)?;
256 if work.expired(now) {
257 return Err(SyncError::InvitationChanged);
258 }
259 match (&work.state, request) {
260 (InviteState::Waiting { request: Some(stored), .. }, Some(request)) => {
261 if work.present_request(stored)? != *request {
262 return Err(SyncError::InvitationChanged);
263 }
264 }
265 (
266 InviteState::Requested
267 | InviteState::Sharing { .. }
268 | InviteState::Grant
269 | InviteState::Waiting { .. },
270 None,
271 ) => {}
272 _ => return Err(SyncError::InvitationChanged),
273 }
274 work.end();
275 journal.advance_operation(&work.update(&record)?)?;
276 Ok(record.id)
277 })
278}
279
280fn invite_record(
283 journal: &Journal<'_>,
284 invite: InviteId,
285) -> Result<(OperationRecord, InviteWork), SyncError> {
286 for record in journal.operations(operation_kind::INVITE)? {
287 let work = InviteWork::read(&record)?;
288 if work.id == invite {
289 return Ok((record, work));
290 }
291 }
292 Err(SyncError::InvitationChanged)
293}
294
295#[cfg(test)]
296#[path = "sequence_invite_steps_tests.rs"]
297mod tests;
298
299#[cfg(any(test, feature = "test-utils"))]
303pub struct RecordedInvite {
304 pub id: InviteId,
306 pub member: MemberId,
308 pub stage: RecordedInviteStage,
310}
311
312#[cfg(any(test, feature = "test-utils"))]
314pub enum RecordedInviteStage {
315 Granting,
317 Waiting {
320 joiner: Option<RecordedJoiner>,
322 },
323 Approving {
326 joiner: RecordedJoiner,
328 binding: OperationId,
330 },
331}
332
333#[cfg(any(test, feature = "test-utils"))]
335pub enum RecordedJoiner {
336 NewPerson(String),
338 Recovering,
341}
342
343#[cfg(any(test, feature = "test-utils"))]
349pub fn invite_operation(invite: RecordedInvite) -> Result<NewOperation, SyncError> {
350 let request = |joiner: &RecordedJoiner| -> Result<Vec<u8>, SyncError> {
351 let mut request = coven_format::test_utils::join_request();
352 request.invite = invite.id;
353 request.member = invite.member;
354 if let RecordedJoiner::NewPerson(name) = joiner {
355 request.joiner = coven_format::objects::Joiner::NewPerson {
356 name: name.clone(),
357 circle: coven_format::objects::JoiningCircle {
358 circle: coven_format::test_utils::recovered_circle(),
359 copy: coven_format::test_utils::recovered_circle_copy(),
360 },
361 };
362 }
363 Ok(Object::JoinRequest(request).encode()?)
364 };
365 let binding = |joiner: Option<&RecordedJoiner>| match joiner {
366 Some(RecordedJoiner::Recovering) => {
367 InviteBinding::Replace { expected: coven_format::test_utils::replacement() }
368 }
369 Some(RecordedJoiner::NewPerson(_)) | None => {
370 InviteBinding::Add { role: MemberRole::Member }
371 }
372 };
373 let code = || SecretText::new("code".into());
374 let (binding, state) = match &invite.stage {
375 RecordedInviteStage::Granting => (binding(None), InviteState::Requested),
376 RecordedInviteStage::Waiting { joiner } => (
377 binding(joiner.as_ref()),
378 InviteState::Waiting {
379 code: code(),
380 request: joiner.as_ref().map(request).transpose()?,
381 },
382 ),
383 RecordedInviteStage::Approving { joiner, binding: claim } => (
384 binding(Some(joiner)),
385 InviteState::Approving { code: code(), request: request(joiner)?, binding: *claim },
386 ),
387 };
388 let work = InviteWork {
389 id: invite.id,
390 device: DeviceId(1),
391 member: invite.member,
392 inviter: "Ana".into(),
393 binding,
394 access: InviteGrant::Account { email: "invited@example.com".into() },
395 secret: SecretText::new(serde_json::to_string(&[7_u8; 32])?),
396 expires_at: std::time::UNIX_EPOCH + std::time::Duration::from_secs(4_000_000_000),
397 state,
398 };
399 Ok(NewOperation {
400 kind: operation_kind::INVITE.into(),
401 data: serde_json::to_vec(&work)?,
402 started_by: "record_invite".into(),
403 pauses_writes: false,
404 })
405}