keystore: move keystore_root_fingerprint to Rust

Author: benma

src/CMakeLists.txt

@@ -317,7 +317,6 @@ add_custom_target(rust-bindgen
     --allowlist-function keystore_secp256k1_sign
     --allowlist-function keystore_secp256k1_schnorr_bip86_sign
     --allowlist-function keystore_bip39_mnemonic_to_seed
-    --allowlist-function keystore_get_root_fingerprint
     --allowlist-function keystore_mock_unlocked
     --allowlist-var EC_PUBLIC_KEY_UNCOMPRESSED_LEN
     --allowlist-var EC_PUBLIC_KEY_LEN

src/keystore.c

@@ -466,18 +466,6 @@ static bool _get_xprv(const uint32_t* keypath, const size_t keypath_len, struct
     return true;
 }
 
-bool keystore_get_root_fingerprint(uint8_t* fingerprint)
-{
-    struct ext_key derived_xpub __attribute__((__cleanup__(keystore_zero_xkey))) = {0};
-    if (!keystore_get_xpub(NULL, 0, &derived_xpub)) {
-        return false;
-    }
-    if (bip32_key_get_fingerprint(&derived_xpub, fingerprint, 4) != WALLY_OK) {
-        return false;
-    }
-    return true;
-}
-
 static bool _ext_key_equal(struct ext_key* one, struct ext_key* two)
 {
     if (!MEMEQ(one->chain_code, two->chain_code, sizeof(one->chain_code))) {

src/keystore.h

@@ -142,15 +142,6 @@ USE_RESULT bool keystore_bip39_mnemonic_to_seed(
     uint8_t* seed_out,
     size_t* seed_len_out);
 
-/**
- * Fills a uint8_t buffer with a fingerprint of the root public key at m/, which are the first four
- * bytes of its hash160 according to:
- * https://github.com/bitcoin/bips/blob/master/bip-0032.mediawiki#serialization-format
- * @param[out] fingerprint, buffer of the fingerprint that is supposed to be filled, has to be size
- * 4
- */
-USE_RESULT bool keystore_get_root_fingerprint(uint8_t* fingerprint);
-
 /**
  * Can be used only if the keystore is unlocked. Returns the derived xpub,
  * using bip32 derivation. Derivation is done from the xprv master, so hardened

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

@@ -17,15 +17,15 @@ use super::Error;
 
 use pb::response::Response;
 
-use bitbox02::keystore;
+use crate::keystore;
 
 /// Returns the keystore's root fingerprint, which is the first 32
 /// bits of the hash160 of the pubkey at the keypath m/.
 /// https://github.com/bitcoin/bips/blob/master/bip-0032.mediawiki#key-identifiers
 pub fn process() -> Result<Response, Error> {
     let fingerprint = keystore::root_fingerprint()?;
     Ok(Response::Fingerprint(pb::RootFingerprintResponse {
-        fingerprint: fingerprint.to_vec(),
+        fingerprint,
     }))
 }
 

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

@@ -38,6 +38,13 @@ pub fn secp256k1_pubkey_hash160(keypath: &[u32]) -> Result<Vec<u8>, ()> {
     Ok(bitbox02::hash160(&xpub.public_key).to_vec())
 }
 
+/// Returns fingerprint of the root public key at m/, which are the first four bytes of its hash160
+/// according to:
+/// https://github.com/bitcoin/bips/blob/master/bip-0032.mediawiki#serialization-format
+pub fn root_fingerprint() -> Result<Vec<u8>, ()> {
+    Ok(secp256k1_pubkey_hash160(&[])?.get(..4).ok_or(())?.to_vec())
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -115,4 +122,20 @@ mod tests {
             *b"\xe5\xf8\x9a\xb6\x54\x37\x44\xf7\x8f\x15\x86\x7c\x43\x06\xee\x86\x6b\xb1\x1d\xf9"
         );
     }
+
+    #[test]
+    fn test_root_fingerprint() {
+        keystore::lock();
+        assert_eq!(root_fingerprint(), Err(()));
+
+        mock_unlocked_using_mnemonic(
+            "purity concert above invest pigeon category peace tuition hazard vivid latin since legal speak nation session onion library travel spell region blast estate stay"
+        );
+        assert_eq!(root_fingerprint(), Ok(vec![0x02, 0x40, 0xe9, 0x2a]));
+
+        mock_unlocked_using_mnemonic(
+            "small agent wife animal marine cloth exit thank stool idea steel frame",
+        );
+        assert_eq!(root_fingerprint(), Ok(vec![0xf4, 0x0b, 0x46, 0x9a]));
+    }
 }

src/rust/bitbox02/src/keystore.rs

@@ -284,14 +284,6 @@ pub fn bip39_mnemonic_to_seed(mnemonic: &str) -> Result<zeroize::Zeroizing<Vec<u
     }
 }
 
-pub fn root_fingerprint() -> Result<[u8; 4], ()> {
-    let mut fingerprint = [0u8; 4];
-    match unsafe { bitbox02_sys::keystore_get_root_fingerprint(fingerprint.as_mut_ptr()) } {
-        true => Ok(fingerprint),
-        false => Err(()),
-    }
-}
-
 pub fn encrypt_and_store_seed(seed: &[u8], password: &SafeInputString) -> Result<(), Error> {
     match unsafe {
         bitbox02_sys::keystore_encrypt_and_store_seed(

test/unit-test/test_keystore.c

@@ -215,15 +215,6 @@ static void _test_keystore_get_xpub(void** state)
     wally_free_string(xpub_string);
 }
 
-static void _test_keystore_get_root_fingerprint(void** state)
-{
-    keystore_mock_unlocked(_mock_seed, sizeof(_mock_seed), _mock_bip39_seed);
-    uint8_t fingerprint[4];
-    assert_true(keystore_get_root_fingerprint(fingerprint));
-    uint8_t expected_fingerprint[4] = {0x9e, 0x1b, 0x2d, 0x1e};
-    assert_memory_equal(fingerprint, expected_fingerprint, 4);
-}
-
 static void _test_keystore_secp256k1_nonce_commit(void** state)
 {
     uint8_t msg[32] = {0};
@@ -783,7 +774,6 @@ int main(void)
 
     const struct CMUnitTest tests[] = {
         cmocka_unit_test(_test_keystore_get_xpub),
-        cmocka_unit_test(_test_keystore_get_root_fingerprint),
         cmocka_unit_test(_test_keystore_secp256k1_nonce_commit),
         cmocka_unit_test(_test_keystore_secp256k1_sign),
         cmocka_unit_test(_test_keystore_encrypt_and_store_seed),