Bitcoin puzzle transaction ~32 BTC prize to who solves it

[Denis_Hitov]

Some elliptic curve magic ahead!

Public key for 2^256 in secp256k1 :

Code:

03dd3625faef5ba06074669716bbd3788d89bdde815959968092f76cc4eb9a9787

Private key :

Code:

000000000000000000000000000000014551231950b75fc4402da1732fc9bebf

Public key divided by 2 :

Code:

02b23790a42be63e1b251ad6c94fdef07271ec0aada31db6c3e8bd32043f8be384

Private key : 2^255

Code:

8000000000000000000000000000000000000000000000000000000000000000

Now we add an even key to our 2^256 :
Target  Pub

Code:

034a4a6dc97ac7c8b8ad795dbebcb9dcff7290b68a5ef74e56ab5edde01bced775

Target  Prv

Code:

0000000000000000000000000000000000000000000000000000000000008000

Result : pub

Code:

02c028224b2c45bd797143e8f32f025e24601ed85f27ef310d7d55020a192ddba5

Prv

Code:

000000000000000000000000000000014551231950b75fc4402da1732fca3ebf

Divide by 2 , result :

Code:

0216ca7e1edb137684b4aa8a41fd0f8a89dcb773b9db807a9f3f864de2161735ff

Now subtract pub 2^255 from above, result :

Code:

03111d6a45ac1fb90508907a7abcd6877649df662f3b3e2741302df6f78416824a

Prv, also real half of our original target :

Code:

03111d6a45ac1fb90508907a7abcd6877649df662f3b3e2741302df6f78416824a ,  0000000000000000000000000000000000000000000000000000000000004000

I just enjoy making a simple division difficult and twisted! 🤣, now chop chop start your brain's engine and do some calculation, large fractions could be solved by accounting for the above results, not telling you how.

Dive deep and let your brain solve it.😉

It is a pity that such an operation will not work with an odd key))

[digaran]

It is a pity that such an operation will not work with an odd key))

Sure it will, if you add an odd key to another odd key ( our 2^256 key is odd ) you'll get an even key and all you have to do is to subtract the following key from the result :

Code:

a2a8918ca85bafe22016d0b997e4df5f

But why bother if you could add or subtract 1G from your odd key and divide it without having to do what I said.

You can always divide an odd key, if by 2, you'd have to add n/2 to the result, if by 3, adding n/3 etc to get your actual and correct result.

[lordfrs]

It is a pity that such an operation will not work with an odd key))

Sure it will, if you add an odd key to another odd key ( our 2^256 key is odd ) you'll get an even key and all you have to do is to subtract the following key from the result :

Code:

a2a8918ca85bafe22016d0b997e4df5f

But why bother if you could add or subtract 1G from your odd key and divide it without having to do what I said.

You can always divide an odd key, if by 2, you'd have to add n/2 to the result, if by 3, adding n/3 etc to get your actual and correct result.

sorry my english is not good, i'm trying to understand by translating with translate, this gives me different sentences, so can you write the python code for the division you said.

[digaran]

It is a pity that such an operation will not work with an odd key))

Sure it will, if you add an odd key to another odd key ( our 2^256 key is odd ) you'll get an even key and all you have to do is to subtract the following key from the result :

Code:

a2a8918ca85bafe22016d0b997e4df5f

But why bother if you could add or subtract 1G from your odd key and divide it without having to do what I said.

You can always divide an odd key, if by 2, you'd have to add n/2 to the result, if by 3, adding n/3 etc to get your actual and correct result.

sorry my english is not good, i'm trying to understand by translating with translate, this gives me different sentences, so can you write the python code for the division you said.

I'm not a coder but here is the idea. Translate the following.

11/3 =

Code:

3.6666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666667

Secp256k1 representation of the fraction above :

Code:

55555555555555555555555555555554e8e4f44ce51835693ff0ca2ef01215c0

11 decimal 0xb/3 =

Code:

55555555555555555555555555555554e8e4f44ce51835693ff0ca2ef01215c4

Subtract both above, result is 0x4.

Now the twisted division I talked about, simple :

Target 7, is odd, we add 3 to get 10, divide 10 by 2 = 5, and if we subtract half of 3 = 1.5 from half of 7 = 3.5 we get 2, now we subtract 2 from 5 to get the real half of 7 in secp256k1.

[artistk]

is there any C++ open source script ( CPU or GPU ) to join you in this journey ? Thank you in advance

[albert0bsd]

is there any C++ open source script ( CPU or GPU ) to join you in this journey ? Thank you in advance

for CPU you can try my keyhunt program available on github of course it is open source.

https://github.com/albertobsd/keyhunt

