implement signed session data

src/server/repository/UserRepo.rs

@@ -0,0 +1,16 @@
+use async_trait::async_trait;
+use uuid::Uuid;
+use crate::shared::models::app::{CodeLoggedInSession, CodeLoginData, KeyLoggedInSession};
+use crate::shared::email::Email;
+
+#[async_trait]
+pub trait UserRepo: Send + Sync {
+    async fn get_key_session(&self, session_id: &Uuid) -> Result<KeyLoggedInSession, String>;
+    async fn get_code_session(&self, session_id: &Uuid) -> Result<CodeLoggedInSession, String>;
+
+    async fn set_key_session(&self, session: KeyLoggedInSession) -> Result<(), String>;
+    async fn set_code_session(&self, session: CodeLoggedInSession) -> Result<(), String>;
+
+    async fn set_code_login_data(&self, email: Email, data: CodeLoginData) -> Result<(), String>;
+    async fn get_code_login_data(&self, email: &Email) -> Result<CodeLoginData, String>;
+}

src/server/repository/in_memory/in_memory_opaque_db.rs

@@ -1,5 +1,5 @@
 use std::collections::HashMap;
-use crate::shared::models::opaque::PasswordFile;
+use crate::shared::opaque::PasswordFile;
 use crate::server::repository::opaque_repo::{OpaqueDatabaseRepo, AuthRepoError};
 use tokio::sync::Mutex;
 use std::sync::Arc;

src/server/repository/in_memory/in_memory_opaque_session.rs

@@ -5,7 +5,7 @@ use opaque_ke::ServerLogin;
 use tokio::sync::Mutex;
 use uuid::Uuid;
 use crate::server::models::{LoginCache, RegCache};
-use crate::shared::models::opaque::NKodeCipherSuite;
+use crate::shared::opaque::NKodeCipherSuite;
 use crate::server::repository::opaque_repo::OpaqueSessionRepo;
 
 #[derive(Default)]

src/server/repository/in_memory/in_memory_transport.rs

@@ -2,7 +2,7 @@ use async_trait::async_trait;
 use std::marker::PhantomData;
 use uuid::Uuid;
 use opaque_ke::{CredentialFinalization, CredentialRequest, RegistrationRequest};
-use crate::shared::models::opaque::{NKodeCipherSuite, OpaqueLoginSession, OpaqueRegisterSession, PasswordFile};
+use crate::shared::opaque::{NKodeCipherSuite, OpaqueLoginSession, OpaqueRegisterSession, PasswordFile};
 use crate::client::opaque::{ClientAuthError, ServerConnectionLogin, ServerConnectionRegister};
 use crate::server::app::{Code, Key};
 use crate::server::app::ServerApp;
@@ -12,15 +12,15 @@ use crate::server::repository::in_memory::in_memory_opaque_session::InMemoryOpaq
 use crate::server::repository::in_memory::in_memory_user_db::InMemoryUserDB;
 use crate::shared::models::app::LoggedInSession;
 
-pub type InMemoryKeyServer<'a> = InMemoryServer<'a, Key>;
-pub type InMemoryCodeServer<'a> = InMemoryServer<'a, Code>;
+pub type InMemoryKeyServer<'a> = InMemoryServerTransport<'a, Key>;
+pub type InMemoryCodeServer<'a> = InMemoryServerTransport<'a, Code>;
 
-pub struct InMemoryServer<'a, K: CredKind> {
+pub struct InMemoryServerTransport<'a, K: CredKind> {
     auth_db: &'a ServerApp<InMemoryOpaqueDB, InMemoryOpaqueSession, InMemoryUserDB>,
     _kind: PhantomData<K>,
 }
 
-impl<'a, K: CredKind> InMemoryServer<'a, K> {
+impl<'a, K: CredKind> InMemoryServerTransport<'a, K> {
     pub fn new(server_app: &'a ServerApp<InMemoryOpaqueDB, InMemoryOpaqueSession, InMemoryUserDB>) -> Self {
         Self {
             auth_db: server_app,
@@ -30,17 +30,15 @@ impl<'a, K: CredKind> InMemoryServer<'a, K> {
 }
 
 #[async_trait]
-impl<'a, K> ServerConnectionRegister for InMemoryServer<'a, K>
+impl<'a, K> ServerConnectionRegister for InMemoryServerTransport<'a, K>
 where
-    K: CredKind + Sync,
+    K: CredKind,
 {
     async fn start(
         &self,
         identifier: &[u8],
         message: &RegistrationRequest<NKodeCipherSuite>,
     ) -> Result<OpaqueRegisterSession, ClientAuthError> {
-        // Server API takes ownership; client trait gives us a reference.
-        // opaque-ke request types are typically Clone; if not, you'll need to adjust signatures.
         self.auth_db
             .reg_start::<K>(identifier, message.clone())
             .await
@@ -59,7 +57,7 @@ where
 }
 
 #[async_trait]
-impl<'a, K> ServerConnectionLogin for InMemoryServer<'a,K>
+impl<'a, K> ServerConnectionLogin for InMemoryServerTransport<'a,K>
 where
     K: CredKind + Send + Sync,
 {

src/server/repository/in_memory/in_memory_user_db.rs

@@ -3,9 +3,9 @@ use std::sync::Arc;
 use async_trait::async_trait;
 use tokio::sync::Mutex;
 use uuid::Uuid;
-use crate::shared::models::store::UserAuthStore;
+use crate::server::repository::UserRepo::UserRepo;
 use crate::shared::models::app::{CodeLoggedInSession, CodeLoginData, KeyLoggedInSession};
-use crate::shared::models::email::Email;
+use crate::shared::email::Email;
 
 pub struct InMemoryUserDB {
     key_session: Arc<Mutex<HashMap<Uuid, KeyLoggedInSession>>>,
@@ -30,7 +30,7 @@ impl Default for InMemoryUserDB {
 }
 
 #[async_trait]
-impl UserAuthStore for InMemoryUserDB {
+impl UserRepo for InMemoryUserDB {
     async fn get_key_session(&self, session_id: &Uuid) -> Result<KeyLoggedInSession, String> {
         self.key_session.lock().await
             .get(&session_id)

src/server/repository/mod.rs

@@ -1,2 +1,3 @@
 pub mod in_memory;
 pub mod opaque_repo;
+pub mod UserRepo;

src/server/repository/opaque_repo.rs

@@ -2,7 +2,7 @@ use async_trait::async_trait;
 use uuid::Uuid;
 use opaque_ke::ServerLogin;
 use crate::server::models::{LoginCache, RegCache};
-use crate::shared::models::opaque::{NKodeCipherSuite, PasswordFile};
+use crate::shared::opaque::{NKodeCipherSuite, PasswordFile};
 #[derive(Debug)]
 pub enum AuthRepoError {
     UserExists,