alibi-plugins 0.10.0

Built-in authentication plugins and API metadata for Alibi
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
104
105

use crate::oauth::state::AccountCookiePayload;
use crate::oauth::state::OAuthStatePayload;
use crate::oauth::state::account_cookie_name;
use crate::oauth::state::create_account_cookie_value;
use crate::oauth::state::create_cookie_state_value;
use crate::oauth::state::decode_account_cookie_value;
use crate::oauth::state::state_cookie_name;
use alibi_core::AuthResponse;
use alibi_core::AuthResult;
use alibi_core::utils::cookie_utils::sign_cookie_value;
use chrono::Duration;
pub(in crate::oauth::handlers) fn account_cookie_max_age(config: &alibi_core::AuthConfig) -> f64 {
    if let Some(age) = config.account.cookie_max_age {
        return age;
    }
    config
        .advanced
        .cookies
        .get("account_data")
        .and_then(|cookie| cookie.attributes.max_age)
        .unwrap_or_else(|| {
            alibi_core::session::cookie_cache::effective_max_age(
                config
                    .session
                    .cookie_cache
                    .as_ref()
                    .map_or(300.0, |cache| cache.max_age),
            )
        })
}

/// Emit the encrypted account snapshot and clear stale incoming chunks.
pub(crate) fn create_account_cookie_headers(
    config: &alibi_core::AuthConfig,
    payload: &AccountCookiePayload,
    req: &impl alibi_core::session::SessionRequest,
) -> AuthResult<Vec<String>> {
    let max_age = account_cookie_max_age(config);
    let value = create_account_cookie_value(config, payload, max_age)?;
    alibi_core::session::cookie_cache::runtime::chunked_cookie_headers(
        &account_cookie_name(config),
        &value,
        Some(max_age),
        config,
        req.session_headers(),
        true,
    )
}

pub(in crate::oauth) fn decode_account_cookie(
    req: &impl alibi_core::session::SessionRequest,
    config: &alibi_core::AuthConfig,
) -> AuthResult<Option<AccountCookiePayload>> {
    let Some(value) = alibi_core::session::cookie_cache::runtime::chunked_cookie_value(
        req.session_headers(),
        &account_cookie_name(config),
    ) else {
        return Ok(None);
    };
    decode_account_cookie_value(config, &value).map(Some)
}

pub(in crate::oauth::handlers) fn attach_state_cookie(
    response: AuthResponse,
    config: &alibi_core::AuthConfig,
    secret: &str,
    state: &str,
) -> AuthResult<AuthResponse> {
    Ok(response.with_appended_header("Set-Cookie", state_cookie_header(config, secret, state)?))
}

pub(in crate::oauth) fn state_cookie_header(
    config: &alibi_core::AuthConfig,
    secret: &str,
    state: &str,
) -> AuthResult<String> {
    let value = sign_cookie_value(state, secret);
    alibi_core::utils::cookie_utils::create_cookie(
        &state_cookie_name(config),
        &value,
        Duration::minutes(5).num_seconds(),
        config,
    )
}

pub(in crate::oauth::handlers) fn attach_cookie_state_payload(
    response: AuthResponse,
    config: &alibi_core::AuthConfig,
    payload: &OAuthStatePayload,
) -> AuthResult<AuthResponse> {
    Ok(response.with_appended_header("Set-Cookie", cookie_state_header(config, payload)?))
}

pub(in crate::oauth) fn cookie_state_header(
    config: &alibi_core::AuthConfig,
    payload: &OAuthStatePayload,
) -> AuthResult<String> {
    let value = create_cookie_state_value(config, payload)?;
    alibi_core::utils::cookie_utils::create_cookie(
        &state_cookie_name(config),
        &value,
        Duration::minutes(10).num_seconds(),
        config,
    )
}