From private key to address [Facing problem]

[BlackHatCoiner]

Hello, I'm trying to make an address from my custom private key, but I need some help.

This is my 64 length private key in hex: c89856dd1b8f867fedfbefaa95c340a086aaaf1b086ffa3772b37540b45912f9

What exactly happens next? Cause I think, I'm not doing it correctly. I want to reach that private key to a p2pkh address.

[1715141519]

1715141519

[1715141519]

1715141519

[1715141519]

1715141519

[TheArchaeologist]

Since you didn't describe what steps you took I can't comment on what you did wrong. What I can tell you is the following:

You got your private key:

Code:

c89856dd1b8f867fedfbefaa95c340a086aaaf1b086ffa3772b37540b45912f9

Based on this private key you can generate either a compressed or uncompressed public key:

Code:

Public keys:
compressed: 039E8CFA0C5F56D61AA7ADC9CCE5963E9622C29AF2D61E82A2494B7051107B8720
uncompressed:049E8CFA0C5F56D61AA7ADC9CCE5963E9622C29AF2D61E82A2494B7051107B8720D2A18C74A3968A65860CCCAE2892A6A6B39001104B34D5E8D332598C06625A03

The public keys result in a different address but use the exact same algorithm and end up encoding a hash in base58 format. So both these addresses are "p2pkh", most newer ones are bases on a compressed public key:

Code:

compressed: 1L1Z1V8WCQi5DEuQeF3GLR9LPWEUF2swtU
uncompressed: 15hw8MaTFjJsdkpwGNoBZRjGoCNzUy3D37

[odolvlobo]

Hello, I'm trying to make an address from my custom private key, but I need some help.

This is my 64 length private key in hex: c89856dd1b8f867fedfbefaa95c340a086aaaf1b086ffa3772b37540b45912f9

What exactly happens next? Cause I think, I'm not doing it correctly. I want to reach that private key to a p2pkh address.

This page shows all of the steps. though is a out of date: http://gobittest.appspot.com/Address

[BTCW]