If you have any questions or feedback, don't hesitate to reach out.

Regards

[mcdouglasx]

So basically, you talk about stride option in already existing tools.

Skipping the keys or searching n times is not the same as changing the curve.

Then explain the difference please.

I looked at the piece of code you wrote above, looks like it works like BSGS algorithm, with a very naive implementation.
The first thing that you should do, it is remove curve multiplication at all and replace it with subtraction.
I'm talking about this part: PublicKey = getPublicKey(Seq_Bytes)
Every call of "getPublicKey" is very expensive, no matter which point you're uses as "G".
Just take another point (G*100) as a stride and subtract it from current point on each step. Than you will get 6000, 5900, 5800, 5700 and so on with a great speed improvement. Trying to do the same by replacing the generator point is pretty bad practice, despite the fact that from some side it will certainly work.

I made the code basic to express the idea of why changing G+ database is a fast way to scan (it wasn't intended to be fast just forget about it and focus on G, the database, and the range division), if you jump keys you miss the speed of scalar multiplication.
for that reason the random in the current tools is R+incremental (to take advantage of scalar multiplication).

example :
pk=148557384957383058
and your database capacity is 1000000.
changing G to 1000000
you would only have to search
148557384957
while the common is
148557384957383058.
and as I said when posting the script, everything is in the fluidity with which we can scan the database quickly.

[DegenHero]

is there any C++ open source script ( CPU or GPU ) to join you in this journey ? Thank you in advance

for CPU you can try my keyhunt program available on github of course it is open source.

https://github.com/albertobsd/keyhunt

If you have any questions or feedback, don't hesitate to reach out.

Regards

I am not coder, so don't know how to build.
Could you please build this for non-coders?
Also how fast is this using CPU?

Thanks

[albert0bsd]

I am not coder, so don't know how to build.
Could you please build this for non-coders?
Also how fast is this using CPU?

Thanks

Hi you don't need to be a coder to use the program just follow the instrucctios to compile it under any WSL enviroment.

For CPU my program is one of the fastest available today, Address/rmd160 mode can reach some Millions keys per second on a laptop, up to 100 Millions keys per second on a High end CPU.

For Mode BSGS that use RAM to store precalcualted data you can reach some Petakeys/s scanning for a single publickey.

Regards!

[citb0in]

For Mode BSGS that use RAM to store precalcualted data you can reach some Petakeys/s scanning for a single publickey.

... though BSGS speed is not comparable to the standard scanning technique. Just for the sake of correctness, you cannot compare apple speed with pie speed displayed by those tools. I only want to mention this so that no false illusion is created in the reader and he might think that BSGS is the means of choice and thus the holy grail.

[Denis_Hitov]

Code:

import secp256k1 as ice


target_public_key = "023d62d9d64a7164a2ae6f0561f7e8317e69b4a1ee61048fe768a1316b39b1d3a7"
target = ice.pub2upub(target_public_key)
num = 100 # number of times.
sustract= 1 #amount to subtract each time.
sustract_pub= ice.scalar_multiplication(sustract)
res= ice.point_loop_subtraction(num, target, sustract_pub)
for t in range (num+1):
    h= res[t*65:t*65+65]
    data = open("data-base.txt","a")
    data.write(str(h.hex())+"\n")
    data.close()

Is it possible to make it possible to specify an unlimited number in num?

If set num = 1000000000
That throws an error:

Traceback (most recent call last):
   File "D :\PubSub\PubSub.py", line 8, in <module>
     res= ice.point_loop_subtraction(num, target, sustract_pub).hex()
   File "D :\PubSub\secp256k1.py", line 504, in point_loop_subtraction
     res = _point_loop_subtraction(num, pubkey1_bytes, pubkey2_bytes)
   File "D :\PubSub\secp256k1.py", line 497, in _point_loop_subtraction
     res = (b'\x00') * (65 * num)
MemoryError

[digaran]

Code:

import secp256k1 as ice


target_public_key = "023d62d9d64a7164a2ae6f0561f7e8317e69b4a1ee61048fe768a1316b39b1d3a7"
target = ice.pub2upub(target_public_key)
num = 100 # number of times.
sustract= 1 #amount to subtract each time.
sustract_pub= ice.scalar_multiplication(sustract)
res= ice.point_loop_subtraction(num, target, sustract_pub)
for t in range (num+1):
    h= res[t*65:t*65+65]
    data = open("data-base.txt","a")
    data.write(str(h.hex())+"\n")
    data.close()

Is it possible to make it possible to specify an unlimited number in num?

If set num = 1000000000
That throws an error:

Traceback (most recent call last):
   File "D :\PubSub\PubSub.py", line 8, in <module>
     res= ice.point_loop_subtraction(num, target, sustract_pub).hex()
   File "D :\PubSub\secp256k1.py", line 504, in point_loop_subtraction
     res = _point_loop_subtraction(num, pubkey1_bytes, pubkey2_bytes)
   File "D :\PubSub\secp256k1.py", line 497, in _point_loop_subtraction
     res = (b'\x00') * (65 * num)
MemoryError

More importantly, how to get compressed public keys as result? Lol I changed *65:*65+65 to *32:*32+33 but it messed up everything.

[mcdouglasx]

Code:

import secp256k1 as ice


target_public_key = "023d62d9d64a7164a2ae6f0561f7e8317e69b4a1ee61048fe768a1316b39b1d3a7"
target = ice.pub2upub(target_public_key)
num = 100 # number of times.
sustract= 1 #amount to subtract each time.
sustract_pub= ice.scalar_multiplication(sustract)
res= ice.point_loop_subtraction(num, target, sustract_pub)
for t in range (num+1):
    h= res[t*65:t*65+65]
    data = open("data-base.txt","a")
    data.write(str(h.hex())+"\n")
    data.close()

Is it possible to make it possible to specify an unlimited number in num?

If set num = 1000000000
That throws an error:

Traceback (most recent call last):
   File "D :\PubSub\PubSub.py", line 8, in <module>
     res= ice.point_loop_subtraction(num, target, sustract_pub).hex()
   File "D :\PubSub\secp256k1.py", line 504, in point_loop_subtraction
     res = _point_loop_subtraction(num, pubkey1_bytes, pubkey2_bytes)
   File "D :\PubSub\secp256k1.py", line 497, in _point_loop_subtraction
     res = (b'\x00') * (65 * num)
MemoryError

this may be because secp256k1 loop stores the result in memory first, and exceeds the capacity of your ram.
choose a smaller amount and then change the target with the last pubkey in the database list (to continue from there).

Code:

import secp256k1 as ice


target_public_key = "023d62d9d64a7164a2ae6f0561f7e8317e69b4a1ee61048fe768a1316b39b1d3a7"
target = ice.pub2upub(target_public_key)
num = 100 # number of times.
sustract= 1 #amount to subtract each time.
sustract_pub= ice.scalar_multiplication(sustract)
res= ice.point_loop_subtraction(num, target, sustract_pub)
for t in range (num+1):
    h= res[t*65:t*65+65]
    data = open("data-base.txt","a")
    data.write(str(h.hex())+"\n")
    data.close()

Is it possible to make it possible to specify an unlimited number in num?

If set num = 1000000000
That throws an error:

Traceback (most recent call last):
   File "D :\PubSub\PubSub.py", line 8, in <module>
     res= ice.point_loop_subtraction(num, target, sustract_pub).hex()
   File "D :\PubSub\secp256k1.py", line 504, in point_loop_subtraction
     res = _point_loop_subtraction(num, pubkey1_bytes, pubkey2_bytes)
   File "D :\PubSub\secp256k1.py", line 497, in _point_loop_subtraction
     res = (b'\x00') * (65 * num)
MemoryError

More importantly, how to get compressed public keys as result? Lol I changed *65:*65+65 to *32:*32+33 but it messed up everything.

The 65 refers to bytes, it is to put each 65 bytes of the result on a different line.

for compressed public keys

Code:

import secp256k1 as ice


target_public_key = "032f3342152eff6aca5e7314db6d3301a28d6a90ddcfd189f96babadc2a053d392"
target = ice.pub2upub(target_public_key)
num = 100 # number of times.
sustract= 1 #amount to subtract each time.
sustract_pub= ice.scalar_multiplication(sustract)
res= ice.point_loop_subtraction(num, target, sustract_pub)
for t in range (num+1):
    h= (res[t*65:t*65+65]).hex()
    hc= ice.to_cpub(h)
    data = open("data-base.txt","a")
    data.write(str(hc)+"\n")
    data.close()

[artistk]

Thanks, I'll give it a try now!
Two noob   questions please!:

1) How do I know if I got a Hit? And does it save it in a txt file?

