Keyhunt - development requests - bug reports

[nomadsena]

Hello albertobsd i have a Questions outside and inside this awesome program that you have made.
i've been looking for correct answers for weeks, but everyone says differently so your the one who to ask, because you're a bitcoin expert here.
Questions:


So total  possible public keys are 2^256 and are mapped to a set of 2^160 (160 bits) addresses. Since there are more public keys and private keys than addresses, but every public key can be mapped to an 160 bits address, there must be then in average 2^256 / 2^160 = 2^96 keys to each address. so if there are 2^96 addresses for each bitcoin address, so does all that 2^96 addresses that one Address have, share ALL the same public key? because that's what you need  in order to have the same RIPEMD-160 hash. so only private key which changes, not public key with the 2^96 key possible keys per Address right?

==========

Another Question related:

So if all my thoughts are right, then from what i understood, All addresses of bitcoin exists only 1 TIME from the range ( 160 bits ) 0 - ( FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF ), and the rest 2^96 addresses per address start to exists after the range of 2^160, so starting from 2^161. Is that also correct?


==========


Last Question.

Then if bitcoin addresses have 160 bits, can't we just try to Bruteforce that 160 bits from ( 0 - FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF )  Hex-Range with  high number of  Random peta/keys checks - - using BSGS, won't we have a 1 of 2^160 chance of unlocking any addresses that have the public key? can that work using BSGS right, or with BSGS that method doesn't work? (even with low chance, i still believe in luck)

==========

if you could answer all this three Question, then i really appreciate it!
Best regards.

You keep hearing different opinions because people have different understanding of public key. If someone assumes that wallet address itself is public key he will tell you that the key space is 2^160 remaining are just collisions. But if your are talking about actual public key then you have to search in the space of 2^256 to find a private key. If you are randomly using a public key in BSGS mod then the key space is 2^256. Here is the tradeoff if your using BSGS the speeds are in typpical pkeys/sec but the range is too large and a good ram will help you. But if you are hasing the public key to ripemd-160 the typical speed is mkeys/sec a good GPU will help you. But BSGS is best for solving puzzle. And about the luck part no offense but you are not understanding the odds, if you think you are that lucky pick up a rock outside your house and it will turnout to be a meteorite in which case you will earn millions.
-- by the way this is my understanding of bitcoin if i am wrong please correct me i am eager to learn

[1715286730]

1715286730

[1715286730]

1715286730

[1715286730]

1715286730

[1715286730]

1715286730

[PawGo]

Alberto,
Is there any road map for the project? Do you want to focus on new features or do you prefer to focus on improving performance of the existing code?
What about splitting code to avoid unnecessary ifs/switches?
Any plans to introduce stride?

[albert0bsd]

Alberto,
Is there any road map for the project? Do you want to focus on new features or do you prefer to focus on improving performance of the existing code?
What about splitting code to avoid unnecessary ifs/switches?
Any plans to introduce stride?

https://github.com/albertobsd/keyhunt/discussions/142

What about splitting code to avoid unnecessary ifs/switches?

Yes that will be nice, the problem for that is that if I change some behavior in the main cycle of the process i will need to edit all those separate functions.

Any plans to introduce stride?

There are already stride, but it is not working properly i need to fix it.
BTW there are not stride for BSGS.

[Alpaste]

Dear albertobsd,
can you develop an or is there algorithm to try to get public keys of the unsolved puzzles? example; puzzle 64, 66, 67, 68?
if we get the publickeys, the puzzles would be solved in less than minute.
Thanks in advance.

[CoinMagus]

Dear albertobsd,
can you develop an or is there algorithm to try to get public keys of the unsolved puzzles? example; puzzle 64, 66, 67, 68?
if we get the publickeys, the puzzles would be solved in less than minute.
Thanks in advance.

I just know little python and I did something like this:  https://github.com/sezginyildirim91/keysubtracter

If it is adapted to the C language, it can be very productive.

[Alpaste]

Thank you for posting your idea!

but this idea is really rare to success and to happen, and it takes a lot of time to do searching in a such huge range space. We need a better algorithm to target public keys.

