Keyhunt - development requests - bug reports

[whanau]

Hello Thank you for making this code public. I really like it.

In BSGS mode, if you do not specify a range, will the program default to the entire key range or some default range?

Thank you

[1715197600]

1715197600

[1715197600]

1715197600

[1715197600]

1715197600

[1715197600]

1715197600

[dextronomous]

Same likes from me for your progs man, really nice stuff,
wanted to ask if for -rmd mode u can also use the -k
or a larger ./bpfile
keep up with your great work. 

[albert0bsd]

Hello Thank you for making this code public. I really like it.

In BSGS mode, if you do not specify a range, will the program default to the entire key range or some default range?

The default range is from 1 to FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141

Same likes from me for your progs man, really nice stuff,
wanted to ask if for -rmd mode u can also use the -k
or a larger ./bpfile
keep up with your great work. 

Sorry no, -k is only for mode bsgs, i will add it in the readme.

best regards!

[whanau]

Hello,

Using this command, I am trying to search a range with BSGS.

./keyhunt -m bsgs -f tests/120.txt -ra00000000000000000000000000000:bfffffffffffffffffffffffffffff -k 512

I get

• Version 0.1.20210331
• Setting mode BSGS
• Setting k factor to 512
• Opening file tests/120.txt
• Added 1 points from file
• Setting N up to 17592186044416.
• Init 1st bloom filter for 2147483648 elements : 7361.00 MB
• Init 2nd bloom filter for 107374183 elements : 368.07 MB
• Allocating 0.2 MB for 8192 aMP Points
• Precalculating 8192 aMP points
• Allocating 1638.40 MB for 107374183 bP Points
• processing 2147483648/2147483648 bP points : 100%
• Sorting 107374183 elements
• Thread 0: 0000000000000000000000000000000000a00000000000000046b00000000000
• Thread 0: 0000000000000000000000000000000000a0000000000000008e500000000000
• Thread 0: 0000000000000000000000000000000000a000000000000000d4a00000000000
• Thread 0: 0000000000000000000000000000000000a0000000000000011bb00000000000

and after some time maybe an hour,

• Thread 0: 0000000000000000000000000000000000a00000000000006c83900000000000

Is it supposed to start in the middle and work its way out? What is happening?

Thank you

[fxsniper]

How can I create bPfile.bin?

Can't open file
Can't open file

I try make bPfile.bin

+] Reading 4294967296 bP points from file bPfile.bin
Can't read the file seen you have less items that the amount needed
Can't read the file seen you have less items that the amount needed

[fxsniper]

How can I create bPfile.bin?

Can't open file
Can't open file

I try make bPfile.bin

+] Reading 4294967296 bP points from file bPfile.bin
Can't read the file seen you have less items that the amount needed
Can't read the file seen you have less items that the amount needed

Ok. I got infomation from post on first page

./bPfile 20000000 bPfile.bin

How much number create recommend?

[fxsniper]

• processing 19495846/214Can't read the file seen you have less items that the amount needed
• processing 19964144/2147483648 bP points : 0%

What recommend when I run on Linux Subsystem on Windows 10?
and limited with low memory

[Markzuberg64]

• processing 19495846/214Can't read the file seen you have less items that the amount needed
• processing 19964144/2147483648 bP points : 0%

What recommend when I run on Linux Subsystem on Windows 10?
and limited with low memory

Depends on your choosen K , t and b value (Or range choosen ) , if you want to create bpfile yourself then run the program first with desired config and note value of BP points that program is generating. Then terminate the program and run bpfile.bin with that value.

Bpfile so generated can be used as long as value of K , t and b remain same.

For low memory you can roughly calculate yourself. For around 1 million BP points , bloom filter takes 15MB in memory.

[albert0bsd]

Is it supposed to start in the middle and work its way out? What is happening?

Is working, what is your doubt?

• processing 19495846/214Can't read the file seen you have less items that the amount needed
• processing 19964144/2147483648 bP points : 0%

What recommend when I run on Linux Subsystem on Windows 10?
and limited with low memory

You need to create a bigger file, with more than 2147483648 items.


The file need the next amout of items (4,194,304  * K)

So if you are planning changing you K a lot of times, again and again please stop to that, chose a K value and make your file once.

Sorry for make the program in that way.

best regards

[seoincorporation]

Great work albert0bsd!

I'm running the code now, lets see if it doesn't burn my old craptop 

I was looking at the source code and as some other users already commented, it would be awesome to run it with Cuda cores or OpenSL, that way we could try tons of keys with the right GPU mining rig... But looks like a complex task.

If I hit that 64 jackpot y will share a tip with OP, Odds are null but the only way to do it is trying.

[dextronomous]

hi albert0bsd, this one is for iceland, kangrand
i keep getting
0x02D822FAC57DB1CA1E060581969B0247A388C46F331FEC84307121328B08FD4E66 Aborted !
and now for you albert0bsd

i keep getting false collisions with the same pubkeys
MK/s][Count 2^37.92][Dead 2][34:17 (Avg 29:02)][2.0/4.0MB]
Key# 1 [XX]Pub:  0x02A46B582948835B0D715E5F5EAA34ABADB8C1E221C8E1A5FD3773CDC3EC1C2C5B
       Aborted !
