Xbase++
BIP39 Compute Binary Seed from Mnemonic

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).
Chilkat Xbase++ Downloads

Download Chilkat for Xbase++
Xbase++
LOCAL oCrypt
LOCAL cMnemonic
LOCAL cPassphrase
LOCAL cExpectedSeed
LOCAL cExpectedMasterKey
LOCAL oBdSalt
LOCAL cComputedSeed
LOCAL oBdSeed
LOCAL cHmacSha512_hex
LOCAL oBdHmac
LOCAL oBdXprv
LOCAL oBdHash
LOCAL cSecondHash
LOCAL cComputedMasterKey

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

oCrypt := CreateObject("Chilkat.Crypt2")

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

//  This is the 2nd test vector..
cMnemonic := "legal winner thank year wave sausage worth useful legal winner thank yellow"
cPassphrase := "TREZOR"
cExpectedSeed := "2e8905819b8723fe2c1d161860e5ee1830318dbf49a83bd451cfb8440c28bd6fa457fe1296106559a3c80937a1c1069be3a3a5bd381ee6260e8d9739fce1f607"
cExpectedMasterKey := "xprv9s21ZrQH143K2gA81bYFHqU68xz1cX2APaSq5tt6MFSLeXnCKV1RVUJt9FWNTbrrryem4ZckN8k4Ls1H6nwdvDTvnV7zEXs2HgPezuVccsq"

//  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.
oBdSalt := CreateObject("Chilkat.BinData")
oBdSalt:AppendString("mnemonic", "utf-8")
oBdSalt:AppendString(cPassphrase, "utf-8")

cComputedSeed := oCrypt:Pbkdf2(cMnemonic, "utf-8", "sha512", oBdSalt:GetEncoded("hex_lower"), 2048, 512, "hex_lower")

? "Expected: " + cExpectedSeed
? "Computed: " + cComputedSeed

//  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
oBdSeed := CreateObject("Chilkat.BinData")
oBdSeed:AppendEncoded(cComputedSeed, "hex_lower")
oCrypt:EncodingMode := "hex_lower"
oCrypt:HashAlgorithm := "sha512"
oCrypt:SetMacKeyString("Bitcoin seed")
cHmacSha512_hex := oCrypt:MacBdENC(oBdSeed)

oBdHmac := CreateObject("Chilkat.BinData")
oBdHmac:AppendEncoded(cHmacSha512_hex, "hex_lower")

oBdXprv := CreateObject("Chilkat.BinData")
oBdXprv:AppendEncoded("0488ade4", "hex_lower")
oBdXprv:AppendEncoded("000000000000000000", "hex_lower")
oBdXprv:AppendEncoded(oBdHmac:GetEncodedChunk(32, 32, "hex_lower"), "hex_lower")
oBdXprv:AppendByte(0)
oBdXprv:AppendEncoded(oBdHmac:GetEncodedChunk(0, 32, "hex_lower"), "hex_lower")

//  Double hash using SHA256
oCrypt:EncodingMode := "hex_lower"
oCrypt:HashAlgorithm := "sha256"

oBdHash := CreateObject("Chilkat.BinData")
oBdHash:AppendEncoded(oCrypt:HashBdENC(oBdXprv), "hex_lower")
cSecondHash := oCrypt:HashBdENC(oBdHash)
oBdHash:Clear()
oBdHash:AppendEncoded(cSecondHash, "hex_lower")

//  Append the 1st 4 bytes of the bdHash to bdXprv.
oBdXprv:AppendEncoded(oBdHash:GetEncodedChunk(0, 4, "hex_lower"), "hex_lower")

//  Base58 encode bdXprv
cComputedMasterKey := oBdXprv:GetEncoded("base58")

? "Expected Master Key: " + cExpectedMasterKey
? "Computed Master Key: " + cComputedMasterKey

oCrypt:destroy()
oBdSalt:destroy()
oBdSeed:destroy()
oBdHmac:destroy()
oBdXprv:destroy()
oBdHash:destroy()