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

I am trying to follow what you are saying as well, as I have a Windows version, and want to make sure there are no bugs, as you say.

When I run your command line flags:  WindowsKeySubtractorv2.3 -p 0265119A9E94A135BAE5E03AD6F41DA5D7D7CC5873448FFC7B2F2304B520DBE133 -s -a -n 32 -f publickey -o 0x10to0x100.txt -r 0:13CD125F2165F8510DBA46008014A09

(with my Windows version), I get:


If I take the first one you show different, (the 4th down the list, and run it with keymath) I get:


But you get something like this:
036e531664a1356caf0e253a3c1cd6f46724358cbcc07892c6a34f94769f9554fa

It would help if you would post the entire output file, as I did above, to see all your results, to better understand, if there is a disconnect or something.

now check the out put off ecc tool and subtract its not same alltime

@farshadbbb Thank you for report it, but I think that you don't full understand how it works:

Lets run the values that you suggested but with all the offset comment information.

Command:

Output:


Lets take any value example:

Now using modmath or keymath:


So in general if your substracted key is:

the Target key is


This work with all the values given by the output of keysubtracted.

Hava a nice day

                                                                                                      8F39E9339CB57B4FD233864AC7E50481DCFD8725979E79B487494451A6DE5B44
 + 1645007837268601581759340926449306128 ====>                   +                                                         13CD125F2165F8510DBA46008014A10
                                                                                                      __________________________________________________________________
                                                                                                     8F39E9339CB57B4FD233864AC7E50481DE3A584B89B4D9399824E8B1AEDFA554 


but subtrac gave us this


8f39e9339cb57b4fd233864ac7e50481de3a584b89b4d9399824e8b1aedfa54d        036e531664a1356caf0e253a3c1cd6f46724358cbcc07892c6a34f94769f9554fa

KEY SUBTRACTOR DON WORK WEELL
1EELvJCgvKkxR9pemz3vjT9ExV4JwA8EUU    adress
8F39E9339CB57B4FD233864AC7E50481DCFD8725979E79B487494451A6DE5B44    pv key 0265119A9E94A135BAE5E03AD6F41DA5D7D7CC5873448FFC7B2F2304B520DBE133   pubkey
------------------------use keysubtracter     ./keysubtracter -p 0265119A9E94A135BAE5E03AD6F41DA5D7D7CC5873448FFC7B2F2304B520DBE133 -n 32 -f address  -o  0x10to0x100.txt  -x -r 0:13CD125F2165F8510DBA46008014A09


