portier 0.2.0

Portier client for Rust
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

//! Small example application for Portier using the Rocket framework.

use log::error;
use rocket::{
    form::Form,
    get,
    http::{uri::Absolute, Status},
    launch, post,
    response::{content::RawHtml, Redirect},
    routes, FromForm, State,
};

/// Struct used to deserialize form data for `POST /auth`.
#[derive(FromForm)]
struct AuthForm {
    email: String,
}

/// Struct used to deserialize form data for `POST /verify`.
#[derive(FromForm)]
struct VerifyForm {
    id_token: String,
}

/// Render a simple index page with a login form.
#[get("/")]
fn index() -> RawHtml<&'static str> {
    RawHtml(
        r#"
        <p>Enter your email address:</p>
        <form method="post" action="/auth">
          <input name="email" type="email">
          <button type="submit">Login</button>
        </form>
        "#,
    )
}

/// Handle the login form `POST /auth` request.
///
/// This creates a login session using `portier::Client::start_auth`, and redirects the browser to
/// complete the login.
#[post("/auth", data = "<form>")]
async fn auth(form: Form<AuthForm>, client: &State<portier::Client>) -> Result<Redirect, Status> {
    let url = client.start_auth(&form.email).await.map_err(|err| {
        error!("Portier start_auth error: {}", err);
        Status::InternalServerError
    })?;

    Ok(Redirect::to(Absolute::parse_owned(url.into()).unwrap()))
}

/// Handle the Portier response that arrives as a `POST /verify` request.
///
/// Once the broker has authenticated the user, the user agent is instructed to make this `POST`
/// request to us. The request contains a token we can verify using `portier::Client::verify`,
/// which checks that the signature on the token is correct, then extracts the email address
/// contained within.
///
/// Our example application renders a simple page showing that email address.
#[post("/verify", data = "<form>")]
async fn verify(
    form: Form<VerifyForm>,
    client: &State<portier::Client>,
) -> Result<RawHtml<String>, Status> {
    let email = client.verify(&form.id_token).await.map_err(|err| {
        error!("Portier verify error: {}", err);
        Status::InternalServerError
    })?;

    Ok(RawHtml(format!("<p>Verified email address {}!</p>", email)))
}

/// Rocket entry-point.
#[launch]
fn rocket() -> _ {
    let redirect_uri = "http://localhost:8000/verify".parse().unwrap();
    rocket::build()
        .mount("/", routes![index, auth, verify])
        .manage(portier::Client::new(redirect_uri))
}