Merge branch 'hash160-rust'

Author: benma

src/CMakeLists.txt

@@ -317,15 +317,13 @@ 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-function keystore_secp256k1_pubkey_hash160
     --allowlist-var EC_PUBLIC_KEY_UNCOMPRESSED_LEN
     --allowlist-var EC_PUBLIC_KEY_LEN
     --allowlist-function keystore_encode_xpub_at_keypath
     --allowlist-function keystore_encrypt_and_store_seed
-    --rustified-enum xpub_type_t
     --allowlist-var XPUB_ENCODED_LEN
+    --allowlist-var BIP32_SERIALIZED_LEN
     --allowlist-function lock_animation_start
     --allowlist-function lock_animation_stop
     --allowlist-function delay_us

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))) {
@@ -569,19 +557,6 @@ static bool _compressed_to_uncompressed(const uint8_t* pubkey_bytes, uint8_t* un
     return true;
 }
 
-bool keystore_secp256k1_pubkey_hash160(
-    const uint32_t* keypath,
-    size_t keypath_len,
-    uint8_t* hash160_out)
-{
-    struct ext_key xpub __attribute__((__cleanup__(keystore_zero_xkey))) = {0};
-    if (!keystore_get_xpub(keypath, keypath_len, &xpub)) {
-        return false;
-    }
-    memcpy(hash160_out, xpub.hash160, sizeof(xpub.hash160));
-    return true;
-}
-
 bool keystore_secp256k1_pubkey_uncompressed(
     const uint32_t* keypath,
     size_t keypath_len,
@@ -706,82 +681,17 @@ bool keystore_get_ed25519_seed(uint8_t* seed_out)
     return true;
 }
 
-static const uint8_t _xpub_version[4] = {0x04, 0x88, 0xb2, 0x1e};
-static const uint8_t _ypub_version[4] = {0x04, 0x9d, 0x7c, 0xb2};
-static const uint8_t _zpub_version[4] = {0x04, 0xb2, 0x47, 0x46};
-static const uint8_t _tpub_version[4] = {0x04, 0x35, 0x87, 0xcf};
-static const uint8_t _vpub_version[4] = {0x04, 0x5f, 0x1c, 0xf6};
-static const uint8_t _upub_version[4] = {0x04, 0x4a, 0x52, 0x62};
-static const uint8_t _capital_vpub_version[4] = {0x02, 0x57, 0x54, 0x83};
-static const uint8_t _capital_zpub_version[4] = {0x02, 0xaa, 0x7e, 0xd3};
-static const uint8_t _capital_upub_version[4] = {0x02, 0x42, 0x89, 0xef};
-static const uint8_t _capital_ypub_version[4] = {0x02, 0x95, 0xb4, 0x3f};
-
-bool keystore_encode_xpub(
-    const struct ext_key* xpub,
-    xpub_type_t xpub_type,
-    char* out,
-    size_t out_len)
-{
-    uint8_t bytes[BIP32_SERIALIZED_LEN] = {0};
-    if (bip32_key_serialize(xpub, BIP32_FLAG_KEY_PUBLIC, bytes, sizeof(bytes)) != WALLY_OK) {
-        return false;
-    }
-
-    const uint8_t* version;
-    switch (xpub_type) {
-    case XPUB:
-        version = _xpub_version;
-        break;
-    case YPUB:
-        version = _ypub_version;
-        break;
-    case ZPUB:
-        version = _zpub_version;
-        break;
-    case TPUB:
-        version = _tpub_version;
-        break;
-    case VPUB:
-        version = _vpub_version;
-        break;
-    case UPUB:
-        version = _upub_version;
-        break;
-    case CAPITAL_VPUB:
-        version = _capital_vpub_version;
-        break;
-    case CAPITAL_ZPUB:
-        version = _capital_zpub_version;
-        break;
-    case CAPITAL_UPUB:
-        version = _capital_upub_version;
-        break;
-    case CAPITAL_YPUB:
-        version = _capital_ypub_version;
-        break;
-    default:
-        return false;
-    }
-
-    // Overwrite bip32 version.
-    memcpy(bytes, version, 4);
-    return rust_base58_encode_check(
-        rust_util_bytes(bytes, sizeof(bytes)), rust_util_cstr_mut(out, out_len));
-}
-
 USE_RESULT bool keystore_encode_xpub_at_keypath(
     const uint32_t* keypath,
     size_t keypath_len,
-    xpub_type_t xpub_type,
-    char* out,
-    size_t out_len)
+    uint8_t* out)
 {
     struct ext_key derived_xpub __attribute__((__cleanup__(keystore_zero_xkey))) = {0};
     if (!keystore_get_xpub(keypath, keypath_len, &derived_xpub)) {
         return false;
     }
-    return keystore_encode_xpub(&derived_xpub, xpub_type, out, out_len);
+    return bip32_key_serialize(&derived_xpub, BIP32_FLAG_KEY_PUBLIC, out, BIP32_SERIALIZED_LEN) ==
+           WALLY_OK;
 }
 
 static void _tagged_hash(const char* tag, const uint8_t* msg, size_t msg_len, uint8_t* hash_out)

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
@@ -175,18 +166,6 @@ void keystore_zero_xkey(struct ext_key* xkey);
  */
 USE_RESULT bool keystore_get_bip39_word(uint16_t idx, char** word_out);
 
