Merge branch 'mock-sd'

Author: benma

src/rust/bitbox02-rust/src/backup.rs

@@ -16,6 +16,8 @@ use prost::Message;
 
 use crate::pb_backup;
 
+use crate::hal::Sd;
+
 use alloc::boxed::Box;
 use alloc::string::String;
 use alloc::vec::Vec;
@@ -156,15 +158,18 @@ fn bitwise_recovery(buf1: &[u8], buf2: &[u8], buf3: &[u8]) -> Result<Zeroizing<V
     Ok(recovered_contents)
 }
 
-pub fn load(dir: &str) -> Result<(Zeroizing<BackupData>, pb_backup::BackupMetaData), ()> {
-    let files = bitbox02::sd::list_subdir(Some(dir))?;
+pub fn load(
+    hal: &mut impl crate::hal::Hal,
+    dir: &str,
+) -> Result<(Zeroizing<BackupData>, pb_backup::BackupMetaData), ()> {
+    let files = hal.sd().list_subdir(Some(dir))?;
     if files.len() != 3 {
         return Err(());
     }
     let file_contents: [Zeroizing<Vec<u8>>; 3] = [
-        bitbox02::sd::load_bin(&files[0], dir)?,
-        bitbox02::sd::load_bin(&files[1], dir)?,
-        bitbox02::sd::load_bin(&files[2], dir)?,
+        hal.sd().load_bin(&files[0], dir)?,
+        hal.sd().load_bin(&files[1], dir)?,
+        hal.sd().load_bin(&files[2], dir)?,
     ];
     for contents in file_contents.iter() {
         if let o @ Ok(_) = load_from_buffer(contents) {
@@ -182,6 +187,7 @@ pub fn load(dir: &str) -> Result<(Zeroizing<BackupData>, pb_backup::BackupMetaDa
 }
 
 pub fn create(
+    hal: &mut impl crate::hal::Hal,
     seed: &[u8],
     name: &str,
     backup_create_timestamp: u32,
@@ -226,7 +232,7 @@ pub fn create(
     };
     let backup_encoded = backup.encode_to_vec();
     let dir = id(seed);
-    let files = bitbox02::sd::list_subdir(Some(&dir)).or(Err(Error::SdList))?;
+    let files = hal.sd().list_subdir(Some(&dir)).or(Err(Error::SdList))?;
 
     let filename_datetime = {
         let tm = bitbox02::get_datetime(backup_create_timestamp).map_err(|_| Error::Generic)?;
@@ -247,8 +253,12 @@ pub fn create(
         if files.contains(&filename) {
             return Err(Error::Generic);
         }
-        bitbox02::sd::write_bin(&filename, &dir, &backup_encoded).or(Err(Error::SdWrite))?;
-        if bitbox02::sd::load_bin(&filename, &dir)
+        hal.sd()
+            .write_bin(&filename, &dir, &backup_encoded)
+            .or(Err(Error::SdWrite))?;
+        if hal
+            .sd()
+            .load_bin(&filename, &dir)
             .or(Err(Error::SdRead))?
             .as_slice()
             != backup_encoded.as_slice()
@@ -258,7 +268,7 @@ pub fn create(
     }
     let mut stale = false;
     for file in files {
-        if bitbox02::sd::erase_file_in_subdir(&file, &dir).is_err() {
+        if hal.sd().erase_file_in_subdir(&file, &dir).is_err() {
             stale = true
         }
     }
@@ -272,10 +282,9 @@ pub fn create(
 mod tests {
     use super::*;
 
+    use crate::hal::testing::TestingHal;
     use core::convert::TryInto;
 
-    use bitbox02::testing::mock_sd;
-
     #[test]
     fn test_id() {
         // Seeds of different lengths (16, 24, 32 bytes)
@@ -295,14 +304,14 @@ mod tests {
     }
 
     fn _test_create_load(seed: &[u8]) {
-        mock_sd();
+        let mut mock_hal = TestingHal::new();
         let timestamp = 1601281809;
         let birthdate = timestamp - 32400;
-        assert!(create(seed, "test name", timestamp, birthdate).is_ok());
+        assert!(create(&mut mock_hal, seed, "test name", timestamp, birthdate).is_ok());
         let dir = id(seed);
-        assert_eq!(bitbox02::sd::list_subdir(None), Ok(vec![dir.clone()]));
+        assert_eq!(mock_hal.sd.list_subdir(None), Ok(vec![dir.clone()]));
         assert_eq!(
-            bitbox02::sd::list_subdir(Some(&dir)),
+            mock_hal.sd.list_subdir(Some(&dir)),
             Ok(vec![
                 "backup_Mon_2020-09-28T08-30-09Z_0.bin".into(),
                 "backup_Mon_2020-09-28T08-30-09Z_1.bin".into(),
@@ -311,20 +320,22 @@ mod tests {
         );
 
         // Recreating using same timestamp is not allowed and doesn't change the backups.
-        assert!(create(seed, "new name", timestamp, birthdate).is_err());
+        assert!(create(&mut mock_hal, seed, "new name", timestamp, birthdate).is_err());
         assert_eq!(
-            bitbox02::sd::list_subdir(Some(&dir)),
+            mock_hal.sd.list_subdir(Some(&dir)),
             Ok(vec![
                 "backup_Mon_2020-09-28T08-30-09Z_0.bin".into(),
                 "backup_Mon_2020-09-28T08-30-09Z_1.bin".into(),
                 "backup_Mon_2020-09-28T08-30-09Z_2.bin".into()
             ])
         );
 
-        let contents: [zeroize::Zeroizing<Vec<u8>>; 3] = bitbox02::sd::list_subdir(Some(&dir))
+        let contents: [zeroize::Zeroizing<Vec<u8>>; 3] = mock_hal
+            .sd
+            .list_subdir(Some(&dir))
             .unwrap()
             .iter()
-            .map(|file| bitbox02::sd::load_bin(file, &dir).unwrap())
+            .map(|file| mock_hal.sd.load_bin(file, &dir).unwrap())
             .collect::<Vec<_>>()
             .try_into()
             .unwrap();
@@ -334,17 +345,17 @@ mod tests {
         );
 
         // Recreating the backup removes the previous files.
-        assert!(create(seed, "new name", timestamp + 1, birthdate).is_ok());
+        assert!(create(&mut mock_hal, seed, "new name", timestamp + 1, birthdate).is_ok());
         assert_eq!(
-            bitbox02::sd::list_subdir(Some(&dir)),
+            mock_hal.sd.list_subdir(Some(&dir)),
             Ok(vec![
                 "backup_Mon_2020-09-28T08-30-10Z_0.bin".into(),
                 "backup_Mon_2020-09-28T08-30-10Z_1.bin".into(),
                 "backup_Mon_2020-09-28T08-30-10Z_2.bin".into()
             ])
         );
 
-        let (backup_data, metadata) = load(&dir).unwrap();
+        let (backup_data, metadata) = load(&mut mock_hal, &dir).unwrap();
         assert_eq!(backup_data.get_seed(), seed);
         assert_eq!(backup_data.0.birthdate, birthdate);
         assert_eq!(metadata.name.as_str(), "new name");

src/rust/bitbox02-rust/src/hal.rs

@@ -15,8 +15,15 @@
 use crate::workflow::RealWorkflows;
 pub use crate::workflow::Workflows as Ui;
 
+use alloc::string::String;
+use alloc::vec::Vec;
+
 pub trait Sd {
     fn sdcard_inserted(&mut self) -> bool;
+    fn list_subdir(&mut self, subdir: Option<&str>) -> Result<Vec<String>, ()>;
+    fn erase_file_in_subdir(&mut self, filename: &str, dir: &str) -> Result<(), ()>;
+    fn load_bin(&mut self, filename: &str, dir: &str) -> Result<zeroize::Zeroizing<Vec<u8>>, ()>;
+    fn write_bin(&mut self, filename: &str, dir: &str, data: &[u8]) -> Result<(), ()>;
 }
 
 /// Hardware abstraction layer for BitBox devices.
@@ -28,9 +35,30 @@ pub trait Hal {
 pub struct BitBox02Sd;
 
 impl Sd for BitBox02Sd {
+    #[inline(always)]
     fn sdcard_inserted(&mut self) -> bool {
         bitbox02::sd::sdcard_inserted()
     }
+
+    #[inline(always)]
+    fn list_subdir(&mut self, subdir: Option<&str>) -> Result<Vec<String>, ()> {
+        bitbox02::sd::list_subdir(subdir)
+    }
+
+    #[inline(always)]
+    fn erase_file_in_subdir(&mut self, filename: &str, dir: &str) -> Result<(), ()> {
+        bitbox02::sd::erase_file_in_subdir(filename, dir)
+    }
+
+    #[inline(always)]
+    fn load_bin(&mut self, filename: &str, dir: &str) -> Result<zeroize::Zeroizing<Vec<u8>>, ()> {
+        bitbox02::sd::load_bin(filename, dir)
+    }
+
+    #[inline(always)]
+    fn write_bin(&mut self, filename: &str, dir: &str, data: &[u8]) -> Result<(), ()> {
+        bitbox02::sd::write_bin(filename, dir, data)
+    }
 }
 
 pub struct BitBox02Hal {
@@ -58,24 +86,71 @@ impl Hal for BitBox02Hal {
 
 #[cfg(feature = "testing")]
 pub mod testing {
+    use alloc::collections::BTreeMap;
+    use alloc::string::String;
+    use alloc::vec::Vec;
+
     pub struct TestingSd {
         pub inserted: Option<bool>,
+        files: BTreeMap<String, BTreeMap<String, Vec<u8>>>,
     }
 
     impl TestingSd {
         pub fn new() -> Self {
-            Self { inserted: None }
+            Self {
+                inserted: None,
+                files: BTreeMap::new(),
+            }
         }
     }
-    pub struct TestingHal<'a> {
-        pub ui: crate::workflow::testing::TestingWorkflows<'a>,
-        pub sd: TestingSd,
-    }
 
     impl super::Sd for TestingSd {
         fn sdcard_inserted(&mut self) -> bool {
             self.inserted.unwrap()
         }
+
+        fn list_subdir(&mut self, subdir: Option<&str>) -> Result<Vec<String>, ()> {
+            match subdir {
+                Some(key) => Ok(self
+                    .files
+                    .get(key)
+                    .map(|files| files.keys().cloned().collect())
+                    .unwrap_or_default()),
+                None => Ok(self.files.keys().cloned().collect()),
+            }
+        }
+
+        fn erase_file_in_subdir(&mut self, filename: &str, dir: &str) -> Result<(), ()> {
+            self.files
+                .get_mut(dir)
+                .and_then(|files| files.remove(filename).map(|_| ()))
+                .ok_or(())
+        }
+
+        fn load_bin(
+            &mut self,
+            filename: &str,
+            dir: &str,
+        ) -> Result<zeroize::Zeroizing<Vec<u8>>, ()> {
+            self.files
+                .get(dir)
+                .and_then(|files| files.get(filename))
+                .map(|data| zeroize::Zeroizing::new(data.clone()))
+                .ok_or(())
+        }
+
+        fn write_bin(&mut self, filename: &str, dir: &str, data: &[u8]) -> Result<(), ()> {
+            self.files
+                .entry(dir.into())
+                .or_default()
+                .insert(filename.into(), data.to_vec());
+            Ok(())
+        }
+    }
+
+    pub struct TestingHal<'a> {
+        pub ui: crate::workflow::testing::TestingWorkflows<'a>,
+        pub sd: TestingSd,
     }
 
     impl TestingHal<'_> {
@@ -95,4 +170,35 @@ pub mod testing {
             &mut self.sd
         }
     }
+
+    #[cfg(test)]
+    mod tests {
+        use super::*;
+        use crate::hal::Sd;
+
+        // Quick check if our mock TestingSd implementation makes sense.
+        #[test]
+        fn test_sd_list_write_read_erase() {
+            let mut sd = TestingSd::new();
+            assert_eq!(sd.list_subdir(None), Ok(vec![]));
+            assert_eq!(sd.list_subdir(Some("dir1")), Ok(vec![]));
+
+            assert!(sd.load_bin("file1.txt", "dir1").is_err());
+            assert!(sd.write_bin("file1.txt", "dir1", b"data").is_ok());
+            assert_eq!(sd.list_subdir(None), Ok(vec!["dir1".into()]));
+            assert_eq!(sd.list_subdir(Some("dir1")), Ok(vec!["file1.txt".into()]));
+            assert_eq!(
+                sd.load_bin("file1.txt", "dir1").unwrap().as_slice(),
+                b"data"
+            );
+            assert!(sd.write_bin("file1.txt", "dir1", b"replaced data").is_ok());
+            assert_eq!(
+                sd.load_bin("file1.txt", "dir1").unwrap().as_slice(),
+                b"replaced data"
+            );
+            assert!(sd.erase_file_in_subdir("doesnt-exist.txt", "dir1").is_err());
+            assert!(sd.erase_file_in_subdir("file1.txt", "dir1").is_ok());
+            assert_eq!(sd.list_subdir(Some("dir1")), Ok(vec![]));
+        }
+    }
 }

src/rust/bitbox02-rust/src/hww.rs

@@ -139,7 +139,7 @@ mod tests {
     use crate::bb02_async::block_on;
     use crate::hal::testing::TestingHal;
     use crate::workflow::testing::Screen;
-    use bitbox02::testing::{mock_memory, mock_sd};
+    use bitbox02::testing::mock_memory;
 
     use prost::Message;
 
@@ -236,7 +236,6 @@ mod tests {
     #[test]
     fn test_noise() {
         mock_memory();
-        mock_sd();
         let mut make_request = init_noise();
         let request = crate::pb::Request {
             request: Some(crate::pb::request::Request::ListBackups(
@@ -477,7 +476,6 @@ mod tests {
         ] {
             bitbox02::keystore::lock();
             mock_memory();
-            mock_sd();
 
             bitbox02::memory::set_device_name("test device name").unwrap();
 
@@ -508,8 +506,7 @@ mod tests {
                 }]
             );
 
-            let mut mock_hal = TestingHal::new();
-            mock_hal.sd.inserted = Some(true);
+            mock_hal.ui = crate::workflow::testing::TestingWorkflows::new();
             make_request(
                 &mut mock_hal,
                 (crate::pb::Request {
@@ -541,7 +538,7 @@ mod tests {
 
             let seed = bitbox02::keystore::copy_seed().unwrap();
             assert_eq!(seed.len(), host_entropy.len());
-            let mut mock_hal = TestingHal::new();
+            mock_hal.ui = crate::workflow::testing::TestingWorkflows::new();
             assert!(matches!(
                 crate::pb::Response::decode(
                     make_request(
@@ -566,7 +563,7 @@ mod tests {
             ));
             assert_eq!(mock_hal.ui.screens, vec![]);
 
-            let mut mock_hal = TestingHal::new();
+            mock_hal.ui = crate::workflow::testing::TestingWorkflows::new();
             make_request(
                 &mut mock_hal,
                 (crate::pb::Request {
@@ -587,7 +584,7 @@ mod tests {
                 }]
             );
 
-            let mut mock_hal = TestingHal::new();
+            mock_hal.ui = crate::workflow::testing::TestingWorkflows::new();
             assert!(matches!(
                 crate::pb::Response::decode(
                     make_request(
@@ -612,7 +609,7 @@ mod tests {
             ));
             assert_eq!(mock_hal.ui.screens, vec![]);
 
-            let mut mock_hal = TestingHal::new();
+            mock_hal.ui = crate::workflow::testing::TestingWorkflows::new();
             let backup_id = match crate::pb::Response::decode(
                 make_request(
                     &mut mock_hal,
@@ -647,7 +644,7 @@ mod tests {
             };
             assert_eq!(mock_hal.ui.screens, vec![]);
 
-            let mut mock_hal = TestingHal::new();
+            mock_hal.ui = crate::workflow::testing::TestingWorkflows::new();
             mock_hal
                 .ui
                 .set_enter_string(Box::new(|_params| Ok("password".into())));