sofie-identity 0.2.0

Accounts, their area memberships, and signing up, in and out: the identity an app opts into.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103

use sofie::http::{Routes, Web};
use sofie::prelude::*;

use super::{Mailed, link_routes};
use crate::account::{Account, Distrusted};
use crate::account_link::{AccountLink, LinkPurpose};
use crate::{MemberArea, Password, PasswordHash};

struct Reset;

impl Mailed for Reset {
    const PURPOSE: LinkPurpose = LinkPurpose::PasswordReset;
    const ASKING: &'static str = "/forgot-password";
    const SCREENS: [&'static str; 2] = ["forgot_password", "reset_password"];
    const NAMES: [&'static str; 3] = ["forgot_page", "ask_reset", "reset_page"];
}

#[derive(Input)]
pub struct NewPassword {
    new_password: Password,
}

pub(super) fn routes<A: MemberArea>(routes: &mut Routes<Web>) {
    let reset = link_routes::<A, Reset>(routes);
    routes
        .post(&reset, reset_password)
        .name_for::<A>("reset_password")
        .signed()
        .then_redirect(A::SIGN_IN);
}

#[cfg(feature = "sessions")]
type Ended = crate::sessions::Ended;
#[cfg(not(feature = "sessions"))]
type Ended = ();

#[cfg(feature = "tokens")]
type Revoked = Vec<crate::tokens::AccessToken>;
#[cfg(not(feature = "tokens"))]
type Revoked = ();

/// Uses up every other unused link of the account too, so no older mail opens it, and
/// revokes its access tokens, which a thief of the old password may have issued.
/// With `sessions`, every session of the account ends; without, sessions live only in
/// their cookies, so ones already open elsewhere stay open. A reset proving the address
/// for the first time distrusts the account before setting the password, as a sign-in link does.
async fn reset_password(
    mut link: AccountLink,
    chosen: NewPassword,
    read: Read,
    clock: Clock,
) -> Result<(
    Account,
    Vec<AccountLink>,
    Option<Distrusted>,
    Option<(Ended, Revoked)>,
)> {
    let now = clock.now();
    link.use_up(Reset::PURPOSE, now)?;
    let mut account = Account::stored(&read, link.account()).await?;
    let distrusted = account.prove_email(&read, now).await?;
    account.change_password(PasswordHash::new(&chosen.new_password).await?);
    let mut others = AccountLink::query()
        .where_(AccountLink::ACCOUNT.eq(link.account()))
        .where_(AccountLink::USED_AT.is_null())
        .where_(AccountLink::EXPIRES_AT.gt(now))
        .all(&read)
        .await?;
    others.retain(|other| other.id() != link.id());
    for other in &mut others {
        other.retire(now);
    }
    others.push(link);
    let signed_out = match distrusted {
        Some(_) => None,
        None => Some(signed_out(&read, account.id(), now).await?),
    };
    Ok((account, others, distrusted, signed_out))
}

#[cfg_attr(
    not(any(feature = "sessions", feature = "tokens")),
    expect(clippy::unused_async)
)]
async fn signed_out(
    read: &Read,
    account: crate::AccountId,
    now: sofie::core::Instant,
) -> Result<(Ended, Revoked)> {
    #[cfg(feature = "sessions")]
    let ended = crate::sessions::ending_all(read, account, None, now).await?;
    #[cfg(not(feature = "sessions"))]
    let ended = ();
    #[cfg(feature = "tokens")]
    let revoked = crate::tokens::revoking(read, account).await?;
    #[cfg(not(feature = "tokens"))]
    let revoked = ();
    #[cfg(not(feature = "sessions"))]
    let _ = now;
    #[cfg(not(any(feature = "sessions", feature = "tokens")))]
    let _ = (read, account);
    Ok((ended, revoked))
}