A False collision ignored, just the 64th bit keyspace scanning. bsgs_hybrid
thanks for the help
i guess it fixed itself. thanks for your great software,

[albert0bsd]

I was looking at the source code and as some other users already commented, it would be awesome to run it with Cuda cores or OpenSL, that way we could try tons of keys with the right GPU mining rig... But looks like a complex task.

I will add it later, long later, first im solving some bugs and improving the general speed in CPU

If I hit that 64 jackpot y will share a tip with OP, Odds are null but the only way to do it is trying.

Good luck, actually we have better chances to hit the #64 with some megakeys/s than the 120 with Petakeys/s

A False collision ignored, just the 64th bit keyspace scanning. bsgs_hybrid
thanks for the help

Yes he told me something about that issue, i will send him your message.


BTW guys i just publish a video on youtube about keyhunt.

https://youtu.be/k3698rhRUzg

I hope you like it.

Best regards!

[whanau]

Is working, what is your doubt?

Not doubt, just not understanding.
Thread 0: 0000000000000000000000000000000000a000000000000000d4a00000000000
Thread 0: 0000000000000000000000000000000000a0000000000000011bb00000000000
Why are right hand bytes always zero on update ? Is it because the program just displays at that range and everything in between d4a00000000000 and 11bb00000000000 is not shown?

Thanks again for a great program

[WanderingPhilospher]

Been doing some testing.  I have a CPU only setup/program that takes an input file of full BTC addresses and randomly searches user defined keyspace.

I can get 1 MKey/s with a list of 15 million addresses (i5-4690 running 4 threads).  I am curious, does/will your Keyhunt program handle that many addresses and if so, does the Key/s drop?

Also, I read your page and I have a suggestion for you.  You say that searching RIPE is 2x faster than full address; why not read the input file of full addresses, convert them to RIPE, and then do the search on RIPE? Then you only have to have the one user option...to search for full address while under the hood, the program converts to RIPE and searches for RIPE.  That's how my program works, C++ based off of VanitySearch (but CPU only).

[albert0bsd]

Hi WanderingPhilospher, thanks for test the program.

I can get 1 MKey/s with a list of 15 million addresses (i5-4690 running 4 threads).  I am curious, does/will your Keyhunt program handle that many addresses and if so, does the Key/s drop?

Keyhunt use a Bloom filter to check if the generated address or hash is on the list, this will lead in some false positive collision (Error rate is one in a million or something like that), so if the the bloom filter return a positive result, it use a second check, this is a binary search over all the address or items in the list, it can dertermine if one item is on the list perfoming only log(N)/log(2) operation, for 15 Milllions of addres this process only take 24 comparations.

This is like the hash table but i prefer keep those separated becuase there are some trick with the bloom filter that allow you use a little less ram in the case of the BSGS mode.

And no, in keyhunt there are no key drop or anything like that.

why not read the input file of full addresses, convert them to RIPE, and then do the search on RIPE?

Yes you are totally right this will be changed soon.

Im working in some migration from libgmp to the secp256k1 library used in  the JLP  BSGS Code, i already check that librery and with some hardware and code tricks it can be 4 or 5 times more faster for publickey generations, this will boost all the modes speeds, address, rmd160, xpoint and bsgs mode in the  code.

Best regards!

[WanderingPhilospher]

Yes you are totally right this will be changed soon.

Im working in some migration from libgmp to the secp256k1 library used in  the JLP  BSGS Code, i already check that librery and with some hardware and code tricks it can be 4 or 5 times more faster for publickey generations, this will boots all the modes speed, address, rmd160, xpoint and bsgs mode in the  code.

Good deal and good work you've done with your program.

4x 5x times faster? Now you just need to code for Windows users

[unclevito]

Program works great but one question. On the BSGS function puzzle 120 only goes to
+] Setting mode BSGS

• Min range: 800000000000000000000000000000
• Max range: 1000000000000000000000000000000
• Setting random mode.
• Setting k factor to 128
[

+] Min range: 80000000000000000000000000000000

• Max range: 100000000000000000000000000000000[/b][/i][/i]
  
• Opening file tests/120.txt
• Added 1 points from file
• Bit Range 128
• Setting N up to 17592186044416.
• Init 1st bloom filter for 536870912 elements : 1840.00 MB
• Init 2nd bloom filter for 26843546 elements : 92.02 MB
• Allocating 3.8 MB for 32768 aMP Points
• Precalculating 32768 aMP points
• Allocating 409.60 MB for 26843546 bP Points
• processing 1950960/536870912 bP points : 0%

I tried the -r but it had no effect on increasing the range. Is this the limit of the space the program can scan? how do I increase the range to the end of the keyspace FFFFFFFFFFFFFFFFFFFFFFFFFFFFFF?

[unclevito]

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:

I am confused if 120 address and public key are compressed why do you say we need to use "uncompress" for 120?

[gitman]

Would someone explain please, what's the point of generating the bPfile.bin file? I run tests with it and without, the speed performance seems to be about the same.
Thank you.

[hskun]

I think you can try xor filter, it's more faster.
https://github.com/FastFilter/xor_singleheader