I wrote a new python script for this (for my friends at https://btcleak.com/ - they will hopefully publish the source code soon; it's pretty neat, uses fastecdsa which is like a thousand times faster than the standard library, check back in a bit), the output is:

Code:

==============

Hex: c89856dd1b8f867fedfbefaa95c340a086aaaf1b086ffa3772b37540b45912f9

Uncompressed Private Key WIF:  5KLdWjcaX1983KPCE3diBD7gc11L5KVmEEsy8iEjYb7w6syygUH
Uncompressed Legacy Address:   15hw8MaTFjJsdkpwGNoBZRjGoCNzUy3D37

Compressed Private Key WIF:    L3weAF62wRcr5E8xYad2k4UVoV2TC4dxDSFxm31cnRbbncJiBGue
Compressed Legacy Address:     1L1Z1V8WCQi5DEuQeF3GLR9LPWEUF2swtU
Wrapped P2SH-P2WPKH Address:   3B5R1gaz9eH2Vh9NRUEkwL8fbD6fPXiyeY
Wrapped P2WPKH Bech32 Address: bc1q6zz3hma6gzqk4uf5tfx8r907lsslc7uvepafx0

==============

The link odolvlobo provided explains the steps well too.

[BrewMaster]

Wrapped P2WPKH Bech32 Address: bc1q6zz3hma6gzqk4uf5tfx8r907lsslc7uvepafx0

"wrapped" usually refers to a P2WPKH script that is "wrapped" inside a P2SH script. but the normal P2WPKH script that produces the bech32 address is called the "native" SegWit address.

[BlackHatCoiner]

Hello, I'm trying to make an address from my custom private key, but I need some help.

This is my 64 length private key in hex: c89856dd1b8f867fedfbefaa95c340a086aaaf1b086ffa3772b37540b45912f9

What exactly happens next? Cause I think, I'm not doing it correctly. I want to reach that private key to a p2pkh address.

This page shows all of the steps. though is a out of date: http://gobittest.appspot.com/Address

I wonder if these files are open source on github. I would like to check them. In what lang they are written for example.

[o_e_l_e_o]

though is a out of date: http://gobittest.appspot.com/Address

What do you mean by the page is out of date? The process of generating legacy addresses from private keys hasn't changed. How can it be out of date?

I wonder if these files are open source on github. I would like to check them. In what lang they are written for example.

They are. You can find them here: https://github.com/ThePiachu/GoBitTest/tree/master/app. The code specific to that Addresses page is here: https://github.com/ThePiachu/GoBitTest/blob/master/app/AddressTest.go. They are written in golang.

[BTCW]

Here is a quick and dirty solution in Python3 (command line, not a saved script) I threw together.

I don't have time to comment on each step, it just works. Feel free to ask me about it.

Code:

>>> import hashlib, binascii, base58
>>> from fastecdsa import keys, curve, ecdsa
>>> hexkey='c89856dd1b8f867fedfbefaa95c340a086aaaf1b086ffa3772b37540b45912f9'
>>> base58.b58encode_check(binascii.a2b_hex('80'+hexkey+'01')).decode()
'L3weAF62wRcr5E8xYad2k4UVoV2TC4dxDSFxm31cnRbbncJiBGue'
>>> curve = curve.secp256k1
>>> pub_key = keys.get_public_key(int(hexkey,16), curve)
>>> uncompressed_public_key = '04'+str(hex(pub_key.x)[2:]).zfill(64)+str(hex(pub_key.y)[2:]).zfill(64)
>>> if int(str(pub_key.y)) % 2 == 0:
...   compressed_public_key = '02'
... else:
...   compressed_public_key = '03'
... 
>>> compressed_public_key += str(uncompressed_public_key[2:66])
>>> compressed_hash160 = hashlib.new('ripemd160',hashlib.sha256(binascii.unhexlify(compressed_public_key)).digest()).hexdigest()
>>> base58.b58encode_check(binascii.unhexlify('00'+compressed_hash160)).decode()
'1L1Z1V8WCQi5DEuQeF3GLR9LPWEUF2swtU'

It gives you the same result as my "real" script and the aforementioned link, which is proof it's working as intended.

[TheArchaeologist]

I wonder if these files are open source on github. I would like to check them. In what lang they are written for example.

This function is in python from my own software. It works with compressed/uncompressed keys:

Code:

import binascii, base58, hashlib

def public_key_to_address(public_key):
        bin = binascii.unhexlify(public_key)

        #Step 1: Create hash of public key:
        hash_of_public_key  = hashlib.sha256(bin).digest()

        #Step 2: Calculate RIPEMD-160 of the public key:
        r = hashlib.new('ripemd160')
        r.update(hash_of_public_key)
        r.hexdigest()

        #Step 3: Adding network bytes (00) to RIPEMD-160
        networked =  binascii.unhexlify('00'+r.hexdigest())

        #Step 4: Double hash the networked RIPEMD-160
        sha4a   = hashlib.sha256(networked).digest()
        sha4b  = hashlib.sha256(sha4a).digest()

        #Step 5: Get the first four bytes of sha4b:
        four_bytes = str(binascii.hexlify(sha4b).decode('utf-8'))[:8]

        #Step 6: Adding the four_bytes to the end the RIPEMD-160 from step 3:
        address_hex = str(binascii.hexlify(networked).decode('utf-8')) + four_bytes

        #Step 7: Convert the hex_address using base58 to bitcoin adres
        address_base58 = base58.b58encode(binascii.unhexlify(address_hex))

        return str(address_base58.decode())

[TheArchaeologist]

What do you mean by the page is out of date? The process of generating legacy addresses from private keys hasn't changed. How can it be out of date?

Although the page itself still works it gives a warning the public key is of an invalid length when entered in compressed format. So it is kind of out-of-date for not recognizing compressed public keys as valid.

[BlackHatCoiner]

http://gobittest.appspot.com/Address

I understand everything about this site, but this. How do I get from 0 - Private ECDSA Key to 1 - Public ECDSA Key

Even on wiki, it doesn't say how: https://en.bitcoin.it/wiki/Technical_background_of_version_1_Bitcoin_addresses

[o_e_l_e_o]

You have to use elliptic curve multiplication to multiply the private key by the generator point (G) in the secp256k1 curve to obtain the public key. The compressed generator point for bitcoin is as follows:

Code:

02 79BE667E F9DCBBAC 55A06295 CE870B07 029BFCDB 2DCE28D9 59F2815B 16F81798

Public key = Private key * G

If you want to read more about how this is done, I would suggest starting here: https://github.com/bitcoinbook/bitcoinbook/blob/develop/ch04.asciidoc#public-keys

[BTCW]

You have to use elliptic curve multiplication to multiply the private key by the generator point (G) in the secp256k1 curve to obtain the public key. The compressed generator point for bitcoin is as follows:

Code:

02 79BE667E F9DCBBAC 55A06295 CE870B07 029BFCDB 2DCE28D9 59F2815B 16F81798

Public key = Private key * G

If you want to read more about how this is done, I would suggest starting here: https://github.com/bitcoinbook/bitcoinbook/blob/develop/ch04.asciidoc#public-keys

Elliptic-curve cryptography (ECC) is not trivial. This is one of the great ironies with Bitcoin, in my opinion, that calculating the public key (which is NOT the same thing as the public address) is by far the toughest part of the sequence.

In my code in the previous post, I used this library (my warmest recommendations!)

https://github.com/AntonKueltz/fastecdsa

(I used "sudo python3 -m pip install fastecdsa" to install it, and I'm well aware that this particular method, even though it works like a charm, is often frowned upon.)

And I showed how it can be used to derive what the OP wanted. Exact code (albeit poorly commented); what more do you need?


Edit: The code TheArchaeologist share is pretty neat, but it doesn't include ECC, getting the public key to begin with, also the toughest part.)

[pooya87]

Elliptic-curve cryptography (ECC) is not trivial. This is one of the great ironies with Bitcoin, in my opinion, that calculating the public key (which is NOT the same thing as the public address) is by far the toughest part of the sequence.

it really isn't as tough as you think. it is like saying computing SHA256 is tough. you simply use a library (eg. hashlib) and call its Sha256.Compute function. similarly for computing public key from a private key, you simply use the ECC.GetPublicKey function.
but since this is new and uncommon (unlike computing SHA256) it seems hard at first sight.

[BlackHatCoiner]

Elliptic-curve cryptography (ECC) is not trivial. This is one of the great ironies with Bitcoin, in my opinion, that calculating the public key (which is NOT the same thing as the public address) is by far the toughest part of the sequence.

it really isn't as tough as you think. it is like saying computing SHA256 is tough. you simply use a library (eg. hashlib) and call its Sha256.Compute function. similarly for computing public key from a private key, you simply use the ECC.GetPublicKey function.
but since this is new and uncommon (unlike computing SHA256) it seems hard at first sight.

Yes, the difference is that SHA256 is more widespread. I don't think that you can use ECC(string) in PHP for example.

[BTCW]

it really isn't as tough as you think. it is like saying computing SHA256 is tough. you simply use a library (eg. hashlib) and call its Sha256.Compute function. similarly for computing public key from a private key, you simply use the ECC.GetPublicKey function.
but since this is new and uncommon (unlike computing SHA256) it seems hard at first sight.

Please stop assuming what I think, or what my background in math is.

ECC is not "new"; it was suggested in 1985 by two independent researchers:

https://www.ams.org/journals/mcom/1987-48-177/S0025-5718-1987-0866109-5/home.html
https://link.springer.com/chapter/10.1007%2F3-540-39799-X_31

SHA-2 (of which is SHA-256 is the most used function) was made public in 2001 (i.e. 16 years later than ECC):

https://web.archive.org/web/20160330153520/http://www.staff.science.uu.nl/~werkh108/docs/study/Y5_07_08/infocry/project/Cryp08.pdf

Bitcoin IS a nice mix and implementation of different fields of math, but none of it is novel (or was novel in 2009). Much of it seems to originate from

https://en.wikipedia.org/wiki/Hashcash

from 1997.

Back to the question. Yes, I do use Python libraries. Why re-invent the wheel?

The OP asked for a solution, and I provided one.

[archyone]

http://gobittest.appspot.com/Address

I understand everything about this site, but this. How do I get from 0 - Private ECDSA Key to 1 - Public ECDSA Key

Even on wiki, it doesn't say how: https://en.bitcoin.it/wiki/Technical_background_of_version_1_Bitcoin_addresses

this topic helped me a lot to understand the concept : https://bitcointalk.org/index.php?topic=5245379