Rust

BIP39 Compute Binary Seed from Mnemonic

See more Encryption Examples

Creates a binary seed from a mnemonic. Uses the PBKDF2 function with a mnemonic sentence (in UTF-8 NFKD) used as the password and the string "mnemonic" + passphrase (again in UTF-8 NFKD) used as the salt. The iteration count is set to 2048 and HMAC-SHA512 is used as the pseudo-random function. The length of the derived key is 512 bits (= 64 bytes). Rust

// This example assumes the Chilkat API to have been previously unlocked.
// See Global Unlock Sample for sample code.

let crypt = chilkat::Crypt2::new();

// Test with the test vectors at https://github.com/trezor/python-mnemonic/blob/master/vectors.json

// This is the 2nd test vector..
let mnemonic = "legal winner thank year wave sausage worth useful legal winner thank yellow".to_string();
let passphrase = "TREZOR".to_string();
let expected_seed = "2e8905819b8723fe2c1d161860e5ee1830318dbf49a83bd451cfb8440c28bd6fa457fe1296106559a3c80937a1c1069be3a3a5bd381ee6260e8d9739fce1f607".to_string();
let expected_master_key = "xprv9s21ZrQH143K2gA81bYFHqU68xz1cX2APaSq5tt6MFSLeXnCKV1RVUJt9FWNTbrrryem4ZckN8k4Ls1H6nwdvDTvnV7zEXs2HgPezuVccsq".to_string();

// The mnemonic sentence (in UTF-8 NFKD) used as the password.
// The string "mnemonic" + passphrase (again in UTF-8 NFKD) used as the salt.
// The iteration count is set to 2048 and HMAC-SHA512 is used as the pseudo-random function.
// The length of the derived key is 512 bits (= 64 bytes). 

// We want the computed seed to be lowercase hex, therefore our salt must also be hex.
// The seed is the keyword "mnemonic" + passphrase (in this case is "TREZOR") converted to hex.
let bd_salt = chilkat::BinData::new();
let _ = bd_salt.append_string("mnemonic", "utf-8");
let _ = bd_salt.append_string(&passphrase, "utf-8");

let computed_seed = crypt.pbkdf2(&mnemonic, "utf-8", "sha512", &bd_salt.get_encoded("hex_lower").unwrap_or_default(), 2048, 512, "hex_lower").unwrap_or_default();

println!("Expected: {}", expected_seed);
println!("Computed: {}", computed_seed);

// To compute the hd_master_key, duplicate this Python code:

//     def to_hd_master_key(seed: bytes, testnet: bool = False) -> str:
//         if len(seed) != 64:
//             raise ValueError("Provided seed should have length of 64")
// 
//         # Compute HMAC-SHA512 of seed
//         seed = hmac.new(b"Bitcoin seed", seed, digestmod=hashlib.sha512).digest()
// 
//         # Serialization format can be found at: https://github.com/bitcoin/bips/blob/master/bip-0032.mediawiki#Serialization_format
//         xprv = b"\x04\x88\xad\xe4"  # Version for private mainnet
//         if testnet:
//             xprv = b"\x04\x35\x83\x94"  # Version for private testnet
//         xprv += b"\x00" * 9  # Depth, parent fingerprint, and child number
//         xprv += seed[32:]  # Chain code
//         xprv += b"\x00" + seed[:32]  # Master key
// 
//         # Double hash using SHA256
//         hashed_xprv = hashlib.sha256(xprv).digest()
//         hashed_xprv = hashlib.sha256(hashed_xprv).digest()
// 
//         # Append 4 bytes of checksum
//         xprv += hashed_xprv[:4]
// 
//         # Return base58
//         return b58encode(xprv)

// First compute the HMAC-SHA512 of the computedSeed
let bd_seed = chilkat::BinData::new();
let _ = bd_seed.append_encoded(&computed_seed, "hex_lower");
crypt.set_encoding_mode("hex_lower");
crypt.set_hash_algorithm("sha512");
let _ = crypt.set_mac_key_string("Bitcoin seed");
let hmac_sha512_hex = crypt.mac_bd_enc(&bd_seed).unwrap_or_default();

let bd_hmac = chilkat::BinData::new();
let _ = bd_hmac.append_encoded(&hmac_sha512_hex, "hex_lower");

let bd_xprv = chilkat::BinData::new();
let _ = bd_xprv.append_encoded("0488ade4", "hex_lower");
let _ = bd_xprv.append_encoded("000000000000000000", "hex_lower");
let _ = bd_xprv.append_encoded(&bd_hmac.get_encoded_chunk(32, 32, "hex_lower").unwrap_or_default(), "hex_lower");
let _ = bd_xprv.append_byte(0);
let _ = bd_xprv.append_encoded(&bd_hmac.get_encoded_chunk(0, 32, "hex_lower").unwrap_or_default(), "hex_lower");

// Double hash using SHA256
crypt.set_encoding_mode("hex_lower");
crypt.set_hash_algorithm("sha256");

let bd_hash = chilkat::BinData::new();
let _ = bd_hash.append_encoded(&crypt.hash_bd_enc(&bd_xprv).unwrap_or_default(), "hex_lower");
let second_hash = crypt.hash_bd_enc(&bd_hash).unwrap_or_default();
let _ = bd_hash.clear();
let _ = bd_hash.append_encoded(&second_hash, "hex_lower");

// Append the 1st 4 bytes of the bdHash to bdXprv.
let _ = bd_xprv.append_encoded(&bd_hash.get_encoded_chunk(0, 4, "hex_lower").unwrap_or_default(), "hex_lower");

// Base58 encode bdXprv
let computed_master_key = bd_xprv.get_encoded("base58").unwrap_or_default();

println!("Expected Master Key: {}", expected_master_key);
println!("Computed Master Key: {}", computed_master_key);