Bitcoin puzzle transaction ~32 BTC prize to who solves it

[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

[1714636909]

1714636909

[1714636909]

1714636909

[1714636909]

1714636909

[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.😉

[mcdouglasx]

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.😉

I don't understand friend, I only reply to the user _counselor who says that my idea is the same as BSGS and it is not.

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.

secp256k1 iceland2k14 It's not open source so you can't modify it and compile it your way.

[lordfrs]

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.

Code:

import secp256k1 as ice
from sympy import mod_inverse
N= 115792089237316195423570985008687907852837564279074904382605163141518161494337
target_public_key = "032f3342152eff6aca5e7314db6d3301a28d6a90ddcfd189f96babadc2a053d392"
target = ice.pub2upub(target_public_key)
t=mod_inverse(2,N)
print(ice.point_multiplication(t,target).hex()) # target / 2 

https://learnmeabitcoin.com/technical/ecdsa

[artistk]

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've tried your tool on an old laptop, gave me about 1 Mkey  ouch!

Is there any other way to increase my chances? Any other tools? please

[Ovixx]

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've tried your tool on an old laptop, gave me about 1 Mkey  ouch!

Is there any other way to increase my chances? Any other tools? please

...another laptop

[kalos15btc]

i have found same 14 digits of hash160 of substraction puzzle 130


1QKZKb6DjAxKkbRycPgC8n9Fs7pPfCZeTv # + 3............................
Hash160:ffcd5c308ebf83ad7ba414b068c69e6192d5a1ab


address that i found, maybe its in that range:
1QKZKb6DjAxS4kGh9RohKCnJisM9geDp5o
Hash160: ffcd5c308ebf83b910d0cd8b853df079c5b07452

pk: 33faa087a4ea5c40e696be9a1c1e8389

but the range is a little big,,,, but for 100 pourcent sure that 130 puzzle is between 30 and 3F
dont waste your time searching in 2
so we can say 130 puzzle is located in 330000000000000000000000000000000:3ffffffffffffffffffffffffffffffff range you can search from there

 , im working on that if i found smaller range same 14 digits or more, that will be amazing to search there ..

Some elliptic curve magic ahead!
...
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.😉

Anyone here knows how to divide a point by 3, 4, 5, 6, 7, 8, 9 and 10 and get a correct result?

Give me a few minutes, you will be amazed, I need to prepare the sample keys on laptop. Stay tuned.😉
Here you go
...

Ps, I will not study to figure out how to divide by 10m and still have a correct result, if I do, I will not share it, that'd be ECC bent and broken totally.

...
Never mind all the above, I have something to twist your minds, take the following key and double, divide, do many other things with it to get really confused about how EC works. 😂

Introducing to you 2^256 of secp256k1

you constantly act as if you are a genius who broke SECP256K1 but doesn't want to share his genius findings. On the other hand, you struggle in vain and miserably like many others to solve a puzzle. Find the mistake.

PS: @digaran, dont reply to me i dont need your answer nether your guessing or anything of you, like what @citb0in tell, you are acting like you are awesome and know everything, 3 months ago im teaching you how to substract from public keys now you say to me old school and bla bla, please bro dont waste my time replying something have nothing to do with puzzle to just say im old school and you do new things, i dont need your answer really bro,,, @citb0in i totally aggree with you

[digaran]

PS: @digaran, you are awesome  , 3 months ago im teaching you how to substract from public keys

Modified the quote.
WP taught me subtraction/addition, I learned division from garlonicon's posts.
Please don't take credit for things you haven't done. Thanks for kind words.!

[tptkimikaze]

Any C++ pro here? I have some dummy question. Is that difficult to convert Python into C++ and integrate it to Keyhunt? Or maybe I should say are we able to do some minor modification on Keyhunt by using my Python code logic because I did saw some similarity. I am currently using Python code to search and estimate can only get about 400k key per sec, if Keyhunt without GPU I can get roughly about 12 M/Keys per second. It is not compulsory to use GPU and I believe I have found some obvious pattern on 66, 67, 68. I just hope if able to integrate into Keyhunt, possibly I can increase the keys per sec instead of only around 400k per sec on Python. We can work together, find the 66,67,68 keys and share what we get.

We maybe also can work together after I find #66 keys if nobody able to find it in possibly a month time. Although much slower to find it on my current speed, but still able to find it. It might cost me like another 10-20 times difficulty to find with current speeds.

[kalos15btc]

PS: @digaran, you are awesome  , 3 months ago im teaching you how to substract from public keys

Modified the quote.
WP taught me subtraction/addition, I learned division from garlonicon's posts.
Please don't take credit for things you haven't done. Thanks for kind words.!

@Op, in the output file I have several #targets, is that what we are looking for? How do I derive the private key now?

@Op, in the output file I have several #targets, is that what we are looking for? How do I derive the private key now?

You should only have 1 target in output file unless you ran the program more than once with same output file.
The target key is the original public key you used in the settings.
To derive the private key you need to search whatever range/bits of your original public key used to generate all of the offset keys in your output file.

What now? I just double clicked on the bat file a few times, each time it finished in less than a second so I changed things and ran it again until I saw the output file is full.

Now you say #target is my input, but why is it in my output file and why did the tool add + to them instead of subtracting? Because I selected -s only.

I have 3 #targets, one of them is derived from 64 hex string and 2 of them are from 31 char hex string, should I search the one leading to the target?

And why does it select the additions like this : eeeeeeeeeeeeee434343434343, did you just hit the keyboard for add/sub selection or is it doing it by itself?

I got what you said about how it works, I have a problem with the results I have got, for example:
dc629ccec8a0c3c53e5a0707021a0053a325720e3321f5fb6db3f9339eac23f7 #+ 184ffe30916bcf90fdba43677100000  and I used -s, which means I have to actually add, but add what to what and how?
Edit, one other thing, how does this adding and subtracting exactly work? Is it done using integers or hex and why do I get different results when I use decimal values to add and subtract? Could you explain this please?

./keysubtracter -p 02ceb6cbbcdbdf5ef7150682150f4ce2c6f4807b349827dcdbdd1f2efa885a2630-n 100 -b 120

Note the bolded part above, no space therefore it starts to produce invalid keys.

Code:

03f1d41da8acf0506f3bf7140b5629dd33a5cf546133479530cd8065e335a97666 # - 13292279957849158729038070602803446
02000000000000000000000000000000000000000000000000000000000000000 # + 13292279957849158729038070602803446
02b70ae2dcb442548570313f652b91ca093a3acac3a2441cb64614e8195505b6b8 # - 26584559915698317458076141205606892
0367dabeef20a6a8b7b5555b162cc8c8489e3134dcec624fe028573c34dbbf20f6 # + 26584559915698317458076141205606892
02a1d21298779f888cd8169f9ed59e4383219cdadbdb342ba886034ef9013b89be # - 39876839873547476187114211808410338
02ae015703cbaee9570dc648d7bce78ac7cb438630e09d69eef4f1208655e1027d # + 39876839873547476187114211808410338

Note one of the public keys above is the 0 public key aka k(0) public key, it shows up if you subtract your k from your p, basically point at infinity.

Now our actual target's k is 13292279957849158729038070602803446 because we subtracted it from our target.

Showing examples for newbies to understand, not that a few posts above I wasn't a total noob, now I act as if I know things, go figure.😅

work on any puzzle public key puzzle 100 or 105, you will understand how it work, and put the range like this Keysubstracter -s -------  0:fffffffffffffffffffffffff -o puzzle100.txt

do only -s dont add -a, you will have all public key from   0 to range 100

put this range always
0 to : end range

and when you create the file.txt, just go and do the maths with https://www.boxentriq.com/code-breaking/big-number-calculator
just do this privatekey of the puzzle 100 - number that you get,, in any line ,exemple af55fc59c335c8ec67ed24826 + .....
you will get the privatekey of the public key that you generate with keysubs,,,, do that with more that 20 lines randomly,,, you wil have smaller and bigger ranges pk,,, you will understand how you will search for puzzle 120 or 125 by this methode,

because your work range with  rangepuzzle120:rangepuzzle120 and -a and -s
you only generate public keys between 800000000000000000000000000000 and ffffffffffffffffffffffffffffff,
but the methode above and i wanna you to try it

you will get all addresses txt file from 0 to puzzle,,, you can find any address in smaller range 10 or in 66 like 13zb1hQ did you get it ? you will now know  how to search and work with this programme. its easy, you can substract 125 puzzle to 80 and 100 but you will have millions in this txt file, you can do bsgs on that file but its slow because it devide your speed to millions that you generated, so you can generate with addresses and search manually, and there is a lot of tricks how can you search , but sir your methode is totally wrong, in one case,, you generate and search with bsgs in that range already, but its the same this if you search for 1 public key 125 puzzle or a file contain 100 million public key substracted from 125 and speed is devided to 100 million, same thing already,, but you must work again on that program to learn how to use it its simple and try my methode you will get it simple, just do an exemple or old puzzle you will find how it works

4 months ago, you didint knew nothing about substraction,,,
when i did reply last week about a range did you saw what you said to me ?

Hi, so  i found 2 address similar 11 digits of hash160 in extraction of bit 130 that means if you scan on this range and have the private key of those one of two addresses we will split the 13 BTC
---SNIP---

what makes you think that a partial string of one hash has a reference to another?

This phase of learning, I call it kindergarten phase, I have also passed this era, I'm in preschool now. Lol.

They need to learn their lessons through experience if verbal education is  not effective.
😉

so please bro let us think about the puzzle and coloborate to crack it, and dont ever reply to me as the other member said that you are really act like you are genious ok?

[ing1996]

PS: @digaran, you are awesome  , 3 months ago im teaching you how to substract from public keys

Modified the quote.
WP taught me subtraction/addition, I learned division from garlonicon's posts.
Please don't take credit for things you haven't done. Thanks for kind words.!

Hello everyone What happens when dividing a scalar from a point (vector/scalar) on the secp256k1 calculator from Mr.maxwell. How can I find out what result it gives when using known points for an example, can you show an example?!.I still don't understand how division works here, I can't find the right result in any way.

[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

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

This is all clear.
But we don't know what range our last key fell into, do we? Accordingly, we cannot know what amount and how many times it can be subtracted from it so as not to go into a minus. That's where the snag is.

P.S.:Your script works great! Thank you very much!

Update:
If, when subtracting, it was immediately checked whether you "flew over" a certain public key (went into minus or not). Back then, all public-key puzzles could be solved within an hour. Can someone write such a script?