Merge branch 'test-show-mnemonic'

Author: benma

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

@@ -44,7 +44,7 @@ pub async fn process(
 /// https://github.com/bitcoin/bips/blob/master/bip-0085.mediawiki#bip39.
 async fn process_bip39(hal: &mut impl crate::hal::Hal) -> Result<(), Error> {
     use crate::workflow::trinary_choice::TrinaryChoice;
-    use crate::workflow::{mnemonic, trinary_input_string};
+    use crate::workflow::trinary_input_string;
 
     hal.ui()
         .confirm(&confirm::Params {
@@ -123,7 +123,7 @@ async fn process_bip39(hal: &mut impl crate::hal::Hal) -> Result<(), Error> {
 
     let mnemonic = keystore::bip85_bip39(num_words, index)?;
     let words: Vec<&str> = mnemonic.split(' ').collect();
-    mnemonic::show_and_confirm_mnemonic(hal, &words).await?;
+    hal.ui().show_and_confirm_mnemonic(&words).await?;
 
     hal.ui().status("Finished", true).await;
 

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

@@ -20,7 +20,7 @@ use crate::pb;
 use pb::response::Response;
 
 use crate::hal::Ui;
-use crate::workflow::{confirm, mnemonic, unlock};
+use crate::workflow::{confirm, unlock};
 
 use crate::keystore;
 
@@ -55,10 +55,156 @@ pub async fn process(hal: &mut impl crate::hal::Hal) -> Result<Response, Error>
 
     let words: Vec<&str> = mnemonic_sentence.split(' ').collect();
 
-    mnemonic::show_and_confirm_mnemonic(hal, &words).await?;
+    hal.ui().show_and_confirm_mnemonic(&words).await?;
 
     bitbox02::memory::set_initialized().or(Err(Error::Memory))?;
 
     hal.ui().status("Backup created", true).await;
     Ok(Response::Success(pb::Success {}))
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    use alloc::boxed::Box;
+
+    use crate::hal::testing::TestingHal;
+    use crate::workflow::testing::Screen;
+    use bitbox02::testing::mock_memory;
+    use util::bb02_async::block_on;
+
+    /// When not yet initialized, we show the mnemonic without a password check. This happens during
+    /// wallet setup.
+    #[test]
+    fn test_process_uninitialized() {
+        mock_memory();
+        bitbox02::keystore::encrypt_and_store_seed(
+            hex::decode("c7940c13479b8d9a6498f4e50d5a42e0d617bc8e8ac9f2b8cecf97e94c2b035c")
+                .unwrap()
+                .as_slice(),
+            "password",
+        )
+        .unwrap();
+
+        assert!(!bitbox02::memory::is_initialized());
+
+        let mut mock_hal = TestingHal::new();
+        mock_hal.ui.set_enter_string(Box::new(|_params| {
+            panic!("unexpected call to enter password")
+        }));
+
+        bitbox02::securechip::fake_event_counter_reset();
+        assert_eq!(
+            block_on(process(&mut mock_hal)),
+            Ok(Response::Success(pb::Success {}))
+        );
+        // 1 operation for one copy_seed() to get the seed to display it.
+        assert_eq!(bitbox02::securechip::fake_event_counter(), 1);
+
+        assert_eq!(
+            mock_hal.ui.screens,
+            vec![
+                Screen::Confirm {
+                    title: "Warning".into(),
+                    body: "DO NOT share your\nrecovery words with\nanyone!".into(),
+                    longtouch: false
+                },
+                Screen::Confirm {
+                    title: "Recovery\nwords".into(),
+                    body: "Please write down\nthe following words".into(),
+                    longtouch: false
+                },
+                Screen::ShowAndConfirmMnemonic {
+                    mnemonic: "shy parrot age monkey rhythm snake mystery burden topic hello mouse script gesture tattoo demand float verify shoe recycle cool network better aspect list".into(),
+                },
+                Screen::Status {
+                    title: "Backup created".into(),
+                    success: true
+                },
+            ]
+        );
+    }
+    /// When initialized, a password check is prompted before displaying the mnemonic.
+    #[test]
+    fn test_process_initialized() {
+        mock_memory();
+        bitbox02::keystore::encrypt_and_store_seed(
+            hex::decode("c7940c13479b8d9a6498f4e50d5a42e0d617bc8e8ac9f2b8cecf97e94c2b035c")
+                .unwrap()
+                .as_slice(),
+            "password",
+        )
+        .unwrap();
+
+        bitbox02::memory::set_initialized().unwrap();
+
+        let mut mock_hal = TestingHal::new();
+        mock_hal
+            .ui
+            .set_enter_string(Box::new(|_params| Ok("password".into())));
+
+        bitbox02::securechip::fake_event_counter_reset();
+        assert_eq!(
+            block_on(process(&mut mock_hal)),
+            Ok(Response::Success(pb::Success {}))
+        );
+        assert_eq!(bitbox02::securechip::fake_event_counter(), 7);
+
+        assert_eq!(
+            mock_hal.ui.screens,
+            vec![
+                Screen::Confirm {
+                    title: "Warning".into(),
+                    body: "DO NOT share your\nrecovery words with\nanyone!".into(),
+                    longtouch: false
+                },
+                Screen::Confirm {
+                    title: "Recovery\nwords".into(),
+                    body: "Please write down\nthe following words".into(),
+                    longtouch: false
+                },
+                Screen::ShowAndConfirmMnemonic {
+                    mnemonic: "shy parrot age monkey rhythm snake mystery burden topic hello mouse script gesture tattoo demand float verify shoe recycle cool network better aspect list".into(),
+                },
+                Screen::Status {
+                    title: "Backup created".into(),
+                    success: true
+                },
+            ]
+        );
+    }
+
+    /// When initialized, a password check is prompted before displaying the mnemonic.
+    /// This tests that we fail early if the wrong password is entered.
+    #[test]
+    fn test_process_initialized_wrong_password() {
+        mock_memory();
+        bitbox02::keystore::encrypt_and_store_seed(
+            hex::decode("c7940c13479b8d9a6498f4e50d5a42e0d617bc8e8ac9f2b8cecf97e94c2b035c")
+                .unwrap()
+                .as_slice(),
+            "password",
+        )
+        .unwrap();
+
+        bitbox02::memory::set_initialized().unwrap();
+
+        let mut mock_hal = TestingHal::new();
+        mock_hal
+            .ui
+            .set_enter_string(Box::new(|_params| Ok("wrong password".into())));
+
+        bitbox02::securechip::fake_event_counter_reset();
+        assert_eq!(block_on(process(&mut mock_hal)), Err(Error::Generic));
+        assert_eq!(bitbox02::securechip::fake_event_counter(), 5);
+
+        assert_eq!(
+            mock_hal.ui.screens,
+            vec![Screen::Status {
+                title: "Wrong password\n9 tries remain".into(),
+                success: false,
+            }]
+        );
+    }
+}

src/rust/bitbox02-rust/src/workflow.rs

@@ -79,6 +79,20 @@ pub trait Workflows {
         choices: &[&str],
         title: &str,
     ) -> Result<u8, cancel::Error>;
+
+    /// Display the mnemonic words and have the user confirm them in a multiple-choice quiz.
+    ///
+    /// The default implementation is implemented in terms of `self.show_mnemonic()`,
+    /// `self.quiz_mnemonic_word()`, etc.
+    ///
+    /// This function is defined in the HAL so unit tests can easily mock it. Real implementations
+    /// should leave the default implementation.
+    async fn show_and_confirm_mnemonic(&mut self, words: &[&str]) -> Result<(), cancel::Error>
+    where
+        Self: Sized,
+    {
+        mnemonic::show_and_confirm_mnemonic(self, words).await
+    }
 }
 
 pub struct RealWorkflows;

src/rust/bitbox02-rust/src/workflow/mnemonic.rs

@@ -111,10 +111,10 @@ pub async fn confirm_word(choices: &[&str], title: &str) -> Result<u8, CancelErr
 }
 
 pub async fn show_and_confirm_mnemonic(
-    hal: &mut impl crate::hal::Hal,
+    hal_ui: &mut impl crate::hal::Ui,
     words: &[&str],
 ) -> Result<(), CancelError> {
-    hal.ui()
+    hal_ui
         .confirm(&confirm::Params {
             title: "",
             body: &format!("{} words follow", words.len()),
@@ -125,11 +125,10 @@ pub async fn show_and_confirm_mnemonic(
         .map_err(|_| CancelError::Cancelled)?;
 
     // Part 1) Scroll through words
-    hal.ui().show_mnemonic(words).await?;
+    hal_ui.show_mnemonic(words).await?;
 
     // Can only succeed due to `accept_only`.
-    let _ = hal
-        .ui()
+    let _ = hal_ui
         .confirm(&confirm::Params {
             title: "",
             body: "Please confirm\neach word",
@@ -147,10 +146,10 @@ pub async fn show_and_confirm_mnemonic(
         choices.push("Back to\nrecovery words");
         let back_idx = (choices.len() - 1) as u8;
         loop {
-            match hal.ui().quiz_mnemonic_word(&choices, &title).await? {
+            match hal_ui.quiz_mnemonic_word(&choices, &title).await? {
                 selected_idx if selected_idx == correct_idx => break,
-                selected_idx if selected_idx == back_idx => hal.ui().show_mnemonic(words).await?,
-                _ => hal.ui().status("Incorrect word\nTry again", false).await,
+                selected_idx if selected_idx == back_idx => hal_ui.show_mnemonic(words).await?,
+                _ => hal_ui.status("Incorrect word\nTry again", false).await,
             }
         }
     }

src/rust/bitbox02-rust/src/workflow/mnemonic_c_unit_tests.rs

@@ -26,7 +26,7 @@ pub async fn confirm_word(_choices: &[&str], _title: &str) -> Result<u8, CancelE
 }
 
 pub async fn show_and_confirm_mnemonic(
-    _hal: &mut impl crate::hal::Hal,
+    _ui: &mut impl crate::hal::Ui,
     words: &[&str],
 ) -> Result<(), CancelError> {
     for word in words.iter() {

src/rust/bitbox02-rust/src/workflow/testing.rs

@@ -40,6 +40,9 @@ pub enum Screen {
         title: String,
         success: bool,
     },
+    ShowAndConfirmMnemonic {
+        mnemonic: String,
+    },
     More,
 }
 
@@ -169,6 +172,13 @@ impl Workflows for TestingWorkflows<'_> {
     ) -> Result<u8, cancel::Error> {
         todo!("not used in unit tests yet");
     }
+
+    async fn show_and_confirm_mnemonic(&mut self, words: &[&str]) -> Result<(), cancel::Error> {
+        self.screens.push(Screen::ShowAndConfirmMnemonic {
+            mnemonic: words.join(" "),
+        });
+        Ok(())
+    }
 }
 
 impl<'a> TestingWorkflows<'a> {