[mausuv]

hi albert
@cixegz this user question https://bitcointalk.org/index.php?topic=5379443.msg58874670#msg58874670
its posible algebra and math tricks use to guess y odd is small or big range
                                                                           y even is small or big Roll Eyes range

[bigvito19]

Dear albertobsd,
can you develop an or is there algorithm to try to get public keys of the unsolved puzzles? example; puzzle 64, 66, 67, 68?
if we get the publickeys, the puzzles would be solved in less than minute.
Thanks in advance.

He already has that, its called pub2rmd mode its under Experimental modes

https://github.com/albertobsd/keyhunt#pub2rmd-mode

[CoinMagus]

Dear albertobsd,
can you develop an or is there algorithm to try to get public keys of the unsolved puzzles? example; puzzle 64, 66, 67, 68?
if we get the publickeys, the puzzles would be solved in less than minute.
Thanks in advance.

He already has that, its called pub2rmd mode its under Experimental modes

https://github.com/albertobsd/keyhunt#pub2rmd-mode

Keyhunt searches the whole range in pub2rmd mode. It searches in the range given in the link I shared above.

[albert0bsd]

hi albert
@cixegz this user question https://bitcointalk.org/index.php?topic=5379443.msg58874670#msg58874670
its posible algebra and math tricks use to guess y odd is small or big range
                                                                           y even is small or big Roll Eyes range

No there is no way to do that...

[cryptoQueez]

I want to open this thread to talk about the tool that i develop Keyhunt available on github.

https://github.com/albertobsd/keyhunt

Keyhunt use the BSGS algorimth to find privatekeys with the publickey, the program runs on CPU and make several use of RAM to boost the speed.

To try to find the privatekey from the 120 puzzle you need to add this publickey "uncompress" to a txt file:

How to use

• Add the publickey to a file

120.txt

Code:

02CEB6CBBCDBDF5EF7150682150F4CE2C6F4807B349827DCDBDD1F2EFA885A2630

you can run the tool agains that file:

Code:

./keyhunt -m bsgs -f 120.txt -b 120 -R

output

Code:

[+] Version 0.1.20210321 K*BSGS
[+] Setting mode BSGS
[+] Min range: 800000000000000000000000000000
[+] Max range: ffffffffffffffffffffffffffffff
[+] Setting random mode.
[+] Opening file 120.txt
[+] Added 1 points from file
[+] Bit Range 120
[+] Setting N up to 17592186044416.
[+] Init 1st bloom filter for 4194304 elements : 14.00 MB
[+] Init 2nd bloom filter for 209716 elements : 0.00 MB
[+] Allocating 128.0 MB for 4194304 aMP Points
[+] Precalculating 4194304 aMP points
[+] Allocating 3.00 MB for 209716 bP Points
[+] precalculating 4194304 bP points
[+] Sorting 209716 elements
[+] Thread 0: 000000000000000000000000000000000092dd2b47cff81ad94120bf853ef87f
[+] Thread 0: 0000000000000000000000000000000000f7fe7fccb98e136a97c2fa9d41de7b
[+] Thread 0: 00000000000000000000000000000000008d4882d7f596851a73ae35543c4dcd
Total 35184372088832 keys in 30 seconds: 1172812402961 keys/s
[+] Thread 0: 00000000000000000000000000000000009e80f97d3e3ff0fddbdcf02894e41d
^C

Speed: 1 Terakeys/s

Well in that example (same in github) we can reach 1Terakeys/s with one thread.

Wan to more speed? use the "-k value" param to boots the speed

Code:

./keyhunt -m bsgs -f 120.txt -b 120 -R -k 20

Output:

Code:

[+] Version 0.1.20210321 K*BSGS
[+] Setting mode BSGS
[+] Min range: 800000000000000000000000000000
[+] Max range: ffffffffffffffffffffffffffffff
[+] Setting random mode.
[+] Setting k factor to 20
[+] Opening file 120.txt
[+] Added 1 points from file
[+] Bit Range 120
[+] Setting N up to 17592253153280.
[+] Init 1st bloom filter for 83886080 elements : 287.00 MB
[+] Init 2nd bloom filter for 4194304 elements : 14.00 MB
[+] Allocating 6.0 MB for 209716 aMP Points
[+] Precalculating 209716 aMP points
[+] Allocating 64.00 MB for 4194304 bP Points
[+] precalculating 83886080 bP points

[+] Sorting 4194304 elements
(Thread output omited....)
Total 703690126131200 keys in 30 seconds: 23456337537706 keys/s
(More thread output omited....)
Total 2814760504524800 keys in 120 seconds: 23456337537706 keys/s

Speed: ~23 Terekeys/s

Tips

• you can quiet the thread output with -q
• you can load the precalcutalted bPtable -p yourfile.bin

Do you still want to more speed? Well Use more RAM, the -k 128 will use some 2.5 GB of RAM

This file will take some minutes for the value -k 128, but the speed worth it!

Code:

./keyhunt -m bsgs -f 120.txt -b 120 -R -k 128 -p ./bPfile.bin

Output:

Code:

[+] Version 0.1.20210321 K*BSGS
[+] Setting mode BSGS
[+] Min range: 800000000000000000000000000000
[+] Max range: ffffffffffffffffffffffffffffff
[+] Setting random mode.
[+] Setting k factor to 128
[+] Opening file 120.txt
[+] Added 1 points from file
[+] Bit Range 120
[+] Setting N up to 17592186044416.
[+] Init 1st bloom filter for 536870912 elements : 1840.00 MB
[+] Init 2nd bloom filter for 26843546 elements : 92.00 MB
[+] Allocating 1.0 MB for 32768 aMP Points
[+] Precalculating 32768 aMP points
[+] Allocating 409.00 MB for 26843546 bP Points
[+] Reading 536870912 bP points from file ./bPfile.bin
[+] Sorting 26843546 elements
(Thread output omited....)
Total 4345269952970752 keys in 30 seconds: 144842331765691 keys/s
(More thread output omited....)
Total 17539409486282752 keys in 120 seconds: 146161745719022 keys/s

Speed: ~146 Terakeys/s one single thread

OK at this point maybe you want to use ALL your RAM memory to solve the puzzle 120, just a bigger -k value

I already tested it with some 24 GB used with -k 1024 and I get 1.16 Petakeys/s per thread.

Using the same configuration with 4 threads I get 4.5 Petakeys/s total

Image:



FAQ

Q: Why the Progress is not displayed?
R: The speed depent of the number of target publickeys if you load 1000 publickeys, it will take some more time, the speed is only displayed when at least one thread finish one of his cycles

Q: Can we faster this code with Gpu?
R: Well yes, but the BSGS algo use RAM, only high end video cards have a lot of RAM, for GPU is better to use Kangaroo

Q: How long will take the scan the 120 bit range?
R: Human brain usually can't handle big numbers, the 120 bit space have 664613997892457936451903530140172287 (six hundred sixty four decillion...) and we speed is about 1000000000000 (one trillion or one terakey/s) the spected time acording with your speed is:

Code:

Puzzle 120 @ 1 Terakeys/s :     21074771622667996 years
Puzzle 120 @ 1 Petakeys/s :     21074771622667 years

Q: Why should i keep using brute force tools?
R: You should not, but people hope in luck.

Q: Is avaible for Windows?
R: Natively no, but you can install the ubuntu shell for windows and compile it from there

Q: It have dependencies?
R: Just libgmp for BigIntegers install it with

Code:

apt-get install  libgmp3-dev

Q: Why your program use alot of RAM?
R: Actuallly i keep in RAM two things (Bloomfilter and a Full bPTable ) im working in one way to remove or reduce the bPTable.

Nexts releases

• BSGS with K factor Release in 6/March
• Network/Pool versión
• Pollard rho

Best regards!

Great information to share!! How to use pfile??

[albert0bsd]

Great information to share!! How to use pfile??

Why quote all the post ?? Why not just to ask that?