results   
1GsPaXkdFKq4Bjdjai46XJp59e4Zggq2dT 8F39E9339CB57B4FD233864AC7E50481DD115437F6BFDFACD856FE97A75E6FE5 02A5A025764100E0A61B73C3B6B3E7AAF2DC16D828156E06C39EF1FE6861DDA86A
1MQJpZo1mfuvNdk3GQeB5tokM2FYcutNgo 8F39E9339CB57B4FD233864AC7E50481DD25214A55E145A52964B8DDA7DE8486 0310CA2B0AFE2A8B218F56D9E5DDA2A92B90DEA6D5D45824464D3EFCD297A6AE13
1LBVtevjQetHrhFpnP3GxVhoaSoeB4e8pg 8F39E9339CB57B4FD233864AC7E50481DD38EE5CB502AB9D7A727323A85E9927 02DA040AA5E121ADD16D5AE06B65E39801185401BEFB44F55FE8DC77FFC5FA756C
1CXx3rSFVBBfdVNDVNgZJFZDxt9ytkjysx 8F39E9339CB57B4FD233864AC7E50481DE3A584B89B4D9399824E8B1AEDFA554 0385CD34FBE923F770A51FEBD5C7C3249727A049859BC6581CA53C997F76052709
1ADw5YSCS1Jovix3XuEMYt6VpAncVwg4x  8F39E9339CB57B4FD233864AC7E50481DD4CBB6F14241195CB802D69A8DEADC8 02D28F2BADB89E7A2F8F44911F7FC8129984888A5B6F80747C4740F1BDF4CF881A
1EfeYSuMyvDKTcLt8jLsszMUQC6AJ4xigE 8F39E9339CB57B4FD233864AC7E50481DD6088817345778E1C8DE7AFA95EC269 02765794A6E3E7C5E73415A2E8A671D7080E8BD6F44E504BF4E88E9D5F09FF10E8
1z1knxXkVikqGXg3ius86GiPbsSZiwi3S  8F39E9339CB57B4FD233864AC7E50481DD745593D266DD866D9BA1F5A9DED70A 0297828E7DB0FBC26063BCE0942755BC68AE983A9160CC393CE757D9A5FFC039C3
1MtJGJ3XPBD9hUz1dWYVn8dabmTxQwXyuQ 8F39E9339CB57B4FD233864AC7E50481DD8822A63188437EBEA95C3BAA5EEBAB 03F495895E94768FF4DB43824EF319F4E1626476B784B686D9288F15D57EF06BE5
1CbEr7CAGZwE2Cqu1nrp3nSYYqSZYQdBiD 8F39E9339CB57B4FD233864AC7E50481DD9BEFB890A9A9770FB71681AADF004C 02F4958FD72F0550109D3C8A3F198156AD92F2658E2BEF65EF7CEDCBCD1CE10A99
1BJEjxqA8pMCUTEpGbr4UFa37g4j77G2ur 8F39E9339CB57B4FD233864AC7E50481DDAFBCCAEFCB0F6F60C4D0C7AB5F14ED 03A7A7035F849E1F3A043800141CE70734A3EBCFF878F5DD98AD65B46CF09A8501
1NRfvxBGhztkQreqCK2j4dGTZUyruqgs1m 8F39E9339CB57B4FD233864AC7E50481DDC389DD4EEC7567B1D28B0DABDF298E 03557D8BB835AC1F812238C316DEA5B18056C059896743CA4357E6E7DF8F20BBCB
1MQgJomzMWy92prcLYApEg1YcqTjgSWV4N 8F39E9339CB57B4FD233864AC7E50481DDD756EFAE0DDB6002E04553AC5F3E2F 02E8B6285C9C2EEB5245923BCB5810B42FC6957F883A1BF06EBF3BDDCF5D28E432
1CVkS4h6Qs2ajw8xDMuAfAgDTgvKFuHKVF 8F39E9339CB57B4FD233864AC7E50481DDEB24020D2F415853EDFF99ACDF52D0 03B0852769C61BC92EBB4B8E0325189803A7672D7AFF8138FCAF7E0912FB6DB83B
1BPWQgdfrw11P9eskfYQ3vZWg1zNXTN1Z4 8F39E9339CB57B4FD233864AC7E50481DDFEF1146C50A750A4FBB9DFAD5F6771 0292B9A4A62C9B11C2B74F5A112C3AE6F8205A812E50E1A998B72A3572206B2E60
1PbSvzjbCybcSFipSERiMd9UtCndWGrKfJ 8F39E9339CB57B4FD233864AC7E50481DE12BE26CB720D48F6097425ADDF7C12 0283CD0F56A1F1444437BB9BB527E6E23FD187F39A46CF5BAAE15635204D0BCE0B
19D1qGRrwP9ot36GPg9Qvyjx9pHvP98muF 8F39E9339CB57B4FD233864AC7E50481DE268B392A93734147172E6BAE5F90B3 021118F300AF0FE59577E4ECEFDC11F36D5CB910413D264726A767FD21A15DEE1C
 but if u chek some results are false and couse after one false if u want get subs from subs all beacame false
