refactor(platform-wallet): build resolved master keys natively

`seed_for_mnemonic` and `master_key_for_mnemonic` turn a recovery phrase into its BIP-39 seed and its BIP-32 master key, with the seed in a zeroizing buffer. `wallet_id_for_mnemonic` and `first_receive_address_for_mnemonic` use them.

The FFI's resolver helpers now only call the host's mnemonic resolver, check its buffer and UTF-8, and hand the phrase to these functions. So every resolver caller, including the address key reveals, gets its seed and master key from `platform-wallet`. Result codes and the retry classification are unchanged.

Author: xdustinface

packages/rs-platform-wallet-ffi/src/identity_keys_from_mnemonic.rs

@@ -7,7 +7,9 @@ use key_wallet::bip32::{ChildNumber, DerivationPath, ExtendedPrivKey, ExtendedPu
 use key_wallet::dip9::{
     IDENTITY_AUTHENTICATION_PATH_MAINNET, IDENTITY_AUTHENTICATION_PATH_TESTNET,
 };
-use platform_wallet::parse_mnemonic_any_language;
+use platform_wallet::{
+    master_key_for_mnemonic, parse_mnemonic_any_language, seed_for_mnemonic, PlatformWalletError,
+};
 use zeroize::Zeroizing;
 
 use crate::error::*;
@@ -135,14 +137,8 @@ pub(crate) unsafe fn resolve_master_from_resolver_classified(
     wallet_id: &[u8; 32],
     network: Network,
 ) -> Result<ExtendedPrivKey, ResolveFailure> {
-    let seed = resolve_seed_from_resolver_classified(mnemonic_resolver_handle, wallet_id)?;
-    // A seed that cannot yield a master key is the stored material being
-    // wrong, not the moment being wrong.
-    ExtendedPrivKey::new_master(network, seed.as_ref()).map_err(|e| {
-        ResolveFailure::permanent(PlatformWalletFFIResult::err(
-            PlatformWalletFFIResultCode::ErrorWalletOperation,
-            format!("failed to build master xpriv from resolved mnemonic: {e}"),
-        ))
+    with_resolved_mnemonic(mnemonic_resolver_handle, wallet_id, |mnemonic| {
+        master_key_for_mnemonic(mnemonic, network)
     })
 }
 
@@ -179,6 +175,19 @@ pub(crate) unsafe fn resolve_seed_from_resolver_classified(
     mnemonic_resolver_handle: *mut rs_sdk_ffi::MnemonicResolverHandle,
     wallet_id: &[u8; 32],
 ) -> Result<Zeroizing<[u8; 64]>, ResolveFailure> {
+    with_resolved_mnemonic(mnemonic_resolver_handle, wallet_id, seed_for_mnemonic)
+}
+
+/// Reads the mnemonic of `wallet_id` through the resolver into a zeroizing
+/// buffer and returns what `convert` makes of it.
+///
+/// # Safety
+/// Same contract as [`resolve_seed_from_resolver`].
+unsafe fn with_resolved_mnemonic<T>(
+    mnemonic_resolver_handle: *mut rs_sdk_ffi::MnemonicResolverHandle,
+    wallet_id: &[u8; 32],
+    convert: impl FnOnce(&str) -> Result<T, PlatformWalletError>,
+) -> Result<T, ResolveFailure> {
     use rs_sdk_ffi::{mnemonic_resolver_result, MNEMONIC_RESOLVER_BUFFER_CAPACITY};
     use std::ffi::c_void;
 
@@ -236,16 +245,13 @@ pub(crate) unsafe fn resolve_seed_from_resolver_classified(
             format!("mnemonic resolver: returned invalid UTF-8: {e}"),
         ))
     })?;
-    let mnemonic = parse_mnemonic_any_language(mnemonic_str).map_err(|e| {
+    // What is stored cannot yield a key, however often it is read.
+    convert(mnemonic_str).map_err(|e| {
         ResolveFailure::permanent(PlatformWalletFFIResult::err(
             PlatformWalletFFIResultCode::ErrorWalletOperation,
             format!("mnemonic resolver: returned an invalid mnemonic: {e}"),
         ))
-    })?;
-
-    let seed: Zeroizing<[u8; 64]> = Zeroizing::new(mnemonic.to_seed(""));
-    drop(mnemonic);
-    Ok(seed)
+    })
 }
 
 /// Build the DIP-9 identity-authentication derivation path