The pfile is obsolete right now, the new version generate his own files automatically if you use always the -S option.

Regards!

[adaris]

Hello. please help me to calculate the probability of winning puzzle 120 in random mode
if
i have 20000000001 keysubtract
speed 27000000/s

what are the chances ?
it is more than 0,0002% ?

[DeepComplex]

Hi Albert0bsd,

Any updates on the additional features for Keyhunt?

Regards,

[PrivatePerson]

is it possible to add an option to search for lost characters in the private key?
For example:
Address 1HZwkjkeaoZfTSaJxDw6aKkxp45agDiEzN
Private key 5KYZdUEo***3FPrtuX2Qb***nNP5zTd7yyr2S******sBCnWjss  or e3b0c44****c1c149afbf4c8996fb****7ae41e4649b934c****991b7852b855

Maybe someone knows similar already existing programs?

[PawGo]

is it possible to add an option to search for lost characters in the private key?
For example:
Address 1HZwkjkeaoZfTSaJxDw6aKkxp45agDiEzN
Private key 5KYZdUEo***3FPrtuX2Qb***nNP5zTd7yyr2S******sBCnWjss  or e3b0c44****c1c149afbf4c8996fb****7ae41e4649b934c****991b7852b855

Maybe someone knows similar already existing programs?

If you have missing characters in WIF, decoding to private key (hex) is not obvious. The most probably the example your show is incorrect.
For restoring WIF, you have several programs, I will mention mine (https://github.com/PawelGorny/WifSolver) where you may specify "gaps" and characters which you want to try there.
For restoring private key with gaps, I do not know any program, but if you have serious case to solve, I may write something new. All depends on number of missing characters. 12 like in your example is already a serious amount of work.

[PrivatePerson]

I'm just interested in a tool with which you can iterate over the missing characters of the private key. I wonder how fast this can be done knowing the hexadecimal key with the missing characters and the address or hash160. Now I found a program that selects 7 characters ~ 1 hour. Perhaps the creator of the keyhunt knows faster algorithms.

[albert0bsd]

Any updates on the additional features for Keyhunt?

Not yet sorry.

is it possible to add an option to search for lost characters in the private key?

I've thinking in this for a while, but i think that it will be a better option make new program for that.
Since there are different cases for every kind of places where the missing are (together or not) ending, beggining middle, publickey available or not, it is a lot of work.

All depends on number of missing characters. 12 like in your example is already a serious amount of work.

I agree with that 12 missing characters is a lot of work. And more if there are in different part of the key.

Private key 5KYZdUEo***3FPrtuX2Qb***nNP5zTd7yyr2S******sBCnWjss  or

58^12 = 1449225352009601191936

e3b0c44****c1c149afbf4c8996fb****7ae41e4649b934c****991b7852b855

16^12 = 281474976710656

The second key is more solvable that the first one. By the way that kind of examples are rare to be found and most of then are not real.

Perhaps the creator of the keyhunt knows faster algorithms.

With the publickey avaiable for this example we can use BSGS to do this task but we need some changes becasuse we need to do the calculate the differents ranges for each different change in the most significan bytes.

To solve the your hexadecimal key example is only a 48 bits problem.

because 16^12 = 2^48 = 281474976710656

If we do the last 2 missing bytes with BSGS the problem can be reduced to only a 32 bits of forcebrute, this problem can be done/solve in some hours CPU with the correct code.

Edit

I found in a way to solve this (Hexadecimal key) in less than one hour, we can divide it in 2 parts a hashtable/bloomfilter of 2^24 of precalculated keys, and 24 bits of forcebrute with some math operations with publickey.

[PrivatePerson]

I gave this key as an example, in my case there are more unknown characters.
I correctly understood that everything that you wrote about the division of the private key and the use of the BSGS is only subject to a known public key?

[albert0bsd]

I correctly understood that everything that you wrote about the division of the private key and the use of the BSGS is only subject to a known public key?

Yes, all those things I wrote before are only possible with the public key. Without it there are not shortcuts or math tricks.

Regards!