Topic: keysubtracter - test - development requests - bug reports - page 2. (Read 2178 times)

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.

./keysubtracter -p 02ceb6cbbcdbdf5ef7150682150f4ce2c6f4807b349827dcdbdd1f2efa885a2630-n 100 -b 120

Note the bolded part above, no space therefore it starts to produce invalid keys.


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.😅

When you can explain and show examples better, maybe it will be easier to understand what you are saying.

Your exact words:

The #target is the supplied key.

I did not develop this tool, albert0 did.

Lol^256, my man, I got how to use this thing the first time you explained, what I had encountered was due to no space between target and -o output.txt in the command line page, so it displayed the 0 point public key and all the offsets were invalid coordinates, lol.
However when your target is one of the exact points you are subtracting, in the out put file it will show for example: 020000000000000000000000000000000000000000000 # + 1  and your target k is actually 1, so when the tool subtracts 1 from your target, it shows the 0 point public key. This is actually very interesting, because you just need to get "lucky" and subtract the exact k as the k of your target from your target to see the 0 point p.

Maybe you didn't know about this, so my man it is you who doesn't 100 percent knows the tool which you developed. Lol^N-1.

*= not the original quote, modified by me.😅

My man, I’ve told you to stop messing with tools you don’t 100 percent understand lol.

The target is the pubkey you are subtracting from; the one you put in the command line to add/subtract from.

You realize you have to run all of the added/subtracted pubkeys through a range and program to try to find them right? Keysubtracter is just a tool that helps you generate many offset pubkeys to search for. Then you have to actually search for them. If you find one, then you add or subtract the number beside it (find the pubkey found via some other program, in your keysubtracter output file) to find the target pubkey you initially entered into the keysubtracter program.

If you entered pubkey x and generated 100 offset pubkeys and you searched via another program and found pubkey 97, You now take pubkey 97’s private key, look it up in your keysubtracter output file, find the + or - number beside it, add or subtract that number, and you will now have the private key to the public key you entered into the keysubtracter program, aka your target pubkey.

Is anyone around these woods? So I understand if we hit a target while adding and subtracting it will show the public key zero aka 02000 with a lot of other zeros, but what does it mean when I have done the subtraction and it shows 0200000 # target. What to do now?

Thanks, now I understand how it works, my question is why haven't you guys looted all the puzzles already then? Well I guess you haven't yet figured out the secret ratio between public keys, whilst everybody thinks dividing public keys doesn't work, it could work and already has a solution we just haven't done enough diving into this amazing vast ocean of hidden mathematics!

---

Ps, when you develop and release software, always expect noobs come asking questions, I just learned about +- pub keys 2 days ago. I know in the past I asked around these woods, but since I couldn't comprehend the notion of sub/add, I didn't pay much attention.

Now I was thinking, if we divide a range by 1 billion tiny ranges and then collect 1 public key from each of them, for our future reference, then we start subtracting our target public key or adding, either going up or down the bit range, and whenever we hit one of our reference public keys, we just start counting points taken from our starting range to reach the checkpoint, and then since we know the private key of our checkpoint public key, we will add  the number of steps taken by the tool to the private key of our check point pub key and reach our loot.

A note to the world!

Now, now. Don't start panicking just yet, we are good treasure hunters, we will first drain the puzzle pot and then we will go after the long lost treasures, now is the the time to panic, because when we spend all those coins, we will come for your coins, and there is no coin safe from us, so where ever you go we will follow, this is the official manifesto of the "AWD" short for Alberto, Wandering, Digaran. The triple team that killed crypto currency, remember our names! Lol.😅

Honestly, you just shouldn't use this tool since you do not even know what it is doing and how to use it...just being honest.

It takes a given public key and adds or subtracts from supplied public key.

If you take a public key in the 20 bit/2^20 range, let us say it is derived from private key 00000000000000000000000000000000000000000000000000000000000D2C55; so its public key is 033c4a45cbd643ff97d77f41ea37e843648d50fd894b864b0d52febc62f6454f7c.

Now if you use -s (subtraction) a -n of 20 and a -r of 1:fffff, the program will generate 20 new pubkeys/addresses/rmd160s (depending on what you told the program to output and the program you are going to use to search for the results) plus the target pubkey/addresses/rmd160s (033c4a45cbd643ff97d77f41ea37e843648d50fd894b864b0d52febc62f6454f7c).

Now, you have to supply those 20 pubkey/addresses/rmd160s to a program and search the 20 bit range to try and find them. Once found, first, take the address/pubkey/rmd160 found and consult your input file and find the specific address/pubkey/rmd160 found and look at the hex number # + fff. Now you have to take the private key of the address/pubkey/rmd160 the program found, and the hex number # + fff that you previously found in your input file, and add the two together to get the private key of the initial public key you were searching for, 033c4a45cbd643ff97d77f41ea37e843648d50fd894b864b0d52febc62f6454f7c.

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?

First off, which version are you using? I believe mine has the only -s or -a flags/options.

The target address/pubkey/rmd160 is always included in the output file. If you run it multiple times, then yes, you will have multiple targets in the output file.

The + is there when you use the -s flag, because if you find the pub/address/rmd160 that is in the file, you will have to take the private key found and then + (add) the number to the right of the key found.
Example, if your file contains this:
1AjerabryCRsi8PQmyeqVmwqn5jMVGrf1j # + 10
and you find the address 1AjerabryCRsi8PQmyeqVmwqn5jMVGrf1j it will print the address plus it's applicable private key; you will have to take the applicable private key and add + 10 to it to get the real private key of the address you are looking for.
opposite if you run the -a flag; you will have to subtract to get the real private key.

It doesn't randomly select anything. It takes the range (-r) provided and then divides the range by how many keys you want generated (-n). Sticking with decimals for ease of example.
If you used a range of -r 1:1000 and wanted -n 10 (10) keys, the program subtracts start range from end range (1000-1 = 999)(but program auto rounds it up to even number, so it would be 1000)  and then divides that by -n 10 (1000/10 = 100) so it would generate keys spread out every 100 keys, so your output file would be something like,  +100, +200, +300, +400, +500, +600, +700, +800, +900, +1000.
Make sense?

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?

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.

@Op, in the output file I have several #targets, is that what we are looking for? How do I derive the private key now?