Author

Topic: Bitcoin puzzle transaction ~32 BTC prize to who solves it - page 189. (Read 244595 times)

hero member
Activity: 862
Merit: 662
Maybe I know too little information about it. I think I have some idea now, not sure if I am correct about it. By subtracting known 130 public key to lower bits to find the lower bits private key, once gotten that private key you do an inverse of lower bit private key back to 130 bits. Am I right?

Yes that is correct if you have  some case like this:

Code:
P130 - PA = X
P130 - PB = Y
P130 - PC = Z
...
P130 - PM = N

if you found the privatekey of any X, Y, Z or N you only need to apply the inverse process to get the Private key of P130, you only need to be aware of what are the values of PA,PB PC and PM

the same appy for other operations like  addition, multiplication and division

Regards!
newbie
Activity: 25
Merit: 2
I have no idea why so many are so obsessed about this adding and subtracting public key thingy. Maybe I know nothing much about it and makes me think that way. This adding/subtracting method in my opinion are totally different from Pollard Kangaroo idea or BSGS. From my understanding, by adding/subtracting public key, you can generate a bunch of valid public key, nothing wrong about it. But if 1 private key matching only 1 public key(of course it does), then where is the difference between adding/subtracting and private key bruteforcing? IMHO, it doesn't eliminate any possible private key combination at all. Please correct me if I am wrong.

try this
https://github.com/WanderingPhilosopher/Windows-KeySubtractor
and you will understand

with substraction, we can minimise the search range from 130bit to lower range, you could fild a private key of generated substracted public key in lower range exemple 100bit or even lower so that will be easy to crack 130 bit..


Actually I saw your previous post quite some time ago and did try on the python script on that closed thread many months ago. After generating millions of public key, I found out it doesn't help much after trying an hour or so, immediately I gave up.  LoL. Maybe I know too little information about it. I think I have some idea now, not sure if I am correct about it. By subtracting known 130 public key to lower bits to find the lower bits private key, once gotten that private key you do an inverse of lower bit private key back to 130 bits. Am I right?
copper member
Activity: 1330
Merit: 899
🖤😏

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.
If you know the private key of your point, just use scalar/scalar instead, result is the same.
Note the last digit of your private key in decimal, for example if you are dividing a key ending with 8 by 3, you need to separately divide 8 by 3 and subtract the result from your first result which is your key ending with 8 divided by 3, then you will have the correct result.

Also note that when you are subtracting, the greater key must be on the left slot, otherwise you'll get -n result starting with a lot of fs.  When you see that though you could either change the keys slot or just subtract the result from n to have your result.

Here is a trick, if you are dividing a key by 2 digits number, then the previous method won't work, e.g, dividing a key ending with 8 by 25 won't work if you divide "8" by 25 and subtract both results, instead you'd need to know the last 2 digits of your key, example : if your key ends in 58, then you'd need to divide "58" by 25 separately then do the previous steps. ( might not work with all numbers ).


Here is another trick, if you are dividing by 25, try dividing n by 7 and compare both results.

Most of what I said won't make sense now, but in the future you'd come back to check this post again.😉

Ps, if you want advanced tricks, ask the master of cryptography aka kalos. I hear he is about to break rmd160 hash function by finding a collision.
jr. member
Activity: 50
Merit: 1
I have no idea why so many are so obsessed about this adding and subtracting public key thingy. Maybe I know nothing much about it and makes me think that way. This adding/subtracting method in my opinion are totally different from Pollard Kangaroo idea or BSGS. From my understanding, by adding/subtracting public key, you can generate a bunch of valid public key, nothing wrong about it. But if 1 private key matching only 1 public key(of course it does), then where is the difference between adding/subtracting and private key bruteforcing? IMHO, it doesn't eliminate any possible private key combination at all. Please correct me if I am wrong.

try this
https://github.com/WanderingPhilosopher/Windows-KeySubtractor
and you will understand

with substraction, we can minimise the search range from 130bit to lower range, you could fild a private key of generated substracted public key in lower range exemple 100bit or even lower so that will be easy to crack 130 bit..
newbie
Activity: 25
Merit: 2
I have no idea why so many are so obsessed about this adding and subtracting public key thingy. Maybe I know nothing much about it and makes me think that way. This adding/subtracting method in my opinion are totally different from Pollard Kangaroo idea or BSGS. From my understanding, by adding/subtracting public key, you can generate a bunch of valid public key, nothing wrong about it. But if 1 private key matching only 1 public key(of course it does), then where is the difference between adding/subtracting and private key bruteforcing? IMHO, it doesn't eliminate any possible private key combination at all. Please correct me if I am wrong.
newbie
Activity: 49
Merit: 0



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
     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?
newbie
Activity: 8
Merit: 0

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.
jr. member
Activity: 50
Merit: 1

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 Huh?


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 Smiley
---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?
newbie
Activity: 25
Merit: 2
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.
copper member
Activity: 1330
Merit: 899
🖤😏

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.!
jr. member
Activity: 50
Merit: 1
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 Smiley
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
newbie
Activity: 30
Merit: 0
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  Grin ouch!

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

...another laptop
newbie
Activity: 5
Merit: 0
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  Grin ouch!

Is there any other way to increase my chances? Any other tools? please
jr. member
Activity: 57
Merit: 1

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
member
Activity: 239
Merit: 53
New ideas will be criticized and then admired.

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.
copper member
Activity: 1330
Merit: 899
🖤😏

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.😉
member
Activity: 239
Merit: 53
New ideas will be criticized and then admired.
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
jr. member
Activity: 57
Merit: 1
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
newbie
Activity: 30
Merit: 0

Thanks, I'll give it a try now!
Two noob  Huh 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.
member
Activity: 110
Merit: 61
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.
Jump to: