Add Auth

backend/src/auth.rs

@@ -1,9 +1,9 @@
+use crate::items;
+use crate::proto_utils::Proto;
 use rocket::State;
 use std::collections::HashMap;
 use std::sync::Mutex;
 use uuid::Uuid;
-use crate::items;
-use crate::proto_utils::Proto;
 
 pub struct AuthState {
     // Map token -> username
@@ -21,26 +21,29 @@ impl AuthState {
 #[post("/login", data = "<request>")]
 pub fn login(
     state: &State<AuthState>,
+    user_list: &State<Vec<crate::User>>,
     request: Proto<items::LoginRequest>,
 ) -> items::LoginResponse {
     let req = request.into_inner();
-    // Simple mock authentication: allow any non-empty username/password
-    if !req.username.is_empty() && !req.password.is_empty() {
+
+    if let Some(user) = user_list.iter().find(|u| u.name == req.username)
+        && bcrypt::verify(&req.password, &user.password_hash).unwrap_or(false)
+    {
         let token = Uuid::new_v4().to_string();
         let mut tokens = state.tokens.lock().unwrap();
         tokens.insert(token.clone(), req.username);
-        
-        items::LoginResponse {
+
+        return items::LoginResponse {
             token,
             success: true,
             message: "Login successful".to_string(),
-        }
-    } else {
-        items::LoginResponse {
-            token: "".to_string(),
-            success: false,
-            message: "Invalid credentials".to_string(),
-        }
+        };
+    }
+
+    items::LoginResponse {
+        token: "".to_string(),
+        success: false,
+        message: "Invalid credentials".to_string(),
     }
 }
 
@@ -51,7 +54,7 @@ pub fn logout(
 ) -> items::LogoutResponse {
     let req = request.into_inner();
     let mut tokens = state.tokens.lock().unwrap();
-    
+
     if tokens.remove(&req.token).is_some() {
         items::LogoutResponse {
             success: true,
@@ -72,7 +75,7 @@ pub fn get_auth_status(
 ) -> items::AuthStatusResponse {
     let req = request.into_inner();
     let tokens = state.tokens.lock().unwrap();
-    
+
     if let Some(username) = tokens.get(&req.token) {
         items::AuthStatusResponse {
             authenticated: true,
@@ -86,4 +89,4 @@ pub fn get_auth_status(
             message: "Not authenticated".to_string(),
         }
     }
-}
+}

backend/src/main.rs

@@ -10,21 +10,38 @@ pub mod items {
 mod auth;
 mod proto_utils;
 
+#[derive(Clone)]
+pub struct User {
+    pub person: items::Person,
+    pub password_hash: String,
+}
+
+impl std::ops::Deref for User {
+    type Target = items::Person;
+
+    fn deref(&self) -> &Self::Target {
+        &self.person
+    }
+}
+
 #[get("/<name>")]
-fn get_user(user_list: &rocket::State<Vec<items::Person>>, name: String) -> Option<items::Person> {
-    user_list.iter().find(|user| user.name == name).cloned()
+fn get_user(user_list: &rocket::State<Vec<User>>, name: String) -> Option<items::Person> {
+    user_list
+        .iter()
+        .find(|user| user.person.name == name)
+        .map(|u| u.person.clone())
 }
 
 #[get("/")]
-fn get_users(user_list: &rocket::State<Vec<items::Person>>) -> items::PersonList {
+fn get_users(user_list: &rocket::State<Vec<User>>) -> items::PersonList {
     items::PersonList {
         person: user_list
             .inner()
-            .to_vec()
-            .iter_mut()
-            .map(|x| {
-                x.opinion.clear();
-                x.clone()
+            .iter()
+            .map(|u| {
+                let mut p = u.person.clone();
+                p.opinion.clear();
+                p
             })
             .collect(),
     }
@@ -44,22 +61,25 @@ async fn index_fallback() -> Option<rocket::fs::NamedFile> {
 
 #[launch]
 fn rocket() -> _ {
-    let mut user_list: Vec<items::Person> = Vec::new();
+    let mut user_list: Vec<User> = Vec::new();
 
-    user_list.push(items::Person {
-        name: "John".to_string(),
-        opinion: vec![items::Opinion {
-            game: Some(items::Game {
-                title: "Naramo Nuclear Plant V2".to_string(),
-                source: items::Source::Roblox.into(),
-                multiplayer: true,
-                min_players: 1,
-                max_players: 90,
-                price: 0,
-                remote_id: 0,
-            }),
-            would_play: true,
-        }],
+    user_list.push(User {
+        person: items::Person {
+            name: "John".to_string(),
+            opinion: vec![items::Opinion {
+                game: Some(items::Game {
+                    title: "Naramo Nuclear Plant V2".to_string(),
+                    source: items::Source::Roblox.into(),
+                    multiplayer: true,
+                    min_players: 1,
+                    max_players: 90,
+                    price: 0,
+                    remote_id: 0,
+                }),
+                would_play: true,
+            }],
+        },
+        password_hash: bcrypt::hash("password123", bcrypt::DEFAULT_COST).unwrap(),
     });
 
     rocket::build()
@@ -71,5 +91,5 @@ fn rocket() -> _ {
             routes![auth::login, auth::logout, auth::get_auth_status],
         )
         .mount("/", routes![index_fallback])
-        .mount("/", FileServer::new("../frontend/dist"))
+        .mount("/", FileServer::new("frontend/dist"))
 }

backend/src/proto_utils.rs

@@ -1,7 +1,7 @@
-use rocket::data::{Data, FromData, Outcome, ToByteUnit};
-use rocket::http::{Status, ContentType};
-use rocket::Request;
 use prost::Message;
+use rocket::Request;
+use rocket::data::{Data, FromData, Outcome, ToByteUnit};
+use rocket::http::{ContentType, Status};
 use std::ops::{Deref, DerefMut};
 
 pub struct Proto<T>(pub T);
@@ -31,8 +31,10 @@ impl<'r, T: Message + Default> FromData<'r> for Proto<T> {
     type Error = String;
 
     async fn from_data(req: &'r Request<'_>, data: Data<'r>) -> Outcome<'r, Self> {
-        if req.content_type() != Some(&ContentType::new("application", "protobuf")) {
-             return Outcome::Forward((data, Status::NotFound));
+        if req.content_type() != Some(&ContentType::new("application", "protobuf"))
+            && req.content_type() != Some(&ContentType::new("application", "octet-stream"))
+        {
+            return Outcome::Forward((data, Status::NotFound));
         }
 
         let limit = req.limits().get("protobuf").unwrap_or(1.mebibytes());
@@ -47,4 +49,4 @@ impl<'r, T: Message + Default> FromData<'r> for Proto<T> {
             Err(e) => Outcome::Error((Status::UnprocessableEntity, e.to_string())),
         }
     }
-}
+}