Java

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). Chilkat2 Java

import com.chilkatsoft.chilkat2.BinData;
import com.chilkatsoft.chilkat2.Crypt2;

public class ChilkatExample {

    public static void main(String[] args) {
        // This example assumes the Chilkat API to have been previously unlocked.
        // See Global Unlock Sample for sample code.

        Crypt2 crypt = new Crypt2();

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

        // This is the 2nd test vector..
        String mnemonic = "legal winner thank year wave sausage worth useful legal winner thank yellow";
        String passphrase = "TREZOR";
        String expectedSeed = "2e8905819b8723fe2c1d161860e5ee1830318dbf49a83bd451cfb8440c28bd6fa457fe1296106559a3c80937a1c1069be3a3a5bd381ee6260e8d9739fce1f607";
        String expectedMasterKey = "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.
        BinData bdSalt = new BinData();
        bdSalt.appendString("mnemonic", "utf-8");
        bdSalt.appendString(passphrase, "utf-8");

        String computedSeed = crypt.pbkdf2(mnemonic, "utf-8", "sha512", bdSalt.getEncoded("hex_lower"), 2048, 512, "hex_lower");

        System.out.println("Expected: " + expectedSeed);
        System.out.println("Computed: " + computedSeed);

        // 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
        BinData bdSeed = new BinData();
        bdSeed.appendEncoded(computedSeed, "hex_lower");
        crypt.setEncodingMode("hex_lower");
        crypt.setHashAlgorithm("sha512");
        crypt.setMacKeyString("Bitcoin seed");
        String hmacSha512_hex = crypt.macBdENC(bdSeed);

        BinData bdHmac = new BinData();
        bdHmac.appendEncoded(hmacSha512_hex, "hex_lower");

        BinData bdXprv = new BinData();
        bdXprv.appendEncoded("0488ade4", "hex_lower");
        bdXprv.appendEncoded("000000000000000000", "hex_lower");
        bdXprv.appendEncoded(bdHmac.getEncodedChunk(32, 32, "hex_lower"), "hex_lower");
        bdXprv.appendByte(0);
        bdXprv.appendEncoded(bdHmac.getEncodedChunk(0, 32, "hex_lower"), "hex_lower");

        // Double hash using SHA256
        crypt.setEncodingMode("hex_lower");
        crypt.setHashAlgorithm("sha256");

        BinData bdHash = new BinData();
        bdHash.appendEncoded(crypt.hashBdENC(bdXprv), "hex_lower");
        String secondHash = crypt.hashBdENC(bdHash);
        bdHash.clear();
        bdHash.appendEncoded(secondHash, "hex_lower");

        // Append the 1st 4 bytes of the bdHash to bdXprv.
        bdXprv.appendEncoded(bdHash.getEncodedChunk(0, 4, "hex_lower"), "hex_lower");

        // Base58 encode bdXprv
        String computedMasterKey = bdXprv.getEncoded("base58");

        System.out.println("Expected Master Key: " + expectedMasterKey);
        System.out.println("Computed Master Key: " + computedMasterKey);
    }
}