-/**
- * Return the hash160 of the secp256k1 public key at the keypath.
- * @param[in] keypath derivation keypath
- * @param[in] keypath_len size of keypath buffer
- * @param[out] hash160_out serialized output. Must be HASH160_LEN bytes.
- * @return true on success, false if the keystore is locked or the input is invalid.
- */
-USE_RESULT bool keystore_secp256k1_pubkey_hash160(
-    const uint32_t* keypath,
-    size_t keypath_len,
-    uint8_t* hash160_out);
-
 /**
  * Return the serialized secp256k1 public key at the keypath, in uncompressed format.
  * @param[in] keypath derivation keypath
@@ -269,44 +248,15 @@ USE_RESULT bool keystore_get_u2f_seed(uint8_t* seed_out);
  */
 USE_RESULT bool keystore_get_ed25519_seed(uint8_t* seed_out);
 
-typedef enum {
-    XPUB,
-    YPUB,
-    ZPUB,
-    TPUB,
-    VPUB,
-    UPUB,
-    CAPITAL_VPUB,
-    CAPITAL_ZPUB,
-    CAPITAL_UPUB,
-    CAPITAL_YPUB,
-} xpub_type_t;
-/**
- * Encode an xpub as a base58 string.
- * @param[in] xpub the xpub to encode.
- * @param[in] xpub_type determines the xpub format.
- * etc.
- * @param[out] out resulting string, must be at least of size `XPUB_ENCODED_LEN` (including the null
- * terminator).
- * @param[in] out_len size of `out`.
- * @return false on failure, true on success.
- */
-USE_RESULT bool keystore_encode_xpub(
-    const struct ext_key* xpub,
-    xpub_type_t xpub_type,
-    char* out,
-    size_t out_len);
-
 /**
- * Encode an xpub as a base58 string at the given `keypath`.
- * Args the same as `keystore_encode_xpub`.
+ * Encode an xpub at the given `keypath` as 78 bytes according to BIP32. The version bytes are
+ * the ones corresponding to `xpub`, i.e. 0x0488B21E.
+ * `out` must be `BIP32_SERIALIZED_LEN` long.
  */
 USE_RESULT bool keystore_encode_xpub_at_keypath(
     const uint32_t* keypath,
     size_t keypath_len,
-    xpub_type_t xpub_type,
-    char* out,
-    size_t out_len);
+    uint8_t* out);
 
 /**
  * Return the tweaked taproot pubkey at the given keypath.

src/rust/bitbox02-rust/Cargo.toml

@@ -38,7 +38,7 @@ zeroize = "1.5.5"
 num-bigint = { version = "0.4.3", default-features = false, optional = true }
 num-traits = { version = "0.2", default-features = false, optional = true }
 bip32-ed25519 = { git = "https://github.com/digitalbitbox/rust-bip32-ed25519", tag = "v0.1.0", optional = true }
-bs58 = { version = "0.4.0", default-features = false, features = ["alloc", "check"], optional = true }
+bs58 = { version = "0.4.0", default-features = false, features = ["alloc", "check"] }
 bech32 = { version = "0.8.1", default-features = false, optional = true }
 blake2 = { version = "0.10.5", default-features = false, optional = true }
 minicbor = { version = "0.18.0", default-features = false, features = ["alloc"], optional = true }
@@ -78,14 +78,12 @@ app-ethereum = [
 
 app-bitcoin = [
   # enable these dependencies
-  "bs58",
   "bech32",
   # enable this feature in the deps
   "bitbox02/app-bitcoin",
 ]
 app-litecoin = [
   # enable these dependencies
-  "bs58",
   "bech32",
   # enable this feature in the deps
   "bitbox02/app-litecoin",
@@ -100,7 +98,6 @@ app-cardano = [
   # enable these deps
   "bech32",
   "blake2",
-  "bs58",
   "minicbor",
   "crc",
 

src/rust/bitbox02-rust/src/bip32.rs

@@ -61,18 +61,28 @@ pub fn serialize_xpub_str(xpub: &pb::XPub, xpub_type: XPubType) -> Result<String
         .into_string())
 }
 
-#[cfg(test)]
-pub fn parse_xpub(xpub: &str) -> Result<pb::XPub, ()> {
-    let decoded = bs58::decode(xpub).into_vec().or(Err(()))?;
+/// Parses an 78-ytes xpub bytestring, encoded according to BIP32. The 4 version bytes are not
+/// checked and discarded.
+pub fn parse_xpub_bytes(xpub: &[u8]) -> Result<pb::XPub, ()> {
+    if xpub.len() != 78 {
+        return Err(());
+    }
     Ok(pb::XPub {
-        depth: decoded[4..5].to_vec(),
-        parent_fingerprint: decoded[5..9].to_vec(),
-        child_num: u32::from_be_bytes(core::convert::TryInto::try_into(&decoded[9..13]).unwrap()),
-        chain_code: decoded[13..45].to_vec(),
-        public_key: decoded[45..78].to_vec(),
+        depth: xpub[4..5].to_vec(),
+        parent_fingerprint: xpub[5..9].to_vec(),
+        child_num: u32::from_be_bytes(core::convert::TryInto::try_into(&xpub[9..13]).unwrap()),
+        chain_code: xpub[13..45].to_vec(),
+        public_key: xpub[45..78].to_vec(),
     })
 }
 
+/// Parses a Base58Check-encoded xpub string. The 4 version bytes are not checked and discarded.
+#[cfg(test)]
+pub fn parse_xpub(xpub: &str) -> Result<pb::XPub, ()> {
+    let decoded = bs58::decode(xpub).with_check(None).into_vec().or(Err(()))?;
+    parse_xpub_bytes(&decoded)
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;

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

@@ -32,7 +32,7 @@ use crate::workflow::confirm;
 
 use util::bip32::HARDENED;
 
-use bitbox02::keystore::{encode_xpub_at_keypath, xpub_type_t};
+use crate::keystore;
 
 use pb::btc_pub_request::{Output, XPubType};
 use pb::btc_request::Request;
@@ -105,21 +105,12 @@ async fn xpub(
 ) -> Result<Response, Error> {
     let params = params::get(coin);
     keypath::validate_xpub(keypath, params.bip44_coin, params.taproot_support)?;
-    let xpub_type = match xpub_type {
-        XPubType::Tpub => xpub_type_t::TPUB,
-        XPubType::Xpub => xpub_type_t::XPUB,
-        XPubType::Ypub => xpub_type_t::YPUB,
-        XPubType::Zpub => xpub_type_t::ZPUB,
-        XPubType::Vpub => xpub_type_t::VPUB,
-        XPubType::Upub => xpub_type_t::UPUB,
-        XPubType::CapitalVpub => xpub_type_t::CAPITAL_VPUB,
-        XPubType::CapitalZpub => xpub_type_t::CAPITAL_ZPUB,
-        XPubType::CapitalUpub => xpub_type_t::CAPITAL_UPUB,
-        XPubType::CapitalYpub => xpub_type_t::CAPITAL_YPUB,
-    };
-    let xpub = encode_xpub_at_keypath(keypath, xpub_type).or(Err(Error::InvalidInput))?;
+    let xpub = crate::bip32::serialize_xpub_str(
+        &keystore::get_xpub(keypath).or(Err(Error::InvalidInput))?,
+        xpub_type,
+    )?;
     if display {
-        let title = format!("{}\naccount #{}", params.name, keypath[2] - HARDENED + 1,);
+        let title = format!("{}\naccount #{}", params.name, keypath[2] - HARDENED + 1);
         let confirm_params = confirm::Params {
             title: &title,
             body: &xpub,

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

@@ -77,14 +77,14 @@ impl Payload {
     ) -> Result<Self, Error> {
         match simple_type {
             SimpleType::P2wpkh => Ok(Payload {
-                data: keystore::secp256k1_pubkey_hash160(keypath)?.to_vec(),
+                data: crate::keystore::secp256k1_pubkey_hash160(keypath)?,
                 output_type: BtcOutputType::P2wpkh,
             }),
             SimpleType::P2wpkhP2sh => {
                 let payload_p2wpkh = Payload::from_simple(params, SimpleType::P2wpkh, keypath)?;
                 let pkscript_p2wpkh = payload_p2wpkh.pk_script(params)?;
                 Ok(Payload {
-                    data: bitbox02::app_btc::hash160(&pkscript_p2wpkh).to_vec(),
+                    data: bitbox02::hash160(&pkscript_p2wpkh).to_vec(),
                     output_type: BtcOutputType::P2sh,
                 })
             }
@@ -134,7 +134,7 @@ impl Payload {
             pb::btc_script_config::multisig::ScriptType::P2wshP2sh => {
                 let pkscript_p2wsh = payload_p2wsh.pk_script(params)?;
                 Ok(Payload {
-                    data: bitbox02::app_btc::hash160(&pkscript_p2wsh).to_vec(),
+                    data: bitbox02::hash160(&pkscript_p2wsh).to_vec(),
                     output_type: BtcOutputType::P2sh,
                 })
             }