api: add trinary_input_string to the Workflows trait

Author: benma

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

@@ -83,17 +83,18 @@ async fn process_bip39<W: Workflows>(workflows: &mut W) -> Result<(), Error> {
         match menu::pick(&["0", "1", "2", "3", "4", "More"], Some("Select index")).await? {
             i @ 0..=4 => i.into(),
             5 => {
-                let number_string = trinary_input_string::enter(
-                    &trinary_input_string::Params {
-                        title: "Enter index",
-                        number_input: true,
-                        longtouch: true,
-                        ..Default::default()
-                    },
-                    trinary_input_string::CanCancel::Yes,
-                    "",
-                )
-                .await?;
+                let number_string = workflows
+                    .enter_string(
+                        &trinary_input_string::Params {
+                            title: "Enter index",
+                            number_input: true,
+                            longtouch: true,
+                            ..Default::default()
+                        },
+                        trinary_input_string::CanCancel::Yes,
+                        "",
+                    )
+                    .await?;
                 match number_string.as_str().parse::<u32>() {
                     Ok(i) if i < util::bip32::HARDENED => i,
                     _ => {

src/rust/bitbox02-rust/src/hww/api/bitcoin/registration.rs

@@ -80,16 +80,17 @@ async fn get_name<W: Workflows>(
             })
             .await?;
 
-        let name = trinary_input_string::enter(
-            &trinary_input_string::Params {
-                title: "Enter account name",
-                longtouch: true,
-                ..Default::default()
-            },
-            trinary_input_string::CanCancel::Yes,
-            "",
-        )
-        .await?;
+        let name = workflows
+            .enter_string(
+                &trinary_input_string::Params {
+                    title: "Enter account name",
+                    longtouch: true,
+                    ..Default::default()
+                },
+                trinary_input_string::CanCancel::Yes,
+                "",
+            )
+            .await?;
         // We truncate the user input string to fit into the maximum allowed multisig
         // account name length. This is not very nice, but it has to do until we have some
         // sort of indication in the input component.

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

@@ -50,28 +50,37 @@ mod tests {
     use super::*;
 
     use crate::bb02_async::block_on;
-    use crate::workflow::RealWorkflows;
+    use crate::workflow::testing::TestingWorkflows;
     use bitbox02::testing::{mock, mock_memory, Data};
 
     use alloc::boxed::Box;
 
     #[test]
     fn test_process() {
         mock_memory();
-        mock(Data {
-            ui_trinary_input_string_create: Some(Box::new(|_params| "password".into())),
-            ..Default::default()
-        });
-        assert!(keystore::is_locked());
+        keystore::lock();
+        let mut counter = 0u32;
+        let mut mock_workflows = TestingWorkflows::new();
+        mock_workflows.set_enter_string(Box::new(|params| {
+            counter += 1;
+            match counter {
+                1 => assert_eq!(params.title, "Set password"),
+                2 => assert_eq!(params.title, "Repeat password"),
+                _ => panic!("too many user inputs"),
+            }
+            Ok("password".into())
+        }));
         assert_eq!(
             block_on(process(
-                &mut RealWorkflows,
+                &mut mock_workflows,
                 &pb::SetPasswordRequest {
                     entropy: b"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa".to_vec(),
                 }
             )),
             Ok(Response::Success(pb::Success {}))
         );
+        drop(mock_workflows); // to remove mutable borrow of counter
+        assert_eq!(counter, 2);
         assert!(!keystore::is_locked());
         assert!(keystore::copy_seed().unwrap().len() == 32);
     }
@@ -80,14 +89,12 @@ mod tests {
     #[test]
     fn test_process_16_bytes() {
         mock_memory();
-        mock(Data {
-            ui_trinary_input_string_create: Some(Box::new(|_params| "password".into())),
-            ..Default::default()
-        });
-        assert!(keystore::is_locked());
+        keystore::lock();
+        let mut mock_workflows = TestingWorkflows::new();
+        mock_workflows.set_enter_string(Box::new(|_params| Ok("password".into())));
         assert_eq!(
             block_on(process(
-                &mut RealWorkflows,
+                &mut mock_workflows,
                 &pb::SetPasswordRequest {
                     entropy: b"aaaaaaaaaaaaaaaa".to_vec(),
                 }
@@ -102,14 +109,13 @@ mod tests {
     #[test]
     fn test_process_invalid_host_entropy() {
         mock_memory();
-        mock(Data {
-            ui_trinary_input_string_create: Some(Box::new(|_params| "password".into())),
-            ..Default::default()
-        });
+        keystore::lock();
+        let mut mock_workflows = TestingWorkflows::new();
+        mock_workflows.set_enter_string(Box::new(|_params| Ok("password".into())));
         assert!(keystore::is_locked());
         assert_eq!(
             block_on(process(
-                &mut RealWorkflows,
+                &mut mock_workflows,
                 &pb::SetPasswordRequest {
                     entropy: b"aaaaaaaaaaaaaaaaa".to_vec(),
                 }
@@ -122,24 +128,20 @@ mod tests {
     #[test]
     fn test_process_2nd_password_doesnt_match() {
         mock_memory();
-        static mut COUNTER: u32 = 0;
-        mock(Data {
-            ui_trinary_input_string_create: Some(Box::new(|_params| {
-                match unsafe {
-                    COUNTER += 1;
-                    COUNTER
-                } {
-                    1 => "password".into(),
-                    2 => "wrong".into(),
-                    _ => panic!("too many user inputs"),
-                }
-            })),
-            ..Default::default()
-        });
-        assert!(keystore::is_locked());
+        keystore::lock();
+        let mut counter = 0u32;
+        let mut mock_workflows = TestingWorkflows::new();
+        mock_workflows.set_enter_string(Box::new(|_params| {
+            counter += 1;
+            Ok(match counter {
+                1 => "password".into(),
+                2 => "wrong".into(),
+                _ => panic!("too many user inputs"),
+            })
+        }));
         assert_eq!(
             block_on(process(
-                &mut RealWorkflows,
+                &mut mock_workflows,
                 &pb::SetPasswordRequest {
                     entropy: b"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa".to_vec(),
                 }

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

@@ -29,6 +29,8 @@ pub mod trinary_input_string;
 pub mod unlock;
 pub mod verify_message;
 
+use alloc::string::String;
+
 #[allow(async_fn_in_trait)]
 pub trait Workflows {
     async fn confirm(&mut self, params: &confirm::Params<'_>) -> Result<(), confirm::UserAbort>;
@@ -47,6 +49,13 @@ pub trait Workflows {
     ) -> Result<(), transaction::UserAbort>;
 
     async fn status(&mut self, title: &str, status_success: bool);
+
+    async fn enter_string(
+        &mut self,
+        params: &trinary_input_string::Params<'_>,
+        can_cancel: trinary_input_string::CanCancel,
+        preset: &str,
+    ) -> Result<zeroize::Zeroizing<String>, trinary_input_string::Error>;
 }
 
 pub struct RealWorkflows;
@@ -80,4 +89,14 @@ impl Workflows for RealWorkflows {
     async fn status(&mut self, title: &str, status_success: bool) {
         status::status(title, status_success).await
     }
+
+    #[inline(always)]
+    async fn enter_string(
+        &mut self,
+        params: &trinary_input_string::Params<'_>,
+        can_cancel: trinary_input_string::CanCancel,
+        preset: &str,
+    ) -> Result<zeroize::Zeroizing<String>, trinary_input_string::Error> {
+        trinary_input_string::enter(params, can_cancel, preset).await
+    }
 }

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

@@ -270,16 +270,17 @@ async fn get_12th_18th_word<W: Workflows>(
     loop {
         let choices = lastword_choices(entered_words);
         let candidates = bitbox02::keystore::get_bip39_wordlist(Some(&choices));
-        let word = trinary_input_string::enter(
-            &trinary_input_string::Params {
-                title,
-                wordlist: Some(&candidates),
-                ..Default::default()
-            },
-            trinary_input_string::CanCancel::Yes,
-            "",
-        )
-        .await?;
+        let word = workflows
+            .enter_string(
+                &trinary_input_string::Params {
+                    title,
+                    wordlist: Some(&candidates),
+                    ..Default::default()
+                },
+                trinary_input_string::CanCancel::Yes,
+                "",
+            )
+            .await?;
 
         // Confirm word picked again, as a typo here would be extremely annoying.  Double checking
         // is also safer, as the user might not even realize they made a typo.
@@ -348,17 +349,18 @@ pub async fn get<W: Workflows>(
                 get_12th_18th_word(workflows, &title, &as_str_vec(&entered_words[..word_idx])).await
             }
         } else {
-            trinary_input_string::enter(
-                &trinary_input_string::Params {
-                    title: &title,
-                    wordlist: Some(&bip39_wordlist),
-                    ..Default::default()
-                },
-                trinary_input_string::CanCancel::Yes,
-                preset,
-            )
-            .await
-            .into()
+            workflows
+                .enter_string(
+                    &trinary_input_string::Params {
+                        title: &title,
+                        wordlist: Some(&bip39_wordlist),
+                        ..Default::default()
+                    },
+                    trinary_input_string::CanCancel::Yes,
+                    preset,
+                )
+                .await
+                .into()
         };
 
         match user_entry {

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

@@ -50,7 +50,7 @@ pub async fn enter<W: Workflows>(
     };
 
     loop {
-        match trinary_input_string::enter(&params, can_cancel, "").await {
+        match workflows.enter_string(&params, can_cancel, "").await {
             o @ Ok(_) => return o,
             Err(Error::Cancelled) => match prompt_cancel(workflows).await {
                 Ok(()) => return Err(Error::Cancelled),

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

@@ -12,8 +12,9 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-use super::{confirm, transaction, Workflows};
+use super::{confirm, transaction, trinary_input_string, Workflows};
 
+use alloc::boxed::Box;
 use alloc::string::String;
 use alloc::vec::Vec;
 
@@ -40,14 +41,20 @@ pub enum Screen {
     More,
 }
 
+type EnterStringCb<'a> = Box<
+    dyn FnMut(&trinary_input_string::Params<'_>) -> Result<String, trinary_input_string::Error>
+        + 'a,
+>;
+
 /// An Workflows implementation for unit tests. Collects all screens and provides helper functions
 /// to verify them.
-pub struct TestingWorkflows {
+pub struct TestingWorkflows<'a> {
     _abort_nth: Option<usize>,
     pub screens: Vec<Screen>,
+    _enter_string: Option<EnterStringCb<'a>>,
 }
 
-impl Workflows for TestingWorkflows {
+impl Workflows for TestingWorkflows<'_> {
     async fn confirm(&mut self, params: &confirm::Params<'_>) -> Result<(), confirm::UserAbort> {
         self.screens.push(Screen::Confirm {
             title: params.title.into(),
@@ -117,13 +124,23 @@ impl Workflows for TestingWorkflows {
             panic!("canot abort status screen");
         }
     }
+
+    async fn enter_string(
+        &mut self,
+        params: &trinary_input_string::Params<'_>,
+        _can_cancel: trinary_input_string::CanCancel,
+        _preset: &str,
+    ) -> Result<zeroize::Zeroizing<String>, trinary_input_string::Error> {
+        self._enter_string.as_mut().unwrap()(params).map(zeroize::Zeroizing::new)
+    }
 }
 
-impl TestingWorkflows {
+impl<'a> TestingWorkflows<'a> {
     pub fn new() -> Self {
         Self {
             screens: vec![],
             _abort_nth: None,
+            _enter_string: None,
         }
     }
 
@@ -139,4 +156,8 @@ impl TestingWorkflows {
             _ => false,
         })
     }
+
+    pub fn set_enter_string(&mut self, cb: EnterStringCb<'a>) {
+        self._enter_string = Some(cb);
+    }
 }