accounts are now real

src/bin/server/db.rs

@@ -1,11 +1,90 @@
-use std::path::Path;
+use std::{
+    marker::PhantomData,
+    ops::{Deref, DerefMut},
+    path::Path,
+};
 
 use bincode::{Decode, Encode};
 use openworm::net::BINCODE_CONFIG;
-use sled::{Db, Tree};
+use sled::Tree;
 
 pub const DB_VERSION: u64 = 0;
 
+#[derive(Encode, Decode)]
+pub struct User {
+    pub username: String,
+    pub password_hash: String,
+}
+
+#[derive(Clone, Encode, Decode)]
+pub struct Msg {
+    pub user: u64,
+    pub content: String,
+}
+
+#[derive(Clone)]
+pub struct Db {
+    pub db: sled::Db,
+    pub msgs: DbMap<u64, Msg>,
+    pub users: DbMap<u64, User>,
+    pub usernames: DbMap<String, u64>,
+}
+
+pub struct DbMap<K, V> {
+    tree: Tree,
+    _pd: PhantomData<(K, V)>,
+}
+
+pub trait Key {
+    type Output<'a>: AsRef<[u8]>
+    where
+        Self: 'a;
+    fn bytes(&self) -> Self::Output<'_>;
+}
+
+impl Key for String {
+    type Output<'a> = &'a Self;
+    fn bytes(&self) -> Self::Output<'_> {
+        self
+    }
+}
+
+impl Key for str {
+    type Output<'a> = &'a Self;
+    fn bytes(&self) -> Self::Output<'_> {
+        self
+    }
+}
+
+impl Key for u64 {
+    type Output<'a> = [u8; 8];
+
+    fn bytes(&self) -> Self::Output<'_> {
+        self.to_be_bytes()
+    }
+}
+
+impl<K: Key, V: Encode + Decode<()>> DbMap<K, V> {
+    pub fn insert(&self, k: &K, v: &V) {
+        self.tree.insert_(k, v);
+    }
+
+    pub fn get(&self, k: &K) -> Option<V> {
+        self.tree.get_(k)
+    }
+
+    pub fn init_unique(&self, k: &K) -> bool {
+        self.tree
+            .compare_and_swap(k.bytes(), None as Option<&[u8]>, Some(&[0]))
+            .unwrap()
+            .is_ok()
+    }
+
+    pub fn iter_all(&self) -> impl Iterator<Item = V> {
+        self.tree.iter_all()
+    }
+}
+
 pub fn open_db(path: impl AsRef<Path>) -> Db {
     let db = sled::open(path).expect("failed to open database");
     if !db.was_recovered() {
@@ -19,23 +98,28 @@ pub fn open_db(path: impl AsRef<Path>) -> Db {
             panic!("non matching db version! (auto update in the future)");
         }
     }
-    db
+    Db {
+        msgs: open_tree("msg", &db),
+        users: open_tree("user", &db),
+        usernames: open_tree("username", &db),
+        db,
+    }
 }
 
