#web-framework #firebase #actix-web #authentication

firebase-auth

Firebase authentication extractor for Actix Web and Axum

13 unstable releases (3 breaking)

0.4.2 Feb 2, 2024
0.4.1 Dec 23, 2023
0.3.2 Feb 2, 2024
0.3.1 Nov 1, 2023
0.1.2 Aug 11, 2022

#91 in HTTP server

Download history 61/week @ 2023-11-20 128/week @ 2023-11-27 80/week @ 2023-12-04 48/week @ 2023-12-11 259/week @ 2023-12-18 129/week @ 2023-12-25 128/week @ 2024-01-01 195/week @ 2024-01-08 267/week @ 2024-01-15 132/week @ 2024-01-22 269/week @ 2024-01-29 323/week @ 2024-02-05 346/week @ 2024-02-12 513/week @ 2024-02-19 470/week @ 2024-02-26 263/week @ 2024-03-04

1,610 downloads per month

MIT license

21KB
335 lines

Firebase Auth

A simple and small Rust library for handling Firebase Authorization.

Supports the two most popular frameworks: Tokio's Axum and Actix-web.

Build badge crates.io badge

Notice

Version 0.4.x supports Axum 0.7.

Version 0.3.x will continue to provide support and fix bugs for Axum 0.6.

Setup

Actix

[dependencies]
firebase-auth = { version = "<version>", features = ["actix-web"] }
actix-web = "4"

Axum

[dependencies]
firebase-auth = { version = "<version>", features = ["axum"] }
axum = "0.7"

Examples

Actix

https://github.com/trchopan/firebase-auth/tree/main/examples/actix_basic.rs

use actix_web::{get, middleware::Logger, web::Data, App, HttpServer, Responder};
use firebase_auth::{FirebaseAuth, FirebaseUser};

// Use `FirebaseUser` extractor to verify the user token and decode the claims
#[get("/hello")]
async fn greet(user: FirebaseUser) -> impl Responder {
    let email = user.email.unwrap_or("empty email".to_string());
    format!("Hello {}!", email)
}

#[actix_web::main]
async fn main() -> std::io::Result<()> {
    let firebase_auth = FirebaseAuth::new("my-project-id").await;

    let app_data = Data::new(firebase_auth);

    HttpServer::new(move || {
        App::new()
            .wrap(Logger::default())
            .app_data(app_data.clone())
            .service(greet)
    })
    .bind(("127.0.0.1", 8080))?
    .run()
    .await
}

Axum

https://github.com/trchopan/firebase-auth/tree/main/examples/axum_basic.rs

use axum::{routing::get, Router};
use firebase_auth::{FirebaseAuth, FirebaseAuthState, FirebaseUser};

async fn greet(current_user: FirebaseUser) -> String {
    let email = current_user.email.unwrap_or("empty email".to_string());
    format!("hello {}", email)
}

async fn public() -> &'static str {
    "ok"
}

#[tokio::main]
async fn main() {
    let firebase_auth = FirebaseAuth::new("my-project-id").await;

    let app = Router::new()
        .route("/hello", get(greet))
        .route("/", get(public))
        .with_state(FirebaseAuthState { firebase_auth });

    let addr = "127.0.0.1:8080";
    let listener = tokio::net::TcpListener::bind(addr).await.unwrap();

    axum::serve(listener, app).await.unwrap();
}

More complete example with Axum, SQLite and slqx

examples/axum-sqlite

This is more real world application with Firebase Authentication and SQLite as database.

Using Custom Claims

examples/actix-web-custom-claims

examples/axum-custom-claims

Custom claims are provided as defined FirebaseUser struct and use actix or axum trait to implement the extraction from the request.

How to call the endpoint with Bearer Token

Obtain the Bearer token

Use firebase sdk to get the User Token.

For example: getIdToken()

Request the endpoint with Authorization Bearer

Make the request using the User's token. Note that it will expire so you will need to get it again if expired.

TOKEN="<paste your token here>"

curl --header "Authorization: Bearer $TOKEN" http://127.0.0.1:8080/hello

Firebase Document

Verify ID tokens using a third-party JWT library

License

MIT

Copyright (c) 2022-, Quang Tran.

Dependencies

~19–34MB
~630K SLoC