2) Has anyone won an address from the puzzles using this? ( excluding the author )

Besides keyhunt and bitcrack.

What are you guys using here, I see a lot of different script some Python some C++ got confused!

are you guys collecting private keys with one script and checking them on another script?

Also there's no puzzle to think about! just a random guess in a range of private keys? right?

[digaran]

for compressed public keys

Code:

import secp256k1 as ice


target_public_key = "032f3342152eff6aca5e7314db6d3301a28d6a90ddcfd189f96babadc2a053d392"
target = ice.pub2upub(target_public_key)
num = 100 # number of times.
sustract= 1 #amount to subtract each time.
sustract_pub= ice.scalar_multiplication(sustract)
res= ice.point_loop_subtraction(num, target, sustract_pub)
for t in range (num+1):
    h= (res[t*65:t*65+65]).hex()
    hc= ice.to_cpub(h)
    data = open("data-base.txt","a")
    data.write(str(hc)+"\n")
    data.close()

One last thing, how do I change the generator point in the script above? I even went to ice.secp256k1.py but didn't see x and y for G to change it, is there a way to include a new G in your script?
Thank you so much for teaching us new things.👍

Ps, I have learned that we could use inverse keys to do multiplication on a script which only divides, lol.

Besides keyhunt and bitcrack.