true result is
8F39E9339CB57B4FD233864AC7E50481DD115437F6BFDFACD856FE97A75E6FE5 02A5A025764100E0A61B73C3B6B3E7AAF2DC16D828156E06C39EF1FE6861DDA86A
8F39E9339CB57B4FD233864AC7E50481DD25214A55E145A52964B8DDA7DE8486 0310CA2B0AFE2A8B218F56D9E5DDA2A92B90DEA6D5D45824464D3EFCD297A6AE13
8F39E9339CB57B4FD233864AC7E50481DD38EE5CB502AB9D7A727323A85E9927 02DA040AA5E121ADD16D5AE06B65E39801185401BEFB44F55FE8DC77FFC5FA756C
8f39e9339cb57b4fd233864ac7e50481de3a584b89b4d9399824e8b1aedfa54d 036e531664a1356caf0e253a3c1cd6f46724358cbcc07892c6a34f94769f9554fa
8f39e9339cb57b4fd233864ac7e50481dd4cbb6f14241195cb802d69a8deadc6 03616ae6fe2c6c7a9a97027c52305cccc9b64758916eaf4dfb2db994d4d65ce2f7
8f39e9339cb57b4fd233864ac7e50481dd6088817345778e1c8de7afa95ec267 03191794e225b3fed0391261c5ed25616d38f0c33497d164f370912fdbae9bc1f6
8f39e9339cb57b4fd233864ac7e50481dd745593d266dd866d9ba1f5a9ded707 029383a890b195a64848c6bf50e68b924fd62ad545555005ef2db3c643af744ace
8f39e9339cb57b4fd233864ac7e50481dd8822a63188437ebea95c3baa5eeba8 0309ddd0888be5dfe0c665c64ec1eba91fb4246cb7ea5d70752cdfbb8c8967a331
8f39e9339cb57b4fd233864ac7e50481dd9befb890a9a9770fb71681aadf0048 03a538d719f3ef5b494f6a18cde1347764afa008b2aefd9861fdc2a3303557a923
8f39e9339cb57b4fd233864ac7e50481ddafbccaefcb0f6f60c4d0c7ab5f14e9 036a1f5dd3bcc7c81fe2b16a2b91786a4d056b8d892c0b1af2d9681fbcd58efa8c
8f39e9339cb57b4fd233864ac7e50481ddc389dd4eec7567b1d28b0dabdf298a 02f5269c5779fac10d4b0b0cba9f3b77cbf3d5b9f96a9c6cdf0476bf2d5879eda3
8f39e9339cb57b4fd233864ac7e50481ddd756efae0ddb6002e04553ac5f3e2a 03f913785579d454ab4ffd63d4fb26cc49b14db1fd57758e2921214ff77dd4c62d
8f39e9339cb57b4fd233864ac7e50481ddeb24020d2f415853edff99acdf52cb 02d865dfbb3b5928f7495f8d3267f30885994db9dfcdb6aa82452ff2ff27349e53
8f39e9339cb57b4fd233864ac7e50481ddfef1146c50a750a4fbb9dfad5f676b 03cba703947a45728f6c241a8ad782cd762a2a18603df38cdb0a8e0e26e78ebfe5
8f39e9339cb57b4fd233864ac7e50481de12be26cb720d48f6097425addf7c0c 03bda4005a84a25a025ccd022bb0cd0836673d3b95865bf06cc8b4cef12eda7fd9
8f39e9339cb57b4fd233864ac7e50481de268b392a93734147172e6bae5f90ac 036c520c6d7a6552dc590a27fc73221c09b78cb92c7ac7409bbe024c9d77a6373c

Ok now I understand, thank you very much sir, I'm using your Keyhunt in BSGS random at the moment only 64Gb RAM but I ordered another 64GB with a 7950x Great program btw

You still need to use range 135...

This is what the program actually do, if you have targe key it create N amount of keys arount that key like a target.

Example for -n 10

All those subtracted keys are near the target key and limited by the range that you select -r  or -b

