Topic: Keyhunt - development requests - bug reports - page 27. (Read 15202 times)

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.

Is working, what is your doubt?


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

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.

• 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

Ok. I got infomation from post on first page

./bPfile 20000000 bPfile.bin

How much number create recommend?

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

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

The default range is from 1 to FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141



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

best regards!

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. 

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

Yes those point will work well with another publickey, Yes if you dont change the values of -k and -n then those points are always the same number and have the same value.

aMP points are not a problem to calculate it those values are less with biggers k values. The problem are the bP values, those values can be calcualted with the bPfile, already in the keyhunt directory.

Best regards!

Hi again ,

If i need to find key in a single range say -b 65 and for fix value -k 250 , then wouldn't it be beneficial to  save sorted amp points to one file and later on use same file for multi pubkey search. Like for searching 1 million key it seems easy and productive to search  in 1000 keys chunks. In that case it will take too much time to again calculate bp points , Amp points and sorting them. if Amp points so generated will work fine on different pub keys ? I see that it generates same number of amp points regardless of inserting 1 pub key or 5 pubkey.  

Thanks for the link to article and explanation. It helped a lot in understanding the algo. It would be better if you can provide tool to generate amp points as well to better understand the algo and if option to choose BP file and Amp file can be provided in program itself for testing purpose. I think -amp option is already available.

Hi everyone, i will update the code today with a new version, this new version is a little more faster and use less RAM, using less RAM meaning tha you can load a bigger bP Table with a bigger K value.


Thanks

bP points are G values, G, 2G, 3G, etc...

aMP points vary with the the values -n value or -k value

check this link to see a good explanation of the BSGS algo: https://andrea.corbellini.name/2015/06/08/elliptic-curve-cryptography-breaking-security-and-a-comparison-with-rsa/


My program dont generate that file by default, i really dont want to sature the HDD of the users of my program.

If you want to generate the bPfile by your own use the bPfile program is already compilied in the last version of keyhunt.

https://github.com/albertobsd/keyhunt/blob/main/bPfile.c




aMP Points change if you change your -n value or -k value. I can publish the tool to generate that file, but i need to add some "self-test" in the main program just to avoid that some user load a different or wrong files.


The program only do one math operation to check if one publickey is in a especific Range

https://andrea.corbellini.name/2015/06/08/elliptic-curve-cryptography-breaking-security-and-a-comparison-with-rsa/

So only one publickey is generated from sustractions and additions and that is compared agains all the bloom filter (bPTable)

If you read the link you will see that if we have a Range N we get an M value getting the squaredroot of N, the K factor was an Iceland recomendation, we can load in the bloom filter kM elements from G to kM, and we only are going to need M/k operaions instead of the orginal M operations sugested in the link.

Not just fast. With my system i get 14 trillion per sec , that on -t 8 -k 30 , with 8 GB ram , BP point allocation took around 2 GB .

What are your specs , BP point allocation seem to be on default with 1 thread only.

Hi ,

Glad to see this project here on bitcointalk . I am using it from last many days and its quite impressive . I found it via iceland2k14 comments on his bsgs repo. Anyways i have some questions for you.

1. What exactly are BP points and AMP points in your code. How are they calculated. Any specific formulae.
2. Where can i find BP file and Amp file after it gets calculated in your program. I am not able to locate any 1920 MB BP file generated for -k 30 im the directory.
3. -a how to make this file of precalculated amp points.
4. A question not related to this tool , i am supposing that this tool is calculating different key pairs at different spaces in a range. And matches the pubkey generated with the input pubkey - keyspace*G ,  my question is that since its comparing one single key from a keyspace of trillion keys then the output that its showing like 30 trillion keys scanned means that it actually matched 30 precalculated results from 30 trillion private keys. Right ? Or it is 30 trillions keys are converted to 30 trillion pub keys and matched in 30 second.
And what are K factor related to M , what is M here.

Thanks in advance.

That is the keys checked in a range from A to B

by example some range from/to in the 120 bit space:


Difference: 0x100000000000
Decimal: 17,592,186,044,416

That is the number of keys in that range, the BSGS algorimth can check that range in a few Operations, then that number of keys are already checked, and added to the total counter

Something is wrong with your input file, it doesn't have any valid data, yes is one bug, i need to solve it.

Edit Already Solved: Commit a0a60ede57890c5f46e711628f52de2d7becd270
 
Best regards!

it is normal.
I think it is too fast.

1086000828893888512 keys in 30 seconds

• Added 0 points from file
• Setting N up to 17592186044416.
• Init bloom filter for 4194304 elements : 11.00 MB
• Allocating 128.00 MB for aMP Points
• Precalculating 4194304 aMP points
• Allocating 64.00 MB for bP Points
• precalculating 4194304 bP points
• Sorting 4194304 elements

Total 1086000828893888512 keys in 30 seconds: 36200027629796283 keys/s
Total 2176681179275591680 keys in 60 seconds: 36278019654593194 keys/s
Total 3263473656541478912 keys in 90 seconds: 36260818406016432 keys/s
Total 4346941210644971520 keys in 120 seconds: 36224510088708096 keys/s

Thanks now ok quiet option already

turn off display make program work fast that show it display
other program is same turn off is make it work faster


and What mean keys, it is mean 1 private key or 1 key character

Total 2163563847226549600256 keys in 69000 seconds: 31355997785892023 keys/s
Total 2164516112257133838336 keys in 69030 seconds: 31356165612880397 keys/s
Total 2165465615314509103104 keys in 69060 seconds: 31356293300239054 keys/s
Total 2166412549912721883136 keys in 69090 seconds: 31356383701153884 keys/s
Total 2167356300325260623872 keys in 69120 seconds: 31356427956094627 keys/s
Total 2168303551582822203392 keys in 69150 seconds: 31356522799462360 keys/s
Total 2169249254728011874304 keys in 69180 seconds: 31356595182538477 keys/s
Total 2170192670889015771136 keys in 69210 seconds: 31356634458734514 keys/s

Most of those test version doesn't work (those are crazy ideas), The only version available is the the github version.



add -q to your command line.

Best regards!