-pub trait DbUtil {
-    fn insert_<K: AsRef<[u8]>, V: Encode>(&self, k: K, v: V);
-    fn get_<K: AsRef<[u8]>, V: Decode<()>>(&self, k: K) -> Option<V>;
+trait DbUtil {
+    fn insert_<V: Encode>(&self, k: &(impl Key + ?Sized), v: V);
+    fn get_<V: Decode<()>>(&self, k: &(impl Key + ?Sized)) -> Option<V>;
     fn iter_all<V: Decode<()>>(&self) -> impl Iterator<Item = V>;
 }
 
 impl DbUtil for Tree {
-    fn insert_<K: AsRef<[u8]>, V: Encode>(&self, k: K, v: V) {
+    fn insert_<V: Encode>(&self, k: &(impl Key + ?Sized), v: V) {
         let bytes = bincode::encode_to_vec(v, BINCODE_CONFIG).unwrap();
-        self.insert(k, bytes).unwrap();
+        self.insert(k.bytes(), bytes).unwrap();
     }
 
-    fn get_<K: AsRef<[u8]>, V: Decode<()>>(&self, k: K) -> Option<V> {
-        let bytes = self.get(k).unwrap()?;
+    fn get_<V: Decode<()>>(&self, k: &(impl Key + ?Sized)) -> Option<V> {
+        let bytes = self.get(k.bytes()).unwrap()?;
         Some(
             bincode::decode_from_slice(&bytes, BINCODE_CONFIG)
                 .unwrap()
@@ -51,3 +135,33 @@ impl DbUtil for Tree {
         })
     }
 }
+
+pub fn open_tree<K, V>(name: &str, db: &sled::Db) -> DbMap<K, V> {
+    DbMap {
+        tree: db.open_tree(name).unwrap(),
+        _pd: PhantomData,
+    }
+}
+
+impl Deref for Db {
+    type Target = sled::Db;
+
+    fn deref(&self) -> &Self::Target {
+        &self.db
+    }
+}
+
+impl DerefMut for Db {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.db
+    }
+}
+
+impl<K, V> Clone for DbMap<K, V> {
+    fn clone(&self) -> Self {
+        Self {
+            tree: self.tree.clone(),
+            _pd: self._pd.clone(),
+        }
+    }
+}

src/bin/server/main.rs

@@ -2,14 +2,20 @@
 mod db;
 mod net;
 
-use crate::db::{DbUtil, open_db};
+use crate::db::{Db, Msg, User, open_db};
 use clap::Parser;
 use net::{ClientSender, ConAccepter, listen};
 use openworm::{
-    net::{ClientMsg, DisconnectReason, RecvHandler, ServerMsg, install_crypto_provider},
+    net::{
+        ClientMsg, DisconnectReason, NetServerMsg, RecvHandler, ServerError, ServerMsg,
+        install_crypto_provider,
+    },
     rsc::DataDir,
 };
-use sled::{Db, Tree};
+use scrypt::{
+    Scrypt,
+    password_hash::{PasswordHash, PasswordHasher, PasswordVerifier, SaltString, rand_core::OsRng},
+};
 use std::{
     collections::HashMap,
     sync::{
@@ -39,7 +45,6 @@ pub async fn run_server(port: u16) {
     let path = dir.get();
     let db: Db = open_db(path.join("server.db"));
     let handler = ServerListener {
-        msgs: db.open_tree("msgs").unwrap(),
         senders: Default::default(),
         count: 0.into(),
         db: db.clone(),
@@ -60,19 +65,24 @@ type ClientId = u64;
 
 struct ServerListener {
     db: Db,
-    msgs: Tree,
     senders: Arc<RwLock<HashMap<ClientId, ClientSender>>>,
     count: AtomicU64,
 }
 
+#[derive(PartialEq, Eq, Clone, Copy)]
+pub enum ClientState {
+    Login,
+    Authed(u64),
+}
+
 impl ConAccepter for ServerListener {
     async fn accept(&self, send: ClientSender) -> impl RecvHandler<ClientMsg> {
         let id = self.count.fetch_add(1, Ordering::Release);
         self.senders.write().await.insert(id, send.clone());
         ClientHandler {
             db: self.db.clone(),
-            msgs: self.msgs.clone(),
             senders: self.senders.clone(),
+            state: Arc::new(RwLock::new(ClientState::Login)),
             send,
             id,
         }
@@ -81,22 +91,35 @@ impl ConAccepter for ServerListener {
 
 struct ClientHandler {
     db: Db,
-    msgs: Tree,
     send: ClientSender,
     senders: Arc<RwLock<HashMap<ClientId, ClientSender>>>,
     id: ClientId,
+    state: Arc<RwLock<ClientState>>,
 }
 
 impl RecvHandler<ClientMsg> for ClientHandler {
     async fn connect(&self) -> () {
-        println!("connected: {:?}", self.send.remote());
+        println!("connected: {:?}", self.send.remote().ip());
     }
     async fn msg(&self, msg: ClientMsg) {
         match msg {
             ClientMsg::SendMsg(msg) => {
+                let ClientState::Authed(uid) = &*self.state.read().await else {
+                    let _ = self.send.send(ServerError::NotLoggedIn).await;
+                    return;
+                };
+                let msg = Msg {
+                    user: *uid,
+                    content: msg.content,
+                };
                 let id = self.db.generate_id().unwrap();
-                self.msgs.insert_(id.to_be_bytes(), &msg);
+                self.db.msgs.insert(&id, &msg);
                 let mut handles = Vec::new();
+                let user: User = self.db.users.get(uid).unwrap();
+                let msg = NetServerMsg {
+                    content: msg.content,
+                    user: user.username,
+                };
                 for (&id, send) in self.senders.read().await.iter() {
                     if id == self.id {
                         continue;
@@ -104,7 +127,7 @@ impl RecvHandler<ClientMsg> for ClientHandler {
                     let send = send.clone();
                     let msg = msg.clone();
                     let fut = async move {
-                        let _ = send.send(ServerMsg::SendMsg(msg)).await;
+                        let _ = send.send(msg).await;
                     };
                     handles.push(tokio::spawn(fut));
                 }
@@ -113,17 +136,85 @@ impl RecvHandler<ClientMsg> for ClientHandler {
                 }
             }
             ClientMsg::RequestMsgs => {
-                let msgs = self.msgs.iter_all().collect();
+                let ClientState::Authed(_uid) = &*self.state.read().await else {
+                    let _ = self.send.send(ServerError::NotLoggedIn).await;
+                    return;
+                };
+                let msgs = self
+                    .db
+                    .msgs
+                    .iter_all()
+                    .map(|msg| {
+                        let user = self
+                            .db
+                            .users
+                            .get(&msg.user)
+                            .map(|user| user.username.to_string())
+                            .unwrap_or("deleted user".to_string());
+                        NetServerMsg {
+                            content: msg.content,
+                            user,
+                        }
+                    })
+                    .collect();
                 let _ = self.send.send(ServerMsg::LoadMsgs(msgs)).await;
             }
+            ClientMsg::CreateAccount { username, password } => {
+                if !self.db.usernames.init_unique(&username) {
+                    let _ = self.send.send(ServerError::UsernameTaken).await;
+                    return;
+                }
+                let id = self.db.generate_id().unwrap();
+                let salt = SaltString::generate(&mut OsRng);
+                let params = scrypt::Params::new(11, 8, 1, 32).unwrap();
+                let hash = Scrypt
+                    .hash_password_customized(password.as_bytes(), None, None, params, &salt)
+                    .unwrap()
+                    .to_string();
+                self.db.users.insert(
+                    &id,
+                    &User {
+                        username: username.clone(),
+                        password_hash: hash,
+                    },
+                );
+                println!("account created: \"{username}\"");
+                self.db.usernames.insert(&username, &id);
+                *self.state.write().await = ClientState::Authed(id);
+                let _ = self.send.send(ServerMsg::Login { username }).await;
+            }
+            ClientMsg::Login { username, password } => {
+                let Some(id) = self.db.usernames.get(&username) else {
+                    let _ = self.send.send(ServerError::UnknownUsername).await;
+                    return;
+                };
+                let Some(user) = self.db.users.get(&id) else {
+                    panic!("invalid state! (should be a user)");
+                };
+                let hash = PasswordHash::new(&user.password_hash).unwrap();
+                if Scrypt.verify_password(password.as_bytes(), &hash).is_err() {
+                    println!("invalid password: \"{username}\"");
+                    let _ = self.send.send(ServerError::InvalidPassword).await;
+                    return;
+                }
+                println!("login: \"{username}\"");
+                *self.state.write().await = ClientState::Authed(id);
+                let _ = self.send.send(ServerMsg::Login { username }).await;
+            }
         }
     }
 
     async fn disconnect(&self, reason: DisconnectReason) -> () {
-        println!("disconnected: {:?}", self.send.remote());
+        println!("disconnected: {:?}", self.send.remote().ip());
         match reason {
             DisconnectReason::Closed | DisconnectReason::Timeout => (),
             DisconnectReason::Other(e) => println!("connection issue: {e}"),
         }
     }
 }
+
+impl ClientState {
+    pub fn is_authed(&self) -> bool {
+        matches!(self, Self::Authed(_))
+    }
+}

src/bin/server/net.rs

@@ -62,7 +62,8 @@ impl ClientSender {
     pub fn remote(&self) -> SocketAddr {
         self.conn.remote_address()
     }
-    pub async fn send(&self, msg: ServerMsg) -> SendResult {
+    pub async fn send(&self, msg: impl Into<ServerMsg>) -> SendResult {
+        let msg = msg.into();
         send_uni(&self.conn, msg).await
     }
 }