Sorry for asking but I don't understand, let's say for puzzle 135... if I add/substract with the command ./keysubtracter -p 02145d2611c823a396ef6712ce0f712f09b9b4f3135e3e0aa3230fb9b6d08d1e16 -n 100 -b 90 ...   then on Kangaroo what range should I use ? The range for 135 bits key or the range for 90 bits ?

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.

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

I had same issues when compiling for windows using MingW64; my work around to fix this was to:

edit the gmpecc.c
strike out #include "gmpecc.h"
and remove the code starting with void Point_Doubling...

and place it all in keysubtracter.c after :

The problem, for Windows at least, was #include "gmpecc.h" was being called in keysubtracter.c and gmpecc.c 
That is what causes that error message. I tried to use the #pragma once and other flags to pass to the compiler, but it wouldn't work on Windows.

You can look at the files on my github repo if you are still confused.
https://github.com/WanderingPhilosopher/Windows-KeySubtractor

Hope that helps.

Hola.

New release for windows; now the add only, subtract only, or both is available in my new release.

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

Please test and let me know of any bugs.

Thanks again albert0bsd!

Hi, in simple terms, what can we do with it? Is it to brute force private keys using pub keys?
I'm not familiar with this tool what parameters should I use?

@albert0bsd, I am facing the same error issue while running this in Linux PC 4.4.0-19041-Microsoft #2311-Microsoft Tue Nov 08 17:09:00 PST 2022 x86_64 GNU/Linux

