Title: [Full Guide+Code]Seed Phrase & The Process of Deriving Bitcoin Addresses from It Post by: webtricks on February 09, 2021, 08:57:10 PM Earlier Bitcoin Wallet used to be a bunch of private keys. In order to use new address, user had to generate new private key which made the whole process cumbersome because user had to backup each and every private key. Hierarchical Deterministic (HD) wallet made the process easier. Deterministic wallet means the wallet uses a single starting point to derive all the addresses. That single starting point is known as 'mnemonic seed' or 'seed phrase'. Today, more than 95% non-custodial wallets generate addresses deterministically and if they aren't, you shouldn't be using those wallets.
Considering that the seed phrase has become integral part of Bitcoin Wallet, I will explain the whole process on how bitcoin addresses are derived from seed phrase along-with Javascript code so you can easily test the process in your computer without downloading or installing any utility. Table of Contents 1. Generate Random Sequence or Entropy (#post_one) 2. Create Checksum and Prepare Final Sequence (#post_two) 3. Convert Sequence into Mnemonic Codes (#post_three) 4. PBKDF2 Key-Stretching Function (#post_four) 5. Master Private Key, Master Public Key and Chain Code (#post_five) 6. Derivation Path and BIP-44 (#post_six) 7. Child Private Key Derivation (#post_seven) 8. Generate Bitcoin Addresses from Private Keys (#post_eight) 9. Javascript Codes (#post_nine) 1. Generate Random Sequence or Entropy Earlier I said that the mnemonic (or seed phrase) is the starting point of the wallet which may not be entirely true. In order to derive mnemonic, we first need to generate entropy. In easier words, entropy is nothing but the measure of randomness. In order to secure wallet, we need it to be based on something unpredictable, hence entropy of 128-256 bits is used. The easiest way to generate entropy is by flipping the coin. Take a coin and toss it 128 times, write 0 when heads come while write 1 when tails come. After 128 flips, you will have the random sequence of 0s and 1s which is your entropy. You can do the same 256 times to increase the security of your wallet (longer the entropy, higher the security). Check the image below to understand the process better: https://i.imgur.com/4T4lIbP.png The 0 and 1 sequence you see above is the distinct point. This should be generated as random as possible. If weak random generator is used then hackers can easily brute-force your sequence and steal the funds. 2. Create Checksum and Prepare Final Sequence Now, as we have the 128-bit entropy, we need to generate checksum. Checksum is nothing but a fingerprint attached at the end of something to ensure user has made no mistake is copying that thing. In our case, we will generate fingerprint of our entropy. As defined in BIP-39, we take SHA-256 hash of the entropy as the fingerprint. Before moving forward, let's convert our entropy from Base2 to Base16 or hexadecimal. Base2 means we use 2 symbols to express our number, as we saw in Step 1, those numbes are '0' and '1'. Similarly, Base16 (or hexadecimal) uses 16 symbols to express the number, those are: 0,1,2,3,4,5,6,7,8,9,a,b,c,d,e,f. Check the image below to understand how conversion works: https://i.imgur.com/I2HzUOk.png You can see that 0001 in Base2 is equal to 1 in hexadecimal, 0010 is equal to 2 and so on. So, our entropy in hexadecimal is represented as 91d3785bf884c639f600b3e587083265. But important point here is that both are same, just representation is different. Back to checksum now, like I said earlier, SHA-256 of the entropy is used as checksum, let's generate the SHA-256 of our entropy: SHA-256 hash of 0x91d3785bf884c639f600b3e587083265 = effdb98e4c4ac27c670f704c39a2e0ba8b85bc4561a7a02a6297e465ed155d30 The hash is 256-bit long number represented by 64 hexadecimal characters. In other words, each hexadecimal character represents 4 bits. As per BIP-39, instead using the whole hash, only first (entropy length / 32) bits of the hash are used as checksum. In our case, the length of entropy is 128 which when divided by 32 gives 4. So, we will only take first four bits of the hash as checksum. If the length of your entropy is 256, checksum would be 256/32 or first 8 bits of the hash. As I said earlier, each hexadecimal character represents four bits, the first four bits of our hash in hexadecimal are represented by 'e'. So, our checksum is 'e' in hexadecimal and 1110 in Base2 (or binary). Now, we append checksum at the end of the sequence which will make our final sequence in hexadecimal as, 0x91d3785bf884c639f600b3e587083265e. Or in Base2 as: https://i.imgur.com/rgP7r2F.png 3. Convert Sequence into Mnemonic Codes Now the length of the sequence is 132 bits. Next step involves splitting the sequence into the chunk of 11 bits. Since, our sequence is of 132 which when divided by 11 gives 12, so we will get 12 chunks. We will get 24 chunks if 256-bit entropy is used. Here are the chunks of our entropy: 10010001110 10011011110 00010110111 11110001000 01001100011 00011100111 11011000000 00010110011 11100101100 00111000010 00001100100 11001011110 As you can notice, each chunk is a binary number. The lowest value of the chunk can be 00000000000 which is 0 in decimal. Whereas, maximum value can be 11111111111 which is 2047 in decimal. So, each chunk is valued between 0-2047. BIP-39 defined 2048 words, each word representing one number from 0 to 2047. I have prepared a table so you can see which word is used for which value, visit the link below to view the table: BIP-39 WORDS (https://webtricks.website/words) From the table, you can see that the decimal values of our chunks are: 1166, 1246, 183, 1928, 611, 231, 1728, 179, 1836, 450, 100, 1630 Picking the adjacent words from the link, we got the following mnemonic code: Code: mushroom orange black valve erase brother submit biology tortoise debate arrive slim 4. PBKDF2 Key-Stretching Function Password-based Key Derivation Function 2 (or PBKDF2) is used as a security measure in the process. This function allows the use of 'passphrase' to further increase the security of our mnemonic code. You can read more about PBKDF2 function on: Wikipedia (https://en.wikipedia.org/wiki/PBKDF2). In our bitcoin address derivation process, PBKDF2 is used to stretch mnemonic code by using 2048 rounds of HMAC-SHA512 algorithm. The algorithm takes two parameters, one is mnemonic code and second is salt. If user decides to opt for no passphrase then salt is the string with the value - 'mnemonic'. But, if user decides, let say, 'webby' as the passphrase. Then, salt will become- 'mnemonicwebby'. We concat passphrase at the end of 'mnemonic' string in salt. Hence, our PBKDF2 function will become: Code: DK = PBKDF2(PRF, Password, Salt, c, dkLen) where, PRF is pseudorandom function (here HMAC) Password is our mnemonic code Salt is string 'mnemonic' without any passphrase c is the number of iteration. In our case, 2048 dkLen is the desired length of derived key (we want 512-bit seed so we selected 64 byte since 1 byte = 8 bits) DK refers to the final key or seed we derived from the process. In our case, we will get 512-bit value as the result. The key for our mnemonic code with no passphrase is: Code: 65729d81d461591bac7384dea43dbd44438053cd1fdc113e0769c49c5fde025ba331eed2077497634e619948437d0448e769a86c0cbbecf01b13fd53540743b3 5. Master Private Key, Master Public Key and Chain Code As I discussed in the starting of the thread, the main purpose of using seed phrase is to get hierarchical tree like structure, where each private or public key is derived from its parent and can derive its children. Master Private Key is the top of the hierarchy. It is a private key at first level with no parent. We have generated DK or 512-bit seed in the last step. This seed will now be used in HMAC-SHA512 function to derive private key and chain code. HMAC-SHA512 function takes two parameters - message and secret key. In our case, 512-bit seed from the last step is message and as defined in BIP-32, string 'Bitcoin seed' is used as secret key. So, HMAC(seed, 'Bitcoin seed') = Hash The resulting hash will be a 512-bit value. In our case, it is the following: Code: a0ccf14c939faa07b896cd5fb306a37fb3f9cb041196c5364d0cca9dbd82e53a5bc9d1368631ae579f02ed8e46a56dd9dd9de8ac59e3c4e18247ff96988bdf1f Note that the length of the output is 512 bits or 128 hexadecimal characters. The first 256 bits (represented by the first 64 hexadecimal characters) will become our Master Private Key whereas next 256 bits will become our Chain Code. Hence, Code: Master Private Key: a0ccf14c939faa07b896cd5fb306a37fb3f9cb041196c5364d0cca9dbd82e53a Master Public Key can be derived from Master Private Key using Elliptic Curve Cryptography. I have written detailed thread on ECC. You can follow this thread: THE THREAD (https://bitcointalk.org/index.php?topic=5223167.msg53772308#msg53772308) and see how public key is derived from private key. Process is same for the Master Public Key as well. Using the same logic, Code: our Master Public Key: 03d1cc1f6bdea4d17eb7f2573d676f9ddb087f8b784c912c4466407781d8acfe38 6. Derivation Path and BIP-44 To easily understand the meaning of derivation path, you can assume it as a map which guides us how should be go through the children from the master private key to finally reach the bitcoin address. BIP-44 defines the following path for Bitcoin Mainnet: Code: Path format: m / purpose' / coin_type' / account' / change / address_index To understand the above, first look at the image below: https://i.imgur.com/YmqY8VJ.png It's like we will go to the master private key and ask, who is your 45th hardened child. Then we will go to the 45th child and ask it, who is your first hardened child. Then we will go to the first hardened child of the first hardened child of the master private key and ask it who is your first child. Then we will go and catch the first child and take its children one-by-one as our private keys. First child will become our first private key which will be used to derive our first bitcoin address and so on. Now you maybe wondering what's the difference between hardened child and normal child. When we say first hardened child, it's actually (231+1)th child. For easy understanding, we replace 231 and use the symbol of prime ( ' ). So, 231+1 or 2147483649th child of the parent is first hardened or 0' child. (Notice the sign of prime at the right top of 0) For more serious discussion about Derivation Path, check this thread from Blue Snow: https://bitcointalk.org/index.php?topic=5243350 7. Child Private Key Derivation Okay, now as we know which child keys are to be derived, let's see how child key is derived: To derive the child key, again HMAC-SHA512 hashing algorithm is used. As we discussed earlier, HMAC-SHA512 algorithm requires 2 params - message and secret key. Here, message is our master private or public key concatenated with the child number (also known as child index) and secret key is the chain code. So, Hash = HMAC(master key + index, chain code) Important Point: When we are deriving hardened child, master private key will be used as message. Whereas, master public key will be used in case we are deriving normal child. Now let's get started with the process: LEVEL 1: Deriving 45th hardened child of the Master Key (Since it's hardened, Master Private Key will be used) Code: Master Private Key = a0ccf14c939faa07b896cd5fb306a37fb3f9cb041196c5364d0cca9dbd82e53a (taken from the fifth step) Note, we got the output of 512 bits. Similar to what we discussed in fifth step, the left 256 bits of the output will be used for the private key of our 45th hardened child and right 256 bits will become the chain code of the child. The left 256 bits are assumed as a hexadecimal number and added to the parent private key. Then we take the modulus of the addition with 'n' parameter as defined by SECG in this document: SECG Vol 2 (https://www.secg.org/sec2-v2.pdf) Code: Left 256 bits = 7fc9ce32a6aeffbeaf5057f266f0d6ed6383ed84f21c96d53c0c1e3838a87e24 LEVEL 2: Deriving first hardened child of the Level 1 Child (Since it's hardened, Private Key will be used) Code: Private Key = 2096bf7f3a4ea9c667e7255219f77a6e5ccedba2546abbcfc9468a4925f5221d LEVEL 3: Deriving first hardened child of the Level 2 Child (Since it's hardened, Private Key will be used) Code: Private Key = ff7b844a9ca9d1b899007245d8f62154d741edd1cc1204895144779c59bf8614 LEVEL 4: Deriving first normal child of the Level 3 Child (Since it's normal, Public Key will be used) Code: Private Key = 27b52d3d12ea694ced4d4ee5261d69fa06cfba73d318e734b586ef8d7738b9ee LEVEL 5: Deriving first 3 normal children of the Level 4 Child (Since it's normal, Public Key will be used) Code: Private Key = e519213b4099dc0a4f26d22ca0a09add7ebc7c6e3964d57f46617f8db522a97a 8. Generate Bitcoin Addresses from Private Keys In the last step, we derived 3 private keys at Level 5 using index 00000000, 00000001 and 00000002. If you want to derive more private keys in the hierarchy, just keep on incrementing index by 1. So, 00000003 will be used for next private key and so on. Also, remember that this is hexadecimal number so after 00000009, next index will be 0000000a, not 00000010. Now, let's generate the bitcoin addresses from our private key. I have already created a thread explaining how to generate Legacy addresses (starting with '1') from private key in detail here: How Bitcoin Addresses are generated? Understand the Math behind Bitcoin (https://bitcointalk.org/index.php?topic=5223167.msg53772308#msg53772308) You can follow the above thread and you will be able to generate first 3 Legacy Bitcoin Addresses of the hierarchy using private keys from Step 7, which will be: Quote 1MbJqqvN8ZPYsUch45HdRAxKbH6bJeGfZi 1GMpMNYwhb7Wvu8q1Zy52MtZUGWvLgCXak 12fv5eg3kzBgZQy7ue2yYmC9xXohmKWGR3 I will use the current thread to explain how to generate P2SH Address. P2SH is very different from the P2PKH (or Legacy) address. In Legacy address, we simply generate the hash of the public key and use it as the address. But in P2SH, we first create a script, then generate hash of the script. Then, transaction is made to the script. Now, script can literally be anything. Sender of the transaction don't have to know what does the script mean. Bitcoin has its own scripting language (https://en.bitcoin.it/wiki/Script) and the script has defined many opcodes such as OP_ADD, OP_EQUAL and many more. So, I can literally create a script, let say, 'what when added to 3 makes 5'. Create hash of this script and use it as P2SH Address. Then the payment made to that P2SH address can be spent by providing original script i.e. 'what when added to 3 makes 5' and solution script i.e. '2' along with the hash. P2SH can be used to create a lot more complex scripts but one of the most common type of P2SH is our P2WPKH-in-P2SH. It simply means using P2PKH in the P2SH script. This is the type of addresses you see while creating a wallet (the ones starting with '3'). Now, let's see, how are these created: The scheme for P2WPKH-in-P2SH format is defined in BIP-49. In step 6, we discussed that the 45th hardened child of Master Private Key is used in the hierarchy. That's true for Legacy addresses but for P2WPKH-in-P2SH, we use the 50th hardened child, so, derivation path becomes: Code: m / 49' / 0' / 0' / 0 / address_index Except this, rest of the process is same as discussed in Step 6 and 7. I have repeated the Step 7 with our Master Private Key, i.e. a0ccf14c939faa07b896cd5fb306a37fb3f9cb041196c5364d0cca9dbd82e53a and got the following three private keys as the first 3 normal child of m/49'/0'/0'/0 path i.e. Level 5: Code: Private Key of first normal child of Level 4 Child = 26e1061459e7961eeac018efa765339d785bd30de91f8fade64c639b275d74c4 (to be used for deriving first bitcoin address) Using ECC, I got the following Public Keys (second reminder, if you wanna know how public key is derived from private key, check out my thread I mentioned in Step 5): Code: Public Key of first normal child of Level 4 Child = 021549dd72d89cbc844bb74ab6247239cf60d184cbfb0cfc4d024150a4985412fe (to be used for deriving first bitcoin address) First check the image below to understand how public key is converted into Bitcoin Address: https://i.imgur.com/EPRTjBV.png Now time for the explanation: Firstly, we create SHA-256 hash of the public key: Code: SHA-256(public key) = Hash Then, we create ripemd160 hash of the sha256 hash: Code: RIPEMD160(hash) = Hash160 Then, we concat 0x0014 before the hash: Code: serialization = 0x0014 + Hash160 Now, as we have our script, next step involves creating hash of the script: Code: SHA-256(script) = Hash Then add 0x05 before the hash160 i.e. encoding byte for script hash Code: serialization = 0x05 + Hash160 Creating checksum of the hash Code: checksum = first four bytes of SHA-256(SHA-256(hash)) Adding checksum at then end of hash and encoding it into Base58: Code: final serialization = 052d7193893e4143fc11bb69c7f004452198bdf6cddcd3b30c Hence, 35qJPbZX23wt3uuB9nz4pxhoouUfG28zxB is our first Bitcoin Address in the hierarchy. Title: Re: [Full Guide+Code]Seed Phrase & The Process of Deriving Bitcoin Addresses from It Post by: webtricks on February 09, 2021, 08:58:01 PM NOTE: I have not included the guide on Extended Keys in this topic. Extended Keys are integral part of HD wallets and help in importing addresses hierarchically without the need of mnemonic code. But the topic is already lengthy enough so will do separate thread on Extended Keys in future.
9. JAVASCRIPT CODE Code in action: https://webtricks.website/seed (https://webtricks.website/seed) GitHub Link: https://github.com/web-tricks/seed-guide (https://github.com/web-tricks/seed-guide) Notes:
Code Files: File 1: mnemonic.js Code: //Generating random 128 bits. 128 - 256 bits can be used but for this tutorial we are strictly generating 128 bits entropy Link: https://github.com/web-tricks/seed-guide/blob/main/mnemonic.js File 2: p2pkh.js Code: //This function will generate Legacy bitcoin address (public key hash) using public key Link: https://github.com/web-tricks/seed-guide/blob/main/p2pkh.js File 3: p2sh.js Code: //This function will generate P2SH bitcoin address (P2WPKH-in-P2SH) using public key Link: https://github.com/web-tricks/seed-guide/blob/main/p2sh.js File 4: ecc.js Code: //This file contains code for generating public key from private key using Elliptic Curve Cryptography Link: https://github.com/web-tricks/seed-guide/blob/main/ecc.js File 5: bs58.js Code: //This javascript code for base58 encoding is taken from https://gist.github.com/diafygi/90a3e80ca1c2793220e5/ Link: https://github.com/web-tricks/seed-guide/blob/main/bs58.js File 6: address.js Code: //This function will take mnemonic code as the input and produce addresses Link: https://github.com/web-tricks/seed-guide/blob/main/address.js File 7: words.js Download this file directly from: https://github.com/web-tricks/seed-guide/blob/main/words.js File 8: index.html Code: <!DOCTYPE html> Link: https://github.com/web-tricks/seed-guide/blob/main/index.html File 9: bech32.js Code: //This function will generate P2SH bitcoin address (P2WPKH-in-P2SH) using public key Link: https://github.com/web-tricks/seed-guide/blob/main/bech32.js Save all files in one folder and then open index.js file in your browser to run the code. Title: Re: [Full Guide+Code]Seed Phrase & The Process of Deriving Bitcoin Addresses from It Post by: bitmover on February 09, 2021, 09:04:11 PM wow, That's a lot of coding!
Good job! I just bookmarked this page so I can drop some merits later, I am out of smerits now. I have just one question/suggestion: You added the first 10 P2SH and P2PKH address formats. Why didn't you add the first 10 Bech32 (bc1) as well? I would also suggest that you add change addresses, at least the first 5 ones as well. If someone uses your code to recover lost coins, change addresses are very important as well. Title: Re: [Full Guide+Code]Seed Phrase & The Process of Deriving Bitcoin Addresses from It Post by: webtricks on February 09, 2021, 09:14:30 PM I have just one question/suggestion: You added the first 10 P2SH and P2PKH address formats. Why didn't you add the first 10 Bech32 (bc1) as well? I would also suggest that you add change addresses, at least the first 5 ones as well. If someone uses your code to recover lost coins, change addresses are very important as well. Well, I initially thought of adding all possible P2SH, P2PKH and Bech32 addresses, both for main network and test network along with the change addresses. Even, wrote code accordingly. But when I was preparing the final version of code and thread, it was becoming extensively lengthy. Restricting it to 10 addresses for 2 formats have reduced the code lines in 'address.js' file by 70%. But like you said, it would be great addition so I will add 10 Bech32 addresses and 5-5 change addresses for all three formats tomorrow. We can leave the explanation part and test network part for now. Title: Re: [Full Guide+Code]Seed Phrase & The Process of Deriving Bitcoin Addresses from It Post by: pooya87 on February 10, 2021, 07:52:51 AM Quote Password-based Key Derivation Function 2 (or PBKDF2) is used as a security measure in the process. This function makes the computation of seed creation slow hence reducing the vulnerability of brute-force. It really doesn't do that.PBKDF2 is already a very weak key derivation function by design and using a very low iteration count (2048 instead of 10 million) isn't going to slow anything down either. In fact under the hood you are just computing about 4k HMACSHA512, suffice it to say that your CPU can compute millions of SHA512 in a second. What people refer to as "increases security" is the passphrase that is used in BIP39 which I always argue that it cannot be considered a true security measure again due to weakness of the used KDF and the fact that there is no minimum size set for the passphrase and users aren't known for using strong passwords. Title: Re: [Full Guide+Code]Seed Phrase & The Process of Deriving Bitcoin Addresses from It Post by: webtricks on February 10, 2021, 12:07:32 PM ~snip~ It really doesn't do that. PBKDF2 is already a very weak key derivation function by design and using a very low iteration count (2048 instead of 10 million) isn't going to slow anything down either. In fact under the hood you are just computing about 4k HMACSHA512, suffice it to say that your CPU can compute millions of SHA512 in a second. What people refer to as "increases security" is the passphrase that is used in BIP39 which I always argue that it cannot be considered a true security measure again due to weakness of the used KDF and the fact that there is no minimum size set for the passphrase and users aren't known for using strong passwords. You are right. I may have over-glorified the use of PBKDF2 in the process. But the standard was proposed by the people behind Trezor wallet and they wanted to use this as the mechanism against brute-force. But due to the limitation of memory and computation constraint in Trezor device, they restricted to using 2048 rounds of PBKDF2 instead of using more iteration or using stronger KDF like Scrypt. However, like you said, it doesn't add anything on regular computer which is capable of computing 2048 rounds in a fraction of millisecond. Passphrase on the contrary is a powerful security measure. But like you pointed out, due to no defined standard for picking the passphrase, users are tend to pick weaker and predictable passphrase. No wonder why most of the wallets don't force users to pick passphrase by default, some even don't have the option of adding passphrase. In my opinion, it's a smart move because:
So, securely creating backup of seed is sufficient enough imo, no need to use passphrase at all. PS: Changes have been made in the OP in Step 4. Thank you. Title: Re: [Full Guide+Code]Seed Phrase & The Process of Deriving Bitcoin Addresses from It Post by: pooya87 on February 11, 2021, 05:41:49 AM But the standard was proposed by the people behind Trezor wallet and they wanted to use this as the mechanism against brute-force. I believe the main purpose of this "extra word/phrase" is to be able to create more than one wallet from a single mnemonic and add "plausible deniability" (not for security). For example in case the user was forced to reveal their mnemonic or hand over their hardware wallet the device could produce a default wallet (without the extra word) that is either empty or has a small amount to fool the thieves while the same wallet with the extra word has the actual (bigger) balance. This is also pointed out in BIP39 Quote The described method also provides plausible deniability, because every passphrase generates a valid seed (and thus a deterministic wallet) but only the correct one will make the desired wallet available. Title: Re: [Full Guide+Code]Seed Phrase & The Process of Deriving Bitcoin Addresses from It Post by: webtricks on February 13, 2021, 07:03:11 PM UPDATE: I have added the code for Bech32 addresses as well. The code for deriving Bech32 Address (using P2WPKH serialization format as defined in BIP-173) from public key has been added in bech32.js file which has been added in the #1 reply of the thread.
GitHub Link: https://github.com/web-tricks/seed-guide/blob/main/bech32.js The code now supports the derivation of first 10 Bech32 Addresses which can be tested here: https://webtricks.website/seed/ You added the first 10 P2SH and P2PKH address formats. Why didn't you add the first 10 Bech32 (bc1) as well? I will add the code to generate first 5 change addresses for all three formats in next update. :) Title: Re: [Full Guide+Code]Seed Phrase & The Process of Deriving Bitcoin Addresses from It Post by: pooya87 on February 17, 2021, 06:20:48 AM UPDATE: I have added the code for Bech32 addresses as well. The code for deriving Bech32 Address (P2WPKH serialization format as defined in BIP-84) from public key has been added in bech32.js file which has been added in the #1 reply of the thread. BIP-84 is just defining a BIP-32 specific derivation path for P2WPKH addresses, similar to BIP-44 and BIP-49. The part you've implemented in that link is mainly the Bech32 encoding itself which is defined by BIP-173 (https://github.com/bitcoin/bips/blob/master/bip-0173.mediawiki).GitHub Link: https://github.com/web-tricks/seed-guide/blob/main/bech32.js Title: Re: [Full Guide+Code]Seed Phrase & The Process of Deriving Bitcoin Addresses from It Post by: pawanjain on February 17, 2021, 03:54:38 PM First of all, this is a very informative thread and definitely worth bookmarking for future reference. Although it's a little lengthy it's worth reading every sentence.
You have explained everything very nicely. I haven't finished reading the whole thread yet but I have crossed half the way and feel overwhelmed with the amount of knowledge in this post. While reading the thread I observed that there are a few mistakes which might just be a copy-paste mistake but it disrupts the flow of understanding when a beginner like me reads it. LEVEL 1: Deriving 45th hardened child of the Master Key (Since it's hardened, Master Private Key will be used) ~snip Code: Left 256 bits = 7fc9ce32a6aeffbeaf5057f266f0d6ed6383ed84f21c96d53c0c1e3838a87e24 In the above step the value for Last 256 bits is different from the HMAC hash generated in the previous step. Your HMAC output in Level 1 is HMAC(message, key) = e9356507b5d275f724123f4053c602fee00c99c4874b63d1714c04ecc196b86cd895767e700af9e 8a8dab225a785d3299431b85298ca94a2628c542b26d96231 but the value for Left 256 bits = 7fc9ce32a6aeffbeaf5057f266f0d6ed6383ed84f21c96d53c0c1e3838a87e24 So either of the one output is incorrect here. And there's one more thing that I observed Quote LEVEL 5: Deriving first 3 normal children of the Level 4 Child (Since it's normal, Public Key will be used) Code: Private Key = e519213b4099dc0a4f26d22ca0a09add7ebc7c6e3964d57f46617f8db522a97a In this step the private key in the first line of code is Private Key = e519213b4099dc0a4f26d22ca0a09add7ebc7c6e3964d57f46617f8db522a97a but the parent private key is Parent Private Key = 27b52d3d12ea694ced4d4ee5261d69fa06cfba73d318e734b586ef8d7738b9ee According to me the parent private key should be the same as the first line i.e. 'e519213b4099dc0a4f26d22ca0a09add7ebc7c6e3964d57f46617f8db522a97a' Title: Re: [Full Guide+Code]Seed Phrase & The Process of Deriving Bitcoin Addresses from It Post by: webtricks on February 18, 2021, 04:03:25 PM ~~ Not quite correct. Entropy is not "the sequence of randomness" but the measure of randomness of discussed sequence which is defined as a number (in log scale) of "guesses" needed to obtain relevant sequence of "0" and "1". ~~ Right! Using the phrase 'measure of randomness' or simply 'randomness' would have been much better and accurate than 'sequence of randomness'. Corrected! ~~ BIP-84 is just defining a BIP-32 specific derivation path for P2WPKH addresses, similar to BIP-44 and BIP-49. The part you've implemented in that link is mainly the Bech32 encoding itself which is defined by BIP-173 (https://github.com/bitcoin/bips/blob/master/bip-0173.mediawiki). Indeed! Wrote 'bip-84' by mistake. Corrected! In the above step the value for Last 256 bits is different from the HMAC hash generated in the previous step. Your HMAC output in Level 1 is HMAC(message, key) = e9356507b5d275f724123f4053c602fee00c99c4874b63d1714c04ecc196b86cd895767e700af9e 8a8dab225a785d3299431b85298ca94a2628c542b26d96231 but the value for Left 256 bits = 7fc9ce32a6aeffbeaf5057f266f0d6ed6383ed84f21c96d53c0c1e3838a87e24 So either of the one output is incorrect here. Good catch! I mistakenly pasted wrong hash in Level 1. The correct hash is: Code: 7fc9ce32a6aeffbeaf5057f266f0d6ed6383ed84f21c96d53c0c1e3838a87e2481d4b120fcd3a11837e5d035fc508bb8b31c47285fdd7506d8d264144b4d8df7 However, it's just a copy/paste error. The rest of the derivation is correct. It seems you made the small typo. Should be "Process is same for the Master Public Key as well" instead of "Process is same for the Master Private Key as well." Sure this a small misspell but it can mislead non-experienced user. Corrected! Thanks for the corrections guys and making the thread more accurate! :) Title: Re: [Full Guide+Code]Seed Phrase & The Process of Deriving Bitcoin Addresses from It Post by: webtricks on April 13, 2021, 02:12:25 PM bump
Title: Re: [Full Guide+Code]Seed Phrase & The Process of Deriving Bitcoin Addresses from It Post by: BlackHatCoiner on November 14, 2021, 09:59:51 PM Excellent thread and I may translate it in Greek whenever I find some time!
I just want to add this: In normal children, you have to be aware that if you give me one of your private keys and your master public key, I can work out every private key. And that's because I can calculate the master private key. Explanation: Since the private key derived in index 0 is the first half of HMAC-512(master_public_key + 0, chain_code) added with the master private key (mod n), then you can do the opposite procedure to reach the master private key if you know both. Even if you don't know the index of the private key you've somehow found, you can just brute force until you make it. It must be possible within seconds with any of the todays' CPUs. The range is [0, 2147483647]. |