keystore: remove keystore_get_bip39_mnemonic

Is now readily implemented in Rust using bip39_mnemonic_from_seed() and copy_seed().

Author: benma

src/keystore.c

@@ -504,20 +504,6 @@ bool keystore_bip39_mnemonic_from_seed(
     return snprintf_result >= 0 && snprintf_result < (int)mnemonic_out_size;
 }
 
-bool keystore_get_bip39_mnemonic(char* mnemonic_out, size_t mnemonic_out_size)
-{
-    if (keystore_is_locked()) {
-        return false;
-    }
-    uint8_t seed[KEYSTORE_MAX_SEED_LENGTH] = {0};
-    UTIL_CLEANUP_32(seed);
-    size_t seed_length = 0;
-    if (!keystore_copy_seed(seed, &seed_length)) {
-        return false;
-    }
-    return keystore_bip39_mnemonic_from_seed(seed, seed_length, mnemonic_out, mnemonic_out_size);
-}
-
 bool keystore_bip39_mnemonic_to_seed(const char* mnemonic, uint8_t* seed_out, size_t* seed_len_out)
 {
     return bip39_mnemonic_to_bytes(NULL, mnemonic, seed_out, 32, seed_len_out) == WALLY_OK;

src/keystore.h

@@ -125,15 +125,6 @@ USE_RESULT bool keystore_bip39_mnemonic_from_seed(
     char* mnemonic_out,
     size_t mnemonic_out_size);
 
-/**
- * @param[out] mnemonic_out resulting mnemonic
- * @param[in] mnemonic_out_size size of mnemonic_out. Should be at least 216 bytes (longest possible
- *            24 word phrase plus null terminator).
- * @return returns false if the keystore is not unlocked or the mnemonic does not fit.
- * The resulting string should be safely zeroed after use.
- */
-USE_RESULT bool keystore_get_bip39_mnemonic(char* mnemonic_out, size_t mnemonic_out_size);
-
 /**
  * Turn a bip39 mnemonic into a seed. Make sure to use UTIL_CLEANUP_32 to destroy it.
  * Output can be fed into `keystore_encrypt_and_store_seed` to create a keystore from the mnemonic.

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

@@ -22,7 +22,7 @@ use pb::response::Response;
 use crate::hal::Ui;
 use crate::workflow::{confirm, mnemonic, unlock};
 
-use bitbox02::keystore;
+use crate::keystore;
 
 /// Handle the ShowMnemonic API call. This shows the seed encoded as
 /// 12/18/24 BIP39 English words. Afterwards, for each word, the user

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

@@ -15,6 +15,7 @@
 #[cfg(feature = "ed25519")]
 pub mod ed25519;
 
+use alloc::string::String;
 use alloc::vec::Vec;
 
 use crate::bip32;
@@ -25,6 +26,11 @@ use util::bip32::HARDENED;
 use crate::hash::Sha512;
 use hmac::{digest::FixedOutput, Mac, SimpleHmac};
 
+/// Returns the keystore's seed encoded as a BIP-39 mnemonic.
+pub fn get_bip39_mnemonic() -> Result<zeroize::Zeroizing<String>, ()> {
+    keystore::bip39_mnemonic_from_seed(&keystore::copy_seed()?)
+}
+
 /// Derives an xpub from the keystore seed at the given keypath.
 pub fn get_xpub(keypath: &[u32]) -> Result<bip32::Xpub, ()> {
     // Convert from C keystore to Rust by encoding the xpub in C and decoding it in Rust.
@@ -74,7 +80,17 @@ pub fn bip85_ln(index: u32) -> Result<zeroize::Zeroizing<Vec<u8>>, ()> {
 mod tests {
     use super::*;
 
-    use bitbox02::testing::{mock_unlocked, mock_unlocked_using_mnemonic};
+    use bitbox02::testing::{mock_unlocked, mock_unlocked_using_mnemonic, TEST_MNEMONIC};
+
+    #[test]
+    fn test_get_bip39_mnemonic() {
+        keystore::lock();
+        assert!(get_bip39_mnemonic().is_err());
+
+        mock_unlocked();
+
+        assert_eq!(get_bip39_mnemonic().unwrap().as_str(), TEST_MNEMONIC);
+    }
 
     #[test]
     fn test_get_xpub() {

src/rust/bitbox02-sys/build.rs

@@ -72,7 +72,6 @@ const ALLOWLIST_FNS: &[&str] = &[
     "keystore_create_and_store_seed",
     "keystore_encode_xpub_at_keypath",
     "keystore_encrypt_and_store_seed",
-    "keystore_get_bip39_mnemonic",
     "keystore_get_bip39_word",
     "keystore_get_ed25519_seed",
     "keystore_is_locked",

src/rust/bitbox02/src/keystore.rs

@@ -122,20 +122,6 @@ pub fn copy_seed() -> Result<zeroize::Zeroizing<Vec<u8>>, ()> {
     }
 }
 
-pub fn get_bip39_mnemonic() -> Result<zeroize::Zeroizing<String>, ()> {
-    let mut mnemonic = zeroize::Zeroizing::new([0u8; 256]);
-    match unsafe {
-        bitbox02_sys::keystore_get_bip39_mnemonic(mnemonic.as_mut_ptr(), mnemonic.len() as _)
-    } {
-        false => Err(()),
-        true => Ok(zeroize::Zeroizing::new(
-            crate::util::str_from_null_terminated(&mnemonic[..])
-                .unwrap()
-                .into(),
-        )),
-    }
-}
-
 pub fn bip39_mnemonic_from_seed(seed: &[u8]) -> Result<zeroize::Zeroizing<String>, ()> {
     let mut mnemonic = zeroize::Zeroizing::new([0u8; 256]);
     match unsafe {
@@ -374,7 +360,7 @@ pub fn secp256k1_schnorr_sign(
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::testing::{mock_unlocked, mock_unlocked_using_mnemonic, TEST_MNEMONIC};
+    use crate::testing::{mock_unlocked, mock_unlocked_using_mnemonic};
     use util::bip32::HARDENED;
 
     #[test]
@@ -442,19 +428,6 @@ mod tests {
         );
     }
 
-    #[test]
-    fn test_get_bip39_mnemonic() {
-        lock();
-        assert!(get_bip39_mnemonic().is_err());
-
-        mock_unlocked();
-
-        assert_eq!(
-            get_bip39_mnemonic().unwrap().as_ref() as &str,
-            TEST_MNEMONIC
-        );
-    }
-
     #[test]
     fn test_get_bip39_word() {
         assert!(get_bip39_word(2048).is_err());

test/unit-test/test_keystore.c

@@ -451,26 +451,23 @@ static void _test_keystore_lock(void** state)
     assert_true(keystore_is_locked());
 }
 
-static void _test_keystore_get_bip39_mnemonic(void** state)
+static void _test_keystore_bip39_mnemonic_from_seed(void** state)
 {
     char mnemonic[300];
-    _mock_unlocked(NULL, 0, NULL);
-    assert_false(keystore_get_bip39_mnemonic(mnemonic, sizeof(mnemonic)));
-
-    _mock_unlocked(_mock_seed, sizeof(_mock_seed), NULL);
-    assert_false(keystore_get_bip39_mnemonic(mnemonic, sizeof(mnemonic)));
 
-    _mock_unlocked(_mock_seed, sizeof(_mock_seed), _mock_bip39_seed);
-    assert_true(keystore_get_bip39_mnemonic(mnemonic, sizeof(mnemonic)));
+    assert_true(keystore_bip39_mnemonic_from_seed(
+        _mock_seed, sizeof(_mock_seed), mnemonic, sizeof(mnemonic)));
     const char* expected_mnemonic =
         "baby mass dust captain baby mass mass dust captain baby mass dutch creek office smoke "
         "grid creek olive baby mass dust captain baby length";
     assert_string_equal(mnemonic, expected_mnemonic);
 
     // Output buffer too short.
-    assert_false(keystore_get_bip39_mnemonic(mnemonic, strlen(expected_mnemonic)));
+    assert_false(keystore_bip39_mnemonic_from_seed(
+        _mock_seed, sizeof(_mock_seed), mnemonic, strlen(expected_mnemonic)));
     // Just enough space to fit.
-    assert_true(keystore_get_bip39_mnemonic(mnemonic, strlen(expected_mnemonic) + 1));
+    assert_true(keystore_bip39_mnemonic_from_seed(
+        _mock_seed, sizeof(_mock_seed), mnemonic, strlen(expected_mnemonic) + 1));
 }
 
 static void _test_keystore_create_and_store_seed(void** state)
@@ -696,7 +693,7 @@ int main(void)
         cmocka_unit_test(_test_keystore_unlock),
         cmocka_unit_test(_test_keystore_unlock_bip39),
         cmocka_unit_test(_test_keystore_lock),
-        cmocka_unit_test(_test_keystore_get_bip39_mnemonic),
+        cmocka_unit_test(_test_keystore_bip39_mnemonic_from_seed),
         cmocka_unit_test(_test_keystore_create_and_store_seed),
         cmocka_unit_test(_test_keystore_get_ed25519_seed),
         cmocka_unit_test(_test_secp256k1_schnorr_sign),

test/unit-test/test_keystore_functional.c

@@ -96,8 +96,12 @@ static void _test_seeds(void** state)
 
 static void _check_mnemonic(const char* expected)
 {
+    uint8_t seed[KEYSTORE_MAX_SEED_LENGTH];
+    size_t seed_len;
+
     char mnemonic[300];
-    assert_true(keystore_get_bip39_mnemonic(mnemonic, sizeof(mnemonic)));
+    assert_true(keystore_copy_seed(seed, &seed_len));
+    assert_true(keystore_bip39_mnemonic_from_seed(seed, seed_len, mnemonic, sizeof(mnemonic)));
     assert_string_equal(mnemonic, expected);
 }