User authentication prototype

Cargo.toml

@@ -5,7 +5,13 @@ edition = "2024"
 
 [dependencies]
 sqlx = {version = "0.9.0", features = ["runtime-tokio", "postgres", "macros", "uuid"]}
-axum = {version = "0.8.9", feature = ["full"]}
+axum = {version = "0.8.9", features = ["macros"]}
 tokio = {version = "1.52.3", features = ["full"]}
 tower = "0.5.3"
 dotenvy = "0.15.7"
+axum-extra = {version = "0.12.6", features = ["cookie"]}
+serde = "1.0.228"
+uuid = {version = "1.23.5", features = ["serde"]}
+tower-http = {version = "0.7.0", features = ["cors"]}
+reqwest = "0.13.4"
+serde_urlencoded = "0.7.1"

src/main.rs

@@ -1,13 +1,16 @@
-use std::error::Error;
 use std::env::var;
+use std::error::Error;
 
+use axum::http::{HeaderValue, Method};
 use axum::routing::get;
-use axum::{serve, Router};
-use tokio::net::TcpListener;
-use sqlx::postgres::PgPool;
+use axum::{Router, serve};
 use dotenvy::dotenv;
+use sqlx::postgres::PgPool;
+use tokio::net::TcpListener;
+use tower_http::cors::CorsLayer;
 
 mod users;
+use users::{login, me};
 
 #[tokio::main]
 async fn main() -> Result<(), Box<dyn Error>> {
@@ -15,12 +18,20 @@ async fn main() -> Result<(), Box<dyn Error>> {
     let db_url = var("DATABASE_URL")?;
     let pool = PgPool::connect(&db_url).await?;
     let app = Router::new()
-        .route("/", get(hello))
+        .route("/status", get(status))
+        .route("/me", get(me))
+        .route("/login", get(login))
+        .layer(
+            CorsLayer::new()
+                .allow_origin("http://localhost:5173".parse::<HeaderValue>().unwrap())
+                .allow_methods([Method::GET])
+                .allow_credentials(true),
+        )
         .with_state(pool);
-    let listener = TcpListener::bind("0.0.0.0:80").await?;
+    let listener = TcpListener::bind("0.0.0.0:8080").await?;
     Ok(serve(listener, app).await?)
 }
 
-async fn hello() -> &'static str {
-    "Hello World"
-}
+async fn status() -> &'static str {
+    "api online"
+}

src/users.rs

@@ -1,37 +1,136 @@
 use std::error::Error;
 
-use axum::routing::{post, get};
-use sqlx::{PgPool, query, query_as, types::Uuid};
+use axum::{
+    Json,
+    extract::{Query, State},
+    http::StatusCode,
+};
+use axum_extra::extract::CookieJar;
+use serde::{Deserialize, Serialize};
+use sqlx::{PgPool, query, types::Uuid};
 
-struct User {
+#[derive(Deserialize, Serialize)]
+pub struct User {
     id: Uuid,
     steamid: String,
     name: String,
-    avatar: String
+    avatar: String,
 }
 
 impl User {
-    fn new(steamid: String, name: String, avatar: String) -> User {
+    fn new<T>(steamid: T, name: T, avatar: T) -> User
+    where
+        String: From<T>,
+    {
         User {
             id: Uuid::nil(),
-            steamid,
-            name,
-            avatar
+            steamid: String::from(steamid),
+            name: String::from(name),
+            avatar: String::from(avatar),
         }
     }
 
-    async fn create(self, pool: PgPool) -> Result<(), Box<dyn Error>>{
-        query!("INSERT INTO users (steamid, name, avatar) VALUES ($1, $2, $3)", self.steamid, self.name, self.avatar).execute(&pool).await?;
+    async fn create(self, pool: PgPool) -> Result<(), Box<dyn Error>> {
+        query!(
+            "INSERT INTO users (steamid, name, avatar) VALUES ($1, $2, $3)",
+            self.steamid,
+            self.name,
+            self.avatar
+        )
+        .execute(&pool)
+        .await?;
         Ok(())
     }
 
-    async fn delete(self, pool: PgPool) -> Result<(), Box<dyn Error>>{
-        query!("DELETE FROM users WHERE id=$1", self.id).execute(&pool).await?;
+    async fn delete(self, pool: PgPool) -> Result<(), Box<dyn Error>> {
+        query!("DELETE FROM users WHERE id=$1", self.id)
+            .execute(&pool)
+            .await?;
         Ok(())
     }
 
-    async fn update(self, pool: PgPool) -> Result<(), Box<dyn Error>>{
-        query!("UPDATE users SET steamid=$1, name=$2, avatar=$3 WHERE id=$4", self.steamid, self.name, self.avatar, self.id).execute(&pool).await?;
+    async fn update(self, pool: PgPool) -> Result<(), Box<dyn Error>> {
+        query!(
+            "UPDATE users SET steamid=$1, name=$2, avatar=$3 WHERE id=$4",
+            self.steamid,
+            self.name,
+            self.avatar,
+            self.id
+        )
+        .execute(&pool)
+        .await?;
         Ok(())
     }
-}
+}
+
+#[axum::debug_handler]
+pub async fn me(State(pool): State<PgPool>, jar: CookieJar) -> Json<Option<User>> {
+    if let Some(cookie) = jar.get("token") {
+        println!("Cookie received: {cookie}");
+        Json(Some(User::new(
+            "76561198840243902",
+            "p0rning AINDUSTRIES",
+            "https://avatars.steamstatic.com/c6975c06a7a7cb874c8f95ed5a10c8a25c936a6b_full.jpg",
+        )))
+    } else {
+        println!("No cookie received");
+        Json(None)
+    }
+}
+
+#[derive(Deserialize, Serialize)]
+pub struct OpenId {
+    #[serde(rename = "openid.ns")]
+    ns: String,
+
+    #[serde(rename = "openid.mode")]
+    mode: String,
+
+    #[serde(rename = "openid.op_endpoint")]
+    op_endpoint: String,
+
+    #[serde(rename = "openid.claimed_id")]
+    claimed_id: String,
+
+    #[serde(rename = "openid.identity")]
+    identity: String,
+
+    #[serde(rename = "openid.return_to")]
+    return_to: String,
+
+    #[serde(rename = "openid.response_nonce")]
+    response_nonce: String,
+
+    #[serde(rename = "openid.assoc_handle")]
+    assoc_handle: String,
+
+    #[serde(rename = "openid.signed")]
+    signed: String,
+
+    #[serde(rename = "openid.sig")]
+    sig: String,
+}
+
+#[axum::debug_handler]
+pub async fn login(
+    State(pool): State<PgPool>,
+    Query(mut info): Query<OpenId>,
+) -> Result<String, StatusCode> {
+    info.mode = "check_authentication".into();
+    if let Ok(url_encoded) = serde_urlencoded::to_string(info) {
+        println!("https://steamcommunity.com/openid/login?{url_encoded}");
+        let response = reqwest::get(format!(
+            "https://steamcommunity.com/openid/login?{url_encoded}"
+        ))
+        .await
+        .map_err(|_| StatusCode::INTERNAL_SERVER_ERROR)?
+        .text()
+        .await
+        .map_err(|_| StatusCode::INTERNAL_SERVER_ERROR)?;
+        println!("{response}");
+        if response.contains("is_valid:true") {
+            return Ok("ok".to_string());
+        }
+    }
+    Ok("nok".to_string())
+}