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

./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?

there is no way to narrow it down with 100% certainty, In the best case the complexibility is the same, in the worst case the complexibility is sometimes worse. I've trying so many methods and none of then give you some certainty.

how to reduce the search range of 125 to 120 ? what range i put for substract the public key of 125 to smaller range ? 0:1f>>>>> ?

Not sure I need that but I was curious to test out and found that with 'n' higher than that the first address doesn't change.
Also when trying to make a big file I've found it working very slow. Uses only 4 threads (or maybe 2 cores). Thought the drive may be the problem but ram drive doesn't make any change.
Would be nice (and code simple I guess) to make the output file parted for such experiments

sadly yes, but are you going to do a list of more of 2 billion address?

Is 'n' 32bit limited?

It really depends on what you are trying to do and which program you will use to achieve what you are trying to do.

But a basic setting would be:


Or if you are using with a program that needs only x points:


And with those, I used -s to subtract, but you could use -a or -s and -a to get both added and subtracted points.

LOL 100%. My high school math teacher used to beat the hell out of me, hence my limited understanding. I have already read about the elliptic curve and all I could figure out from it was the fact that the graph looks like a vagina if you rotate it and the G spot is never on a single spot, very similar to a woman's body. Lol.

---

On github it says we need to save the generated data to get a private key from it, so could you give me an example command line for puzzle #125? I will take care of the rest, thanks.

New release for Windows Version (I guess it will compile and work on Linux as well).

https://github.com/WanderingPhilosopher/Windows-KeySubtractor/releases/tag/v2.2

New features/changes:

-a = add to pubkey only
-s = subtract from pubkey only

-a -s = add and subtract at same time, as before.

-z = x point only. Program will leave off leading y coord parity, 02 and/or 03. Only applicable when generating new pubkeys. Does not impact addresses or hash160s.

I added a completion percentage so people wouldn't wonder how close the program was from being finished LOL.

I converted the + and - info, from decimal to hex. I did this to save on file size/drive space. If you find a pubkey, address or hash160, you'll have to do math either way to reconstruct your target pubkey.

A few notes. You always have to use the -n flag. That tells the program how many keys you want to generate.
When using the -n, if you use -n 1000, you are telling the program to generate 1000 new pubkeys, addresses, or hash160s.
You have to use -n AND either -a, -s, or both.
If you use -a or -s alone, so if you use -a -n 1000, the program will add and generate 1000 new pubkeys.
If you use -a and -s together, so if you use -a -s -n 1000. the program will add and subtract 1000 new pubkeys, not 2000 new pubkeys.

My release section has the compiled Windows exe file. To run on Windows, download the WindowsKeySubtractorv2.2.zip folder. Unzip it. Edit the batch file settings. Make sure you run the program in the same folder as the .dll file (included in the zip folder) or you will get the "Missing libgmp-10.dll" error. Unless you have libgmp-10.dll loaded on your PC and set in the Path/environments.

Let me know of any bugs that you may find.

WP