refactor file struct

src/opaque/server.rs

@@ -4,25 +4,8 @@ use opaque_ke::{
     ServerRegistration,
 };
 use uuid::Uuid;
-use crate::opaque::models::{RegisterSession, LoginSession, NKodeCipherSuite, NKodeServerSetup, PasswordFile};
-
-#[derive(Debug)]
-pub enum AuthRepoError {
-    UserExists,
-    KeyNotRegistered,
-    CodeNotRegistered,
-}
-
-pub trait AuthRepo {
-    fn new_key(&mut self, identifier: &[u8], password_file: PasswordFile) -> Result<(), AuthRepoError>;
-    fn new_code(&mut self, identifier: &[u8], password_file: PasswordFile) -> Result<(), AuthRepoError>;
-
-    fn has_code(&self, identifier: &[u8]) -> bool;
-    fn has_key(&self, identifier: &[u8]) -> bool;
-
-    fn get_key_passcode_file(&self, identifier: &[u8]) -> Result<PasswordFile, AuthRepoError>;
-    fn get_code_passcode_file(&self, identifier: &[u8]) -> Result<PasswordFile, AuthRepoError>;
-}
+use crate::models::opaque::{LoginSession, NKodeCipherSuite, NKodeServerSetup, PasswordFile, RegisterSession};
+use crate::repository::opaque::repos::{OpaqueDatabaseRepo, AuthRepoError, OpaqueSessionRepo};
 
 pub struct RegCache {
     pub session_id: Uuid,
@@ -35,25 +18,11 @@ pub struct LoginCache {
     pub server_login: ServerLogin<NKodeCipherSuite>,
 }
 
-pub trait AuthSession {
-    fn new_reg_session(&mut self, identifier: &[u8]) -> Result<RegCache, String>;
-    fn get_reg_session(&self, session_id: &Uuid) -> Result<RegCache, String>;
-    fn clear_reg_session(&mut self, session_id: &Uuid) -> Result<(), String>;
-
-    fn new_login_session(
-        &mut self,
-        identifier: &[u8],
-        server_login: ServerLogin<NKodeCipherSuite>,
-    ) -> Result<LoginCache, String>;
-    fn get_login_session(&self, session_id: &Uuid) -> Result<LoginCache, String>;
-    fn clear_login_session(&mut self, session_id: &Uuid) -> Result<(), String>;
-}
-
 pub trait CredKind {
-    fn has<R: AuthRepo>(repo: &R, id: &[u8]) -> bool;
-    fn get_pf<R: AuthRepo>(repo: &R, id: &[u8]) -> Result<PasswordFile, AuthRepoError>;
-    fn put_pf<R: AuthRepo>(repo: &mut R, id: &[u8], pf: PasswordFile) -> Result<(), AuthRepoError>;
-    fn prereq_for_register<R: AuthRepo>(_repo: &R, _id: &[u8]) -> Result<(), AuthRepoError> {
+    fn has<R: OpaqueDatabaseRepo>(repo: &R, id: &[u8]) -> bool;
+    fn get_pf<R: OpaqueDatabaseRepo>(repo: &R, id: &[u8]) -> Result<PasswordFile, AuthRepoError>;
+    fn put_pf<R: OpaqueDatabaseRepo>(repo: &mut R, id: &[u8], pf: PasswordFile) -> Result<(), AuthRepoError>;
+    fn prereq_for_register<R: OpaqueDatabaseRepo>(_repo: &R, _id: &[u8]) -> Result<(), AuthRepoError> {
         Ok(())
     }
 }
@@ -62,28 +31,28 @@ pub struct Key;
 pub struct Code;
 
 impl CredKind for Key {
-    fn has<R: AuthRepo>(repo: &R, id: &[u8]) -> bool {
+    fn has<R: OpaqueDatabaseRepo>(repo: &R, id: &[u8]) -> bool {
         repo.has_key(id)
     }
-    fn get_pf<R: AuthRepo>(repo: &R, id: &[u8]) -> Result<PasswordFile, AuthRepoError> {
+    fn get_pf<R: OpaqueDatabaseRepo>(repo: &R, id: &[u8]) -> Result<PasswordFile, AuthRepoError> {
         repo.get_key_passcode_file(id)
     }
-    fn put_pf<R: AuthRepo>(repo: &mut R, id: &[u8], pf: PasswordFile) -> Result<(), AuthRepoError> {
+    fn put_pf<R: OpaqueDatabaseRepo>(repo: &mut R, id: &[u8], pf: PasswordFile) -> Result<(), AuthRepoError> {
         repo.new_key(id, pf)
     }
 }
 
 impl CredKind for Code {
-    fn has<R: AuthRepo>(repo: &R, id: &[u8]) -> bool {
+    fn has<R: OpaqueDatabaseRepo>(repo: &R, id: &[u8]) -> bool {
         repo.has_code(id)
     }
-    fn get_pf<R: AuthRepo>(repo: &R, id: &[u8]) -> Result<PasswordFile, AuthRepoError> {
+    fn get_pf<R: OpaqueDatabaseRepo>(repo: &R, id: &[u8]) -> Result<PasswordFile, AuthRepoError> {
         repo.get_code_passcode_file(id)
     }
-    fn put_pf<R: AuthRepo>(repo: &mut R, id: &[u8], pf: PasswordFile) -> Result<(), AuthRepoError> {
+    fn put_pf<R: OpaqueDatabaseRepo>(repo: &mut R, id: &[u8], pf: PasswordFile) -> Result<(), AuthRepoError> {
         repo.new_code(id, pf)
     }
-    fn prereq_for_register<R: AuthRepo>(repo: &R, id: &[u8]) -> Result<(), AuthRepoError> {
+    fn prereq_for_register<R: OpaqueDatabaseRepo>(repo: &R, id: &[u8]) -> Result<(), AuthRepoError> {
         if repo.has_key(id) {
             Ok(())
         } else {
@@ -92,13 +61,13 @@ impl CredKind for Code {
     }
 }
 
-pub struct OpaqueAuth<R: AuthRepo, S: AuthSession> {
+pub struct OpaqueAuth<R: OpaqueDatabaseRepo, S: OpaqueSessionRepo> {
     server_setup: NKodeServerSetup,
     user_repo: R,
     session: S,
 }
 
-impl<R: AuthRepo, S: AuthSession> OpaqueAuth<R, S> {
+impl<R: OpaqueDatabaseRepo, S: OpaqueSessionRepo> OpaqueAuth<R, S> {
     pub fn new(server_setup: NKodeServerSetup, user_repo: R, session: S) -> Self {
         Self { server_setup, user_repo, session }
     }