Use checksum of encrypted file data.

tests/integration/archive_export_restore.rs

@@ -47,7 +47,6 @@ fn create_archive(
 #[tokio::test]
 #[serial]
 async fn integration_archive_local_provider() -> Result<()> {
-
     // TODO: test creating external file storage
     // TODO: and extracting the archived files
 
@@ -84,6 +83,7 @@ async fn integration_archive_local_provider() -> Result<()> {
         selected: vec![vault.summary().clone()],
         passphrase: Some(SecretString::new(passphrase.to_string())),
         files_dir: None,
+        files_dir_builder: None,
     };
 
     // Create the archive

workspace/core/src/archive.rs

@@ -127,10 +127,7 @@ impl<W: Write + Seek> Writer<W> {
     pub fn finish(mut self) -> Result<W> {
         let manifest = serde_json::to_vec_pretty(&self.manifest)?;
 
-        self.append_file_buffer(
-            ARCHIVE_MANIFEST,
-            manifest.as_slice(),
-        )?;
+        self.append_file_buffer(ARCHIVE_MANIFEST, manifest.as_slice())?;
 
         Ok(self.builder.finish()?)
     }

workspace/node/src/client/account_manager.rs

@@ -2,7 +2,7 @@
 //! creating and managing local accounts.
 use std::{
     borrow::Cow,
-    io::{Cursor, Read, Write},
+    io::{Cursor, Read},
     path::{Path, PathBuf},
     sync::Arc,
 };
@@ -291,9 +291,9 @@ impl AccountManager {
     }
 
     /// Encrypt a file using AGE passphrase encryption and
-    /// move to a target directory.
+    /// write to a target directory.
     ///
-    /// The file name is the Sha256 digest of the original file.
+    /// The file name is the Sha256 digest of the encrypted file.
     pub fn encrypt_file<S: AsRef<Path>, T: AsRef<Path>>(
         source: S,
         target: T,
@@ -302,37 +302,18 @@ impl AccountManager {
         let mut file = std::fs::File::open(source)?;
         let encryptor = Encryptor::with_user_passphrase(passphrase);
 
-        let mut hasher = Sha256::new();
-        let mut encrypted = tempfile::NamedTempFile::new()?;
-
+        let mut encrypted = Vec::new();
         let mut writer = encryptor.wrap_output(&mut encrypted)?;
-
-        let chunk_size = 8192;
-        loop {
-            let mut chunk = Vec::with_capacity(chunk_size);
-            let n = std::io::Read::by_ref(&mut file)
-                .take(chunk_size as u64)
-                .read_to_end(&mut chunk)?;
-            if n == 0 {
-                break;
-            }
-
-            writer.write_all(chunk.as_slice())?;
-            hasher.update(chunk.as_slice());
-
-            if n < chunk_size {
-                break;
-            }
-        }
-
+        std::io::copy(&mut file, &mut writer)?;
         writer.finish()?;
 
+        let mut hasher = Sha256::new();
+        hasher.update(&encrypted);
         let digest = hasher.finalize();
         let file_name = hex::encode(digest);
         let dest = PathBuf::from(target.as_ref()).join(&file_name);
 
-        // Move the temporary file into place
-        std::fs::rename(encrypted.path(), dest)?;
+        std::fs::write(dest, encrypted)?;
 
         Ok(digest.to_vec())
     }