oauth 0.0.2

Universal OAuth 2.0 adapter for Rust web frameworks
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

use std::sync::Arc;

use rocket::fairing::AdHoc;
use rocket::http::Status;
use rocket::serde::json::Json;
use serde::Serialize;

use crate::OAuthConfig;
use crate::error::OAuthError;
use crate::grants::{self, TokenRequest, TokenResponse};

/// Fairing that injects the shared [`OAuthConfig`] into Rocket state.
pub fn manage(config: Arc<OAuthConfig>) -> AdHoc {
    AdHoc::on_ignite("OAuth configuration", |rocket| async move {
        rocket.manage(config)
    })
}

/// Routes exposing the OAuth token endpoint.
pub fn oauth_routes() -> Vec<rocket::Route> {
    rocket::routes![token_endpoint]
}

#[rocket::post("/oauth/token", format = "json", data = "<request>")]
async fn token_endpoint(
    config: &rocket::State<Arc<OAuthConfig>>,
    request: Json<TokenRequest>,
) -> Result<Json<TokenResponse>, (Status, Json<ErrorBody>)> {
    match grants::issue_token(config.inner().as_ref(), request.into_inner()) {
        Ok(token) => Ok(Json(token)),
        Err(err) => {
            let status = Status::from_code(err.status_code().as_u16())
                .unwrap_or(Status::InternalServerError);
            Err((status, Json(ErrorBody::from(&err))))
        }
    }
}

#[derive(Serialize)]
struct ErrorBody {
    error: String,
    #[serde(skip_serializing_if = "Option::is_none")]
    error_description: Option<String>,
}

impl From<&OAuthError> for ErrorBody {
    fn from(err: &OAuthError) -> Self {
        let error = match err {
            OAuthError::InvalidClient => "invalid_client",
            OAuthError::UnsupportedGrant(_) | OAuthError::NotImplemented(_) => {
                "unsupported_grant_type"
            }
            OAuthError::InvalidGrant(_) => "invalid_grant",
            OAuthError::InvalidScope(_) => "invalid_scope",
            OAuthError::Config(_) | OAuthError::TokenStore(_) | OAuthError::Internal(_) => {
                "server_error"
            }
        }
        .to_string();

        let error_description = match err {
            OAuthError::UnsupportedGrant(message)
            | OAuthError::InvalidGrant(message)
            | OAuthError::InvalidScope(message)
            | OAuthError::Internal(message) => Some(message.clone()),
            OAuthError::NotImplemented(message) => Some((*message).into()),
            _ => None,
        };

        Self {
            error,
            error_description,
        }
    }
}