┌──(pc㉿PC)-[~/keysubtracter]
└─$ sudo make
gcc -O3 -c sha256/sha256.c -o sha256.o
gcc -O3 -c base58/base58.c -o base58.o
gcc -O3 -c rmd160/rmd160.c -o rmd160.o
gcc -O3 -c gmpecc.c -o gmpecc.o
gcc -O3 -c util.c -o util.o
gcc -o keysubtracter keysubtracter.c gmpecc.o util.o sha256.o base58.o rmd160.o -lgmp
/usr/bin/ld: gmpecc.o:(.bss+0x2020): multiple definition of `EC'; /tmp/ccbXGjoT.o:(.bss+0x0): first defined here
/usr/bin/ld: gmpecc.o:(.bss+0x0): multiple definition of `DoublingG'; /tmp/ccbXGjoT.o:(.bss+0x40): first defined here
/usr/bin/ld: gmpecc.o:(.bss+0x2000): multiple definition of `G'; /tmp/ccbXGjoT.o:(.bss+0x20): first defined here
collect2: error: ld returned 1 exit status
make: *** [Makefile:7: default] Error 1

┌──(pc㉿PC)-[~/keysubtracter]
└─$ uname -a
Linux PC 4.4.0-19041-Microsoft #2311-Microsoft Tue Nov 08 17:09:00 PST 2022 x86_64 GNU/Linux

┌──(pc㉿PC)-[~/keysubtracter]
└─$ gcc -v
Using built-in specs.
COLLECT_GCC=gcc
COLLECT_LTO_WRAPPER=/usr/lib/gcc/x86_64-linux-gnu/12/lto-wrapper
OFFLOAD_TARGET_NAMES=nvptx-none:amdgcn-amdhsa
OFFLOAD_TARGET_DEFAULT=1
Target: x86_64-linux-gnu
Configured with: ../src/configure -v --with-pkgversion='Debian 12.2.0-10' --with-bugurl=file:///usr/share/doc/gcc-12/README.Bugs --enable-languages=c,ada,c++,go,d,fortran,objc,obj-c++,m2 --prefix=/usr --with-gcc-major-version-only --program-suffix=-12 --program-prefix=x86_64-linux-gnu- --enable-shared --enable-linker-build-id --libexecdir=/usr/lib --without-included-gettext --enable-threads=posix --libdir=/usr/lib --enable-nls --enable-clocale=gnu --enable-libstdcxx-debug --enable-libstdcxx-time=yes --with-default-libstdcxx-abi=new --enable-gnu-unique-object --disable-vtable-verify --enable-plugin --enable-default-pie --with-system-zlib --enable-libphobos-checking=release --with-target-system-zlib=auto --enable-objc-gc=auto --enable-multiarch --disable-werror --enable-cet --with-arch-32=i686 --with-abi=m64 --with-multilib-list=m32,m64,mx32 --enable-multilib --with-tune=generic --enable-offload-targets=nvptx-none=/build/gcc-12-w47ffq/gcc-12-12.2.0/debian/tmp-nvptx/usr,amdgcn-amdhsa=/build/gcc-12-w47ffq/gcc-12-12.2.0/debian/tmp-gcn/usr --enable-offload-defaulted --without-cuda-driver --enable-checking=release --build=x86_64-linux-gnu --host=x86_64-linux-gnu --target=x86_64-linux-gnu
Thread model: posix
Supported LTO compression algorithms: zlib zstd
gcc version 12.2.0 (Debian 12.2.0-10)


@albert0bsd, having gcc version gcc
How to solve this please help.

thanks and Regards.

 @albert0bsd, I am facing the same error issue while running this in ubantu 22.04 LTS

having gcc version gcc (Ubuntu 11.3.0-1ubuntu1~22.04) 11.3.0

How to solve this please help.

thanks and Regards.

What version of Ubuntu do you have?


What version of gcc do you have?

Hello everyone,
i can't build this on windows ubuntu shell

I don't know subtract method will work or not? not yet have sample case for test with any puzzle improve
but many people try, I will tri to test this subtract method (not yet clear to understand on this knowledge)
Is there any other scripts keysubtracter in python language (sorry for ask, I am not expert on c++, I am not programmer)?

For this keysubtracter in c++ language, why not try to add GPU calculate to work faster (Dev both CUDA and OpenCL will be great)

I don't know python, but here is a link that explain the point Negation in eliptic curves:

https://www.youtube.com/watch?v=0EsyHJvf_JE

https://trustica.cz/en/2018/03/08/elliptic-curves-point-negation/

For you example the negated Point is : 04c6047f9441ed7d6d3045406e95c07cd85c778e4b8cef3ca7abac09b95c709ee5e51e970159c23 cc65c3a7be6b99315110809cd9acd992f1edc9bce55af301705

And the result is:

0479be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798483ada7726a3c 4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8

Regards!

this code subtracte in c language https://github.com/WanderingPhilosopher/Windows-KeySubtractor/releases/tag/v1.0


yes i know this git code
i am not understand c language so,
                         
input two point
privatekey    3     -    2      =   1
                 point1 - point2 = point3
                                               X                                                                                                                         Y
point1 f9308a019258c31049344f85f89d5229b531c845836f99b08601f113bce036f9      388f7b0f632de8140fe337e62a37f3566500a99934c2231b6cb9fd7584b8e672
point2 c6047f9441ed7d6d3045406e95c07cd85c778e4b8cef3ca7abac09b95c709ee5   1ae168fea63dc339a3c58419466ceaeef7f632653266d0e1236431a950cfe52a


i need 3rd point subtract value

please write easy understand make python or explain mathematicaly

Here is the Windows version:

https://github.com/WanderingPhilosopher/Windows-KeySubtractor

albert0bsd,

You may want to add the link in your main post so people who use Windows know they can use your program as well.

WP

Edit:  If Windows users wish to compile on their own, I followed this guide  https://www.msys2.org/  to download, install, setup the mingw-w64 GCC. Follow the instructions. Once complete, you can go to the above github page that has my Windows release and download the files and unzip. Open up MSYS MinGW 64-bit, do a cd (change directory) to the folder containing the files. Once there, simply type in make.

Enjoy.

I finally figured it out...how to compile in Windows using Mingw64 with make command!

I am learning more and more outside of my comfort zone of Visual Studio.

Sorry it took me so long lol.

I will post code for this code, the keysubtracter and your new code for, ecctools

Many thanks for the 2 cool programs

This did not work...I will work on it more later today. Thanks for responding!

OK, i see that, please edit the gmpecc.h file and add the next line at the begging of the file


And try to recompile it again

More info here: https://docs.microsoft.com/en-us/cpp/preprocessor/once?view=msvc-160

if that works please let me know for make that change too in the next update

I think it is good the way it is. Your logic is different that mine but your program works just fine for the way some would use it. Like I said, I can generate millions of offset keys with -b 100 and all of those offset keys will be in the original 119 keyspace for pubkey #120. You can also pre-subtract pubkey down to a specific range and then use keysubtracter, which is what I do. So I have millions of pubkeys in a 116 bit range, but only 1/8th of those new offset keys will be within that range.

I do like the option of selecting just subtract or addition, but not 100% necessary. A great, fast program that I have been looking for, for a long time. Many thanks!

Yes, I am using the "make" command in Mingw64.

I also used "make" command for KeyHunt and it compiled and worked perfectly.

If you see the number after the # char, is that the number that is being substracted or added to the original given publickey.


Yes you are totally right, my logic in the first version was was the next:

• if the target publickey was at the middle of the range, the subtracted keys will land from the beginning of the bit range up to the end of the same bit range.
• if  the target publickey was at the begging of the range, the subtracted keys will land in the first half of the bit range and the other half will land in the previous bit range
  
• but if the target publickey was at the end of the range, the subtracted keys will land in the last half of the bit range and the other half will land in the next bit range
  
• Obviously those are perfect cases, but the reality is that we don't know where is the target publickey, so my orignal idea was just increase the probability to have near a subtracted key in anywhere in the selected keyspace
  

But I repeat you are right i will add the option of select only make a subtract or addition.

Also think in the next one:

• if you are working with targets in the 256 bit space, any addition may end in a lower bit space due to cyclical behavior of the eliptic curve

Yes i see that error before, is some re-declaration of that G variable (gmpecc.c  load the gmpecc.h but also keysubtracter is loading that header file, i manage avoid that with the Makefile), maybe  adding some header directive like #prama once can be useful , but i don't know if it can work for you.

Are you using the command "make" in Mingw64 ?

If not, can you add the command that you are using to compile it?

You can use this program in many ways. But if you generate millions of offset keys say with a -b 100 flag, then all of those keys, whether added or subtracted, will still all be within the 8000... through ffff.... range that the 120 key lies in.  In this way, you have created millions of keys to search in the original range. You can use this program to reduce/subtract down to a given range and extract just the subtracted keys, but you will have many keys generated that do not lie in your reduced range.

It will subtract by however many bits you tell it to.
In his example:
He is telling the program to add and subtract up to 120 bits. You could change -b 120 to whatever; -b 50, -b 74, and that would be 50 and 74 bits. You can spread the bits out over a range as well using the -n 2048 -r 0:fffffffffff option as well. That will generate 2048 keys spread out evenly over the range of 0 through fffffffffff

I have built the KeyHunt for Windows using Mingw64 -make, but I receive this error when trying to use the make for keysubtracter:


I know you mainly build for Linux but wasn't sure if this was something you have seen/experienced before.

I am not sure if I understand the reason to add and compare.

It makes total sense to subtract from the 120bit key and compare it with a smaller range.

How many bits does it subtract it by?

Hello Alberto,

Can you make the mapping from the list by converting all extracted keys to HASH160?

I think it would be more effective than Pub2RMD feature.

Edit : I just checked. You made an update today, exactly what I wanted. Thank you very much.

Github page: https://github.com/albertobsd/keysubtracter

I publish this code on github in April 5, but i never update it until now, this is a small tool to make some substracted publickeys, address or hashes rmd160 from a target publickey.

This can be useful to increment our chances of hit some privatekey of the puzzles.

For example to make 100 copies of the puzzle 120 you need to execute the next command:


Output

but what that mean:


Output:

Windows version thanks to WanderingPhilospher

https://github.com/WanderingPhilosopher/Windows-KeySubtractor