What are you guys using here, I see a lot of different script some Python some C++ got confused!

are you guys collecting private keys with one script and checking them on another script?

Also there's no puzzle to think about! just a random guess in a range of private keys? right?

What do you know about elliptic curve math? If you are new, I suggest learning everything you can about *, +, -, / of public keys, without knowing that you'd be searching blindly using BSGS and kangaroo etc, and don't bother searching for #66, #67 etc, unless you know programming and can develop a new and faster brute force tool.

[_Counselor]

I made the code basic to express the idea of why changing G+ database is a fast way to scan (it wasn't intended to be fast just forget about it and focus on G, the database, and the range division), if you jump keys you miss the speed of scalar multiplication.
for that reason the random in the current tools is R+incremental (to take advantage of scalar multiplication).

example :
pk=148557384957383058
and your database capacity is 1000000.
changing G to 1000000
you would only have to search
148557384957
while the common is
148557384957383058.
and as I said when posting the script, everything is in the fluidity with which we can scan the database quickly.

This is what is called a Baby-step-Giant-step (BSGS) algorithm. There is many good and optimized implementations of this algorithm, including GPU implementations.
If you generate sequence of 10 successive keys, you can check every 10th key in range to hit some key in sequence, 100 keys - every 100th and so on.
But to achieve this you don't need to change G at all.

[Ovixx]

Thanks, I'll give it a try now!
Two noob   questions please!:

1) How do I know if I got a Hit? And does it save it in a txt file?

2) Has anyone won an address from the puzzles using this? ( excluding the author )

1.a file named KEYFOUNDKEYFOUND.txt will be generated in the root of the keyhunt folder
2.in BSGS mode (after it was discovered by others) I found the private key for #64 in 14 minutes, but you can try in rmd160 mode and see what keyfound knows, using the command "./keyhunt -m rmd160 -f tests/1to32.rmd -r 1:FFFFFFFF -l compress -s 5", to convince yourself.
After testing, you choose your own method of use. If you have a PC with at least 64 GB RAM, you can choose the factor -K 4096 and reach 10 Petakeys/second or more in BSGS mode.

[lordfrs]

1.a file named KEYFOUNDKEYFOUND.txt will be generated in the root of the keyhunt folder
2.in BSGS mode (after it was discovered by others) I found the private key for #64 in 14 minutes, but you can try in rmd160 mode and see what keyfound knows, using the command "./keyhunt -m rmd160 -f tests/1to32.rmd -r 1:FFFFFFFF -l compress -s 5", to convince yourself.
After testing, you choose your own method of use. If you have a PC with at least 64 GB RAM, you can choose the factor -K 4096 and reach 10 Petakeys/second or more in BSGS mode.

bsgs is a bit slow collider finds it in 17 seconds

[mcdouglasx]

I made the code basic to express the idea of why changing G+ database is a fast way to scan (it wasn't intended to be fast just forget about it and focus on G, the database, and the range division), if you jump keys you miss the speed of scalar multiplication.
for that reason the random in the current tools is R+incremental (to take advantage of scalar multiplication).

example :
pk=148557384957383058
and your database capacity is 1000000.
changing G to 1000000
you would only have to search
148557384957
while the common is
148557384957383058.
and as I said when posting the script, everything is in the fluidity with which we can scan the database quickly.

This is what is called a Baby-step-Giant-step (BSGS) algorithm. There is many good and optimized implementations of this algorithm, including GPU implementations.
If you generate sequence of 10 successive keys, you can check every 10th key in range to hit some key in sequence, 100 keys - every 100th and so on.
But to achieve this you don't need to change G at all.

Are you sure you know what bsgs is? because I see you confused

https://github.com/albertobsd/keyhunt/issues/132

[digaran]

Are you sure you know what bsgs is? because I see you confused

You mean Satoshi doesn't know what he is talking about?
I'm 85% certain he is the man himself, very interested in brute force tools and very knowledgeable about math and cryptography.😉