[wip] make bip39 unlocking async

Author: benma

src/rust/bitbox02-rust/src/keystore.rs

@@ -270,6 +270,7 @@ mod tests {
     use bitbox02::testing::{
         TEST_MNEMONIC, mock_memory, mock_unlocked, mock_unlocked_using_mnemonic,
     };
+    use util::bb02_async::block_on;
 
     use bitcoin::secp256k1;
 
@@ -573,7 +574,15 @@ mod tests {
             keystore::lock();
             let seed = &seed[..test.seed_len];
 
-            assert!(keystore::unlock_bip39(SECP256K1, seed, test.mnemonic_passphrase).is_err());
+            assert!(
+                block_on(keystore::unlock_bip39(
+                    SECP256K1,
+                    seed,
+                    test.mnemonic_passphrase,
+                    async |_idx| {}
+                ))
+                .is_err()
+            );
 
             bitbox02::securechip::fake_event_counter_reset();
             assert!(keystore::encrypt_and_store_seed(seed, "foo").is_ok());
@@ -582,7 +591,15 @@ mod tests {
             assert!(keystore::is_locked());
 
             bitbox02::securechip::fake_event_counter_reset();
-            assert!(keystore::unlock_bip39(SECP256K1, seed, test.mnemonic_passphrase).is_ok());
+            assert!(
+                block_on(keystore::unlock_bip39(
+                    SECP256K1,
+                    seed,
+                    test.mnemonic_passphrase,
+                    async |_idx| {}
+                ))
+                .is_ok()
+            );
             assert_eq!(bitbox02::securechip::fake_event_counter(), 1);
 
             assert!(!keystore::is_locked());

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

@@ -133,9 +133,16 @@ pub async fn unlock_bip39(hal: &mut impl crate::hal::Hal, seed: &[u8]) {
         }
     }
 
-    let result = bitbox02::ui::with_lock_animation(|| {
-        keystore::unlock_bip39(crate::secp256k1::SECP256K1, seed, &mnemonic_passphrase)
-    });
+    let result = bitbox02::ui::with_lock_animation(async || {
+        keystore::unlock_bip39(
+            crate::secp256k1::SECP256K1,
+            seed,
+            &mnemonic_passphrase,
+            async |_idx| util::bb02_async::yield_now().await,
+        )
+        .await
+    })
+    .await;
     if result.is_err() {
         abort("bip39 unlock failed");
     }

src/rust/bitbox02/src/keystore.rs

@@ -111,14 +111,18 @@ fn unlock_bip39_finalize(bip39_seed: &[u8; 64]) -> Result<(), Error> {
     }
 }
 
-fn derive_bip39_seed(
+async fn derive_bip39_seed(
     secp: &Secp256k1<All>,
     seed: &[u8],
     mnemonic_passphrase: &str,
+    yield_now: impl AsyncFn(usize),
 ) -> (zeroize::Zeroizing<[u8; 64]>, [u8; 4]) {
     let mnemonic = bip39::Mnemonic::from_entropy_in(bip39::Language::English, seed).unwrap();
-    let bip39_seed: zeroize::Zeroizing<[u8; 64]> =
-        zeroize::Zeroizing::new(mnemonic.to_seed_normalized(mnemonic_passphrase));
+    let bip39_seed: zeroize::Zeroizing<[u8; 64]> = zeroize::Zeroizing::new(
+        mnemonic
+            .to_seed_normalized_async(mnemonic_passphrase, yield_now)
+            .await,
+    );
     let root_fingerprint: [u8; 4] =
         bitcoin::bip32::Xpriv::new_master(bitcoin::NetworkKind::Main, bip39_seed.as_ref())
             .unwrap()
@@ -132,14 +136,16 @@ fn derive_bip39_seed(
 /// of `keystore_copy_seed()`).
 /// `mnemonic_passphrase` is the bip39 passphrase used in the derivation. Use the empty string if no
 /// passphrase is needed or provided.
-pub fn unlock_bip39(
+pub async fn unlock_bip39(
     secp: &Secp256k1<All>,
     seed: &[u8],
     mnemonic_passphrase: &str,
+    yield_now: impl AsyncFn(usize),
 ) -> Result<(), Error> {
     unlock_bip39_check(seed)?;
 
-    let (bip39_seed, root_fingerprint) = derive_bip39_seed(secp, seed, mnemonic_passphrase);
+    let (bip39_seed, root_fingerprint) =
+        derive_bip39_seed(secp, seed, mnemonic_passphrase, yield_now).await;
 
     unlock_bip39_finalize(bip39_seed.as_slice().try_into().unwrap())?;
 
@@ -279,6 +285,7 @@ mod tests {
     use bitcoin::secp256k1;
 
     use crate::testing::{mock_memory, mock_unlocked_using_mnemonic};
+    use util::bb02_async::block_on;
 
     #[test]
     fn test_secp256k1_sign() {
@@ -442,7 +449,15 @@ mod tests {
             .unwrap();
         assert!(encrypt_and_store_seed(&seed, "password").is_ok());
         assert!(is_locked()); // still locked, it is only unlocked after unlock_bip39.
-        assert!(unlock_bip39(&secp256k1::Secp256k1::new(), &seed, "foo").is_ok());
+        assert!(
+            block_on(unlock_bip39(
+                &secp256k1::Secp256k1::new(),
+                &seed,
+                "foo",
+                async |_idx| {}
+            ))
+            .is_ok()
+        );
         assert!(!is_locked());
         lock();
         assert!(is_locked());
@@ -569,7 +584,12 @@ mod tests {
         let secp = secp256k1::Secp256k1::new();
         for test in tests {
             let seed = hex::decode(test.seed).unwrap();
-            let (bip39_seed, root_fingerprint) = derive_bip39_seed(&secp, &seed, test.passphrase);
+            let (bip39_seed, root_fingerprint) = block_on(derive_bip39_seed(
+                &secp,
+                &seed,
+                test.passphrase,
+                async |_idx| {},
+            ));
             assert_eq!(hex::encode(bip39_seed).as_str(), test.expected_bip39_seed);
             assert_eq!(
                 hex::encode(root_fingerprint).as_str(),
@@ -597,9 +617,17 @@ mod tests {
         assert!(encrypt_and_store_seed(&seed, "password").is_ok());
         assert!(root_fingerprint().is_err());
         // Incorrect seed passed
-        assert!(unlock_bip39(&secp, b"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", "foo").is_err());
+        assert!(
+            block_on(unlock_bip39(
+                &secp,
+                b"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
+                "foo",
+                async |_idx| {}
+            ))
+            .is_err()
+        );
         // Correct seed passed.
-        assert!(unlock_bip39(&secp, &seed, "foo").is_ok());
+        assert!(block_on(unlock_bip39(&secp, &seed, "foo", async |_idx| {})).is_ok());
         assert_eq!(root_fingerprint(), Ok(vec![0xf1, 0xbc, 0x3c, 0x46]),);
 
         let expected_bip39_seed = hex::decode("2b3c63de86f0f2b13cc6a36c1ba2314fbc1b40c77ab9cb64e96ba4d5c62fc204748ca6626a9f035e7d431bce8c9210ec0bdffc2e7db873dee56c8ac2153eee9a").unwrap();

src/rust/bitbox02/src/testing.rs

@@ -22,7 +22,13 @@ pub fn mock_unlocked_using_mnemonic(mnemonic: &str, passphrase: &str) {
     unsafe {
         bitbox02_sys::keystore_mock_unlocked(seed.as_ptr(), seed.len() as _, core::ptr::null())
     }
-    keystore::unlock_bip39(&bitcoin::secp256k1::Secp256k1::new(), &seed, passphrase).unwrap();
+    util::bb02_async::block_on(keystore::unlock_bip39(
+        &bitcoin::secp256k1::Secp256k1::new(),
+        &seed,
+        passphrase,
+        async |_idx| {},
+    ))
+    .unwrap();
 }
 
 pub const TEST_MNEMONIC: &str = "purity concert above invest pigeon category peace tuition hazard vivid latin since legal speak nation session onion library travel spell region blast estate stay";

src/rust/bitbox02/src/ui/ui.rs

@@ -436,9 +436,9 @@ pub fn trinary_input_string_set_input(component: &mut Component, word: &str) {
     }
 }
 
-pub fn with_lock_animation<F: Fn() -> R, R>(f: F) -> R {
+pub async fn with_lock_animation<F: AsyncFn() -> R, R>(f: F) -> R {
     unsafe { bitbox02_sys::lock_animation_start() };
-    let result = f();
+    let result = f().await;
     unsafe { bitbox02_sys::lock_animation_stop() };
     result
 }

src/rust/util/src/bb02_async.rs

@@ -59,3 +59,15 @@ pub fn block_on<O>(task: impl core::future::Future<Output = O>) -> O {
         }
     }
 }
+
+pub fn yield_now() -> impl core::future::Future<Output = ()> {
+    let mut yielded = false;
+    core::future::poll_fn(move |_cx| {
+        if yielded {
+            core::task::Poll::Ready(())
+        } else {
+            yielded = true;
+            core::task::Poll::Pending
+        }
+    })
+}