Use sync encrypt and decrypt reader

koofr · Dec 1, 2023 · c55be50 · c55be50
1 parent 3ffaa26
commit c55be50
Show file tree

Hide file tree

Showing 14 changed files with 108 additions and 149 deletions.
diff --git a/vault-core-tests/src/fixtures/repo_fixture.rs b/vault-core-tests/src/fixtures/repo_fixture.rs
@@ -84,11 +84,10 @@ impl RepoFixture {
         })
     }
 
-    pub async fn unlock(&self) {
+    pub fn unlock(&self) {
         self.vault
             .repos_service
             .unlock_repo(&self.repo_id, "password", RepoUnlockMode::Unlock)
-            .await
             .unwrap();
     }
 

diff --git a/vault-core-tests/src/helpers/mod.rs b/vault-core-tests/src/helpers/mod.rs
@@ -113,7 +113,7 @@ pub fn with_repo(
 
             user_fixture.load().await;
 
-            repo_fixture.unlock().await;
+            repo_fixture.unlock();
 
             f(repo_fixture).await;
         }

diff --git a/vault-core-tests/tests/integration/repo_create_tests.rs b/vault-core-tests/tests/integration/repo_create_tests.rs
@@ -55,7 +55,6 @@ fn test_create() {
                 .vault
                 .repos_service
                 .unlock_repo(&repo_id, "password", RepoUnlockMode::Unlock)
-                .await
                 .unwrap();
             fixture
                 .vault

diff --git a/vault-core-tests/tests/integration/repo_files_browsers_tests.rs b/vault-core-tests/tests/integration/repo_files_browsers_tests.rs
@@ -120,7 +120,7 @@ fn test_repo_lock_unlock_remove() {
                 }
             );
 
-            fixture.unlock().await;
+            fixture.unlock();
 
             let state_after_unlock = get_state();
             assert_eq!(
@@ -597,7 +597,7 @@ fn test_eventstream() {
             let fixture1 = fixture.new_session();
             fixture1.user_fixture.login();
             fixture1.user_fixture.load().await;
-            fixture1.unlock().await;
+            fixture1.unlock();
 
             let (browser_id, load_future) = fixture.vault.repo_files_browsers_create(
                 fixture.repo_id.clone(),

diff --git a/vault-core-tests/tests/integration/repo_files_details_tests.rs b/vault-core-tests/tests/integration/repo_files_details_tests.rs
@@ -627,7 +627,7 @@ fn test_repo_lock_unlock_remove() {
                 }
             );
 
-            fixture.unlock().await;
+            fixture.unlock();
 
             let state_after_unlock = get_state();
             assert_eq!(
@@ -749,7 +749,7 @@ fn test_eventstream() {
             let fixture1 = fixture.new_session();
             fixture1.user_fixture.login();
             fixture1.user_fixture.load().await;
-            fixture1.unlock().await;
+            fixture1.unlock();
 
             let (details_id, load_future) = fixture.vault.repo_files_details_create(
                 fixture.repo_id.clone(),

diff --git a/vault-core-tests/tests/integration/repo_files_tests.rs b/vault-core-tests/tests/integration/repo_files_tests.rs
@@ -54,7 +54,7 @@ fn test_repo_lock_unlock_remove() {
 
             assert_eq!(state_after_lock, RepoFilesState::default());
 
-            fixture.unlock().await;
+            fixture.unlock();
 
             let state_after_unlock = get_state();
 

diff --git a/vault-core/src/cipher/cipher.rs b/vault-core/src/cipher/cipher.rs
@@ -1,5 +1,8 @@
-use futures::{io::Cursor, AsyncReadExt};
-use std::{str, sync::Arc};
+use std::{
+    io::{Cursor, Read},
+    str,
+    sync::Arc,
+};
 use xsalsa20poly1305::XSalsa20Poly1305;
 
 use crate::types::{DecryptedName, DecryptedPath, EncryptedName, EncryptedPath};
@@ -8,8 +11,8 @@ use super::{
     cipher_keys::{derive_keys, DerivedKeys},
     constants::{DATA_KEY_LEN, NAME_CIPHER_BLOCK_SIZE, NAME_KEY_LEN},
     data_cipher::get_data_cipher,
-    decrypt_reader::AsyncDecryptReader,
-    encrypt_reader::AsyncEncryptReader,
+    decrypt_reader::{AsyncDecryptReader, SyncDecryptReader},
+    encrypt_reader::{AsyncEncryptReader, SyncEncryptReader},
     errors::DecryptFilenameError,
     name_cipher::{
         decrypt_filename, decrypt_path, encrypt_filename, encrypt_path, get_name_cipher,
@@ -90,35 +93,35 @@ impl Cipher {
         AsyncEncryptReader::new(reader, self.data_cipher.clone(), nonce)
     }
 
-    pub async fn encrypt_data(
-        &self,
-        data: &[u8],
-        out: &mut Vec<u8>,
-    ) -> Result<usize, std::io::Error> {
+    pub fn encrypt_reader_sync<R>(&self, reader: R) -> SyncEncryptReader<R> {
+        let nonce = Nonce::new_random().unwrap();
+
+        SyncEncryptReader::new(reader, self.data_cipher.clone(), nonce)
+    }
+
+    pub fn encrypt_data(&self, data: &[u8], out: &mut Vec<u8>) -> Result<usize, std::io::Error> {
         let reader = Cursor::new(data);
 
-        self.encrypt_reader_async(reader).read_to_end(out).await
+        self.encrypt_reader_sync(reader).read_to_end(out)
     }
 
     pub fn decrypt_reader_async<R>(&self, reader: R) -> AsyncDecryptReader<R> {
         AsyncDecryptReader::new(reader, self.data_cipher.clone())
     }
 
-    pub async fn decrypt_data(
-        &self,
-        data: &[u8],
-        out: &mut Vec<u8>,
-    ) -> Result<usize, std::io::Error> {
+    pub fn decrypt_reader_sync<R>(&self, reader: R) -> SyncDecryptReader<R> {
+        SyncDecryptReader::new(reader, self.data_cipher.clone())
+    }
+
+    pub fn decrypt_data(&self, data: &[u8], out: &mut Vec<u8>) -> Result<usize, std::io::Error> {
         let reader = Cursor::new(data);
 
-        self.decrypt_reader_async(reader).read_to_end(out).await
+        self.decrypt_reader_sync(reader).read_to_end(out)
     }
 }
 
 #[cfg(test)]
 mod tests {
-    use futures::executor::block_on;
-
     use crate::types::{DecryptedName, DecryptedPath, EncryptedName, EncryptedPath};
 
     use super::Cipher;
@@ -293,47 +296,41 @@ mod tests {
 
     #[test]
     fn test_encrypt_data() {
-        block_on(async {
-            // tested with rclone 1.60
-            let cipher = Cipher::new("testpassword", None);
+        // tested with rclone 1.60
+        let cipher = Cipher::new("testpassword", None);
 
-            let mut encrypted = Vec::new();
+        let mut encrypted = Vec::new();
 
-            let res = cipher
-                .encrypt_data("testdata".as_bytes(), &mut encrypted)
-                .await;
+        let res = cipher.encrypt_data("testdata".as_bytes(), &mut encrypted);
 
-            assert_eq!(res.unwrap(), 56);
+        assert_eq!(res.unwrap(), 56);
 
-            let mut decrypted = Vec::new();
+        let mut decrypted = Vec::new();
 
-            let res = cipher.decrypt_data(&encrypted, &mut decrypted).await;
+        let res = cipher.decrypt_data(&encrypted, &mut decrypted);
 
-            assert_eq!(res.unwrap(), 8);
+        assert_eq!(res.unwrap(), 8);
 
-            assert_eq!(std::str::from_utf8(&decrypted).unwrap(), "testdata");
-        })
+        assert_eq!(std::str::from_utf8(&decrypted).unwrap(), "testdata");
     }
 
     #[test]
     fn test_decrypt_data() {
-        block_on(async {
-            // tested with rclone 1.60
-            let cipher = Cipher::new("testpassword", None);
+        // tested with rclone 1.60
+        let cipher = Cipher::new("testpassword", None);
 
-            let encrypted = vec![
-                82, 67, 76, 79, 78, 69, 0, 0, 209, 27, 246, 23, 134, 105, 131, 148, 3, 49, 228, 74,
-                200, 43, 245, 170, 123, 102, 24, 137, 45, 77, 53, 115, 206, 216, 221, 4, 40, 177,
-                52, 14, 5, 190, 84, 192, 246, 157, 207, 154, 11, 178, 94, 181, 135, 59, 240, 115,
-            ];
+        let encrypted = vec![
+            82, 67, 76, 79, 78, 69, 0, 0, 209, 27, 246, 23, 134, 105, 131, 148, 3, 49, 228, 74,
+            200, 43, 245, 170, 123, 102, 24, 137, 45, 77, 53, 115, 206, 216, 221, 4, 40, 177, 52,
+            14, 5, 190, 84, 192, 246, 157, 207, 154, 11, 178, 94, 181, 135, 59, 240, 115,
+        ];
 
-            let mut decrypted = Vec::new();
+        let mut decrypted = Vec::new();
 
-            let res = cipher.decrypt_data(&encrypted, &mut decrypted).await;
+        let res = cipher.decrypt_data(&encrypted, &mut decrypted);
 
-            assert_eq!(res.unwrap(), 8);
+        assert_eq!(res.unwrap(), 8);
 
-            assert_eq!(std::str::from_utf8(&decrypted).unwrap(), "testdata");
-        })
+        assert_eq!(std::str::from_utf8(&decrypted).unwrap(), "testdata");
     }
 }
diff --git a/vault-core/src/repo_config_backup/service.rs b/vault-core/src/repo_config_backup/service.rs
@@ -26,12 +26,12 @@ impl RepoConfigBackupService {
             .mutate(|state, notify, _, _| mutations::create(state, notify, repo_id))
     }
 
-    pub async fn generate(&self, backup_id: u32, password: &str) -> Result<(), UnlockRepoError> {
+    pub fn generate(&self, backup_id: u32, password: &str) -> Result<(), UnlockRepoError> {
         let repo_id = self
             .store
             .mutate(|state, notify, _, _| mutations::generating(state, notify, backup_id))?;
 
-        let res = self.repos_service.get_repo_config(&repo_id, password).await;
+        let res = self.repos_service.get_repo_config(&repo_id, password);
 
         let res_err = res.as_ref().map(|_| ()).map_err(|err| err.clone());
 

diff --git a/vault-core/src/repo_unlock/service.rs b/vault-core/src/repo_unlock/service.rs
@@ -29,15 +29,12 @@ impl RepoUnlockService {
         })
     }
 
-    pub async fn unlock(&self, unlock_id: u32, password: &str) -> Result<(), UnlockRepoError> {
+    pub fn unlock(&self, unlock_id: u32, password: &str) -> Result<(), UnlockRepoError> {
         let (repo_id, mode) = self
             .store
             .mutate(|state, notify, _, _| mutations::unlocking(state, notify, unlock_id))?;
 
-        let res = self
-            .repos_service
-            .unlock_repo(&repo_id, password, mode)
-            .await;
+        let res = self.repos_service.unlock_repo(&repo_id, password, mode);
 
         self.store.mutate(|state, notify, _, _| {
             mutations::unlocked(state, notify, unlock_id, res.clone());
-Original file line number
+Diff line change
@@ Expand Up / @@ -55,7 +55,6 @@ fn test_create() { @@
                     .vault
                     .repos_service
                     .unlock_repo(&repo_id, "password", RepoUnlockMode::Unlock)
-                    .await
                     .unwrap();
                 fixture
                     .vault
@@ Expand Down @@