Topic: keysubtracter - test - development requests - bug reports (Read 1788 times)

Ahhh, I see what you mean, for some reason I wasn't considering that as an option... could end up a fair depth deep in order to get a reasonable working range to scan.

Thanks for your insight.

Lol, I know you say you are new to this tool, but I do not understand what you are saying/wanting to do.

Let me break it down. Let's say you want to space all keys out at every 100; can be as close or as far apart as you want them.

So you run your first 2^32 keys as such; public key = 1, n = 2^32, range = 1:2^32*100 = n 4294967296 range = 1:429496729600, now keys will be spread out every 100 keys (429496729600 / 2^32 = 100). You follow so far?

Now let's say you want more than 2^32 keys, you want 2^33 keys. So on your next run, you would do the same, just change the public key: public key = 429496729600, n = 2^32, range = 1:2^32*100 = n 4294967296 range = 1:429496729600

SO yeah, I do not follow what you mean by "Optimally, you'd want them closer together for a shorter search time." it really makes no sense, because you can change your 2nd and 3rd runs to whatever you want, in relation to the first run, same distance, shorter distance, longer distance, etc. however, that's not the point, the point is/was, you can generate more than 2^32 keys, you just have to make multiple runs.


It helps if one wants more than 2^32 generated keys, not sure how else to explain it.

Not sure how running a second or third time will help.... That will only create more at roughly the same distance apart as the previous run(s). Optimally, you'd want them closer together for a shorter search time.

EDIT:

I am search for puzzle #130 in the range 200000000000000000000000000000000:3ffffffffffffffffffffffffffffffff

Created 2,000,000,000 subtracted pk's. Each should be 340,282,366,920,938,484,656,701,964,288 apart. That's quite a distance  - 7573948.693931144 years of searching for EACH at 10 Pkeys/s  (that is, if my math is correct). 15147897387862288 years of searching that range without the added pk's.

That is an impressive reduction of time, but alas, I don't think I have 7 and a half million years to spare haha

Absolutely great idea, still not in the feasibility category yet though for the higher ranges.

Oh, so that means n is limited to 2^32 keys for each run...you could do as many runs as needed to reach desired number of generated keys.

The number of pubs that can be generated?

The distance is based on how many keys you want to generate.

The program takes the range you provide (always rounds up to an even number), subtracts the start range from the end range, and then divides that by how many keys you want generated.

Sticking with numbers, if your range is 1:2,000,000; and the number of keys you want generated is 1,000,000; then the distance between generated keys will be 2; 2,000,000 divided by 1,000,000.

I do not know where the 32 bit limit is implied or came from. Can you explain more?

Ok, so I think I understand how this works... certainly has some interesting potential.

If I am searching a higher range, the most this will script will give me is a distance of 2^32 from the unknown pk - Am I understanding this correctly? or is it the number of additions/subtractions that is 2^32 limited?

What range values should I enter in the script? Should I start from 0 to upper range limit, or only the actual range I'm searching?

It's been decades since I've thought about any advanced math topics, so it may take a bit to wrap my head around this type of stuff. Definitely interesting though!

Is there any way to know if a subtracted public key reaches out of bounds? For example if the subtracted public key goes below 0? From my understanding it would simply just loop around... so, would it be an idea to check the generated public keys to see when the subtraction hits that loop around point, then backtrace to see how many steps it took to reach that point....(which should give a closer point to start scanning from)?

Thanks

Just as a note, if people are not familiar with the program:

You only need the above python script if you are running in Random mode, -R.

If not running in Random mode, you can simply run the keysubtracter again without the -x flag.

I've made this simple Python script to process the resulting file from Keysubtractor, removing all the information beyond the pubkeys/hash160/addresses.

The original file will be kept intact as the script creates a new out file, this way you won't lose all the valuable information.


with open('pbks_in.txt', 'r') as file, open('pbks_out.txt', 'w') as outfile:
    for line in file:
        cleaned_line = line.split('#')[0].strip()
        outfile.write(cleaned_line + '\n')


Just have it in the same folder your Keysubtractor file is in, and don't forget to change the names of the in and out files to match yours.

I know this is simple stuff, but I hope this can be of help!

No, the program is actually very ok, i like it, it doesn't need any improvment. It does what it supposed to do. But sadly it's limited to 32 bits.

ps> and goodluck too!

Yw.
By special thing you mean my suggestion to improve this tool? Well to be able to do that we need the code written and developed, and alberto is MIA for some time now!

Good luck with your test, I haven't left the testing grounds yet, so welcome on board, and keep grinding.

Thanks for answer.

I am not doing that special thing, just some testing with pzzle 125

By X point you mean -z argument? That just excludes 02 and 03 from output keys, it is useful if you don't want to include both 02 and 03 x coordinates, that way you just add one with no 02, 03, it saves space and increases speed.

Show me you command line, lets see what you are doing.😉

---

You know I have been thinking about a feature addition, we could generate for example 10 M known private keys and only keeping the last 8 characters of their public keys while the private keys are completely saved, then we could run addition and subtraction operations while the program automatically checks all the result against those 10M known keys.

One time I had the public key for 0xb, which is key number 11 in decimal, now imagine how many easy and known keys are in our output files but we never notice them, but having the ability to check all on the fly would be a great addition and improvement IMHO.

Thanks Alberto and WanderingPhilospher for this useful program.

I understood most of it's functions however; I have problem understanding the X point function. What does it do exactly? Is it like adding/subtracting?

I need an example if possible 

Sofar i've been using only -s and -a. but not X point. Do you recommend X point for puzzle #125 more? Even though i don't know how it can be useful haha

Thanks

GR Sasa

They are desktop developers. I assume noone here are Android developers.

Hi dev,so I was wondering, is it possible to run key sub on android? Since it doesn't require any computing that much, it should be no problem to run it on a phone, have you ever done such a thing or is it too hard to do?

The program create the same amount of keys In both sides of your target example:


That is why N should be Even:


if you want some subtract some odd numbers you need to play a little with the size of the range  -r from:to divided bewteen the number N example:

Range 25 (19 Hex) divided bewteen 10


Odd numbers every ending 5

Range 15 (F Hex) divided bewteen 10


Odd numbers 3,9,15

I hope this examples help you

Uhh! hey there team mates! I was wondering what is the reason to select an even -n to add and subtract, if I set -n 5, what happens? Also selecting an even number which is a combination of 2 odd numbers will add/subtract odd numbers.  Or is it OK to do that?

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

yes basically if you add two publickeys with same X but different Y value (Negative key of each other) exaple:

02f3fad2f7b0f7f5ba634a0618479694b5744091fc7ed53177b5578dba06ee4b77 - 03f3fad2f7b0f7f5ba634a0618479694b5744091fc7ed53177b5578dba06ee4b77

you always get the point at the infinity, so in that case you the value of One of those you can get the value of the other.