packages/rs-platform-wallet/src/lib.rs

@@ -91,7 +91,8 @@ pub use wallet::masternode_withdrawal::{
     MasternodeWithdrawalKey, MasternodeWithdrawalKeys, MasternodeWithdrawalRequest,
 };
 pub use wallet::mnemonic::{
-    first_receive_address_for_mnemonic, parse_mnemonic_any_language, wallet_id_for_mnemonic,
+    first_receive_address_for_mnemonic, master_key_for_mnemonic, parse_mnemonic_any_language,
+    seed_for_mnemonic, wallet_id_for_mnemonic,
 };
 pub use wallet::platform_wallet::PlatformWalletInfo;
 #[cfg(feature = "shielded")]

packages/rs-platform-wallet/src/wallet/mnemonic.rs

@@ -24,7 +24,7 @@ pub fn wallet_id_for_mnemonic(
     mnemonic: &str,
     network: Network,
 ) -> Result<WalletId, PlatformWalletError> {
-    let seed = seed_of(mnemonic)?;
+    let seed = seed_for_mnemonic(mnemonic)?;
     let root = RootExtendedPrivKey::new_master(&*seed).map_err(key_derivation)?;
     Ok(Wallet::compute_wallet_id_from_root_extended_pub_key(
         &root.to_root_extended_pub_key(),
@@ -45,8 +45,7 @@ pub fn first_receive_address_for_mnemonic(
     let path = account_type
         .derivation_path(network)
         .map_err(key_derivation)?;
-    let seed = seed_of(mnemonic)?;
-    let mut master = ExtendedPrivKey::new_master(network, &*seed).map_err(key_derivation)?;
+    let mut master = master_key_for_mnemonic(mnemonic, network)?;
     let account_xpriv = master.derive_priv(&path);
     master.private_key.zeroize();
     let mut account_xpriv = account_xpriv.map_err(key_derivation)?;
@@ -70,12 +69,25 @@ pub fn parse_mnemonic_any_language(phrase: &str) -> Result<Mnemonic, &'static st
     Mnemonic::from_phrase(phrase).map_err(|_| "phrase does not match any supported BIP-39 wordlist")
 }
 
-fn seed_of(mnemonic: &str) -> Result<Zeroizing<[u8; 64]>, PlatformWalletError> {
+/// Returns the 64-byte BIP-39 seed of `mnemonic`, wiped when dropped.
+pub fn seed_for_mnemonic(mnemonic: &str) -> Result<Zeroizing<[u8; 64]>, PlatformWalletError> {
     let mnemonic = parse_mnemonic_any_language(mnemonic)
         .map_err(|e| PlatformWalletError::InvalidParameter(e.to_string()))?;
     Ok(Zeroizing::new(mnemonic.to_seed("")))
 }
 
+/// Returns the BIP-32 master key of `mnemonic` on `network`.
+///
+/// `ExtendedPrivKey` wipes nothing on drop, so the caller zeroizes its
+/// `private_key` once done.
+pub fn master_key_for_mnemonic(
+    mnemonic: &str,
+    network: Network,
+) -> Result<ExtendedPrivKey, PlatformWalletError> {
+    let seed = seed_for_mnemonic(mnemonic)?;
+    ExtendedPrivKey::new_master(network, &*seed).map_err(key_derivation)
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -88,6 +100,10 @@ mod tests {
     #[test]
     fn should_match_the_id_of_a_created_wallet() {
         for phrase in [ENGLISH, FRENCH] {
+            assert_eq!(
+                seed_for_mnemonic(phrase).unwrap()[..],
+                Mnemonic::from_phrase(phrase).unwrap().to_seed("")[..]
+            );
             for network in [Network::Mainnet, Network::Testnet, Network::Devnet] {
                 let wallet = Wallet::from_mnemonic(
                     Mnemonic::from_phrase(phrase).unwrap(),