Author

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

full member
Activity: 1162
Merit: 237
Shooters Shoot...
now check the out put off ecc tool and subtract its not same alltime

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:

Code:
02a5a025764100e0a61b73c3b6b3e7aaf2dc16d828156e06c39ef1fe6861dda86a # - 13cd125f2165f8510dba46008014a1
0315a15bdb850ab50c8cf1a1c6f47d3b1cb07b124af1d8bf06bf913bb1f13cbc6c # + 13cd125f2165f8510dba46008014a1
0310ca2b0afe2a8b218f56d9e5dda2a92b90dea6d5d45824464d3efcd297a6ae13 # - 279a24be42cbf0a21b748c01002942
02323053201886533953796268b80edba0c0af7308de913af1082349c4a13374fb # + 279a24be42cbf0a21b748c01002942
02da040aa5e121add16d5ae06b65e39801185401befb44f55fe8dc77ffc5fa756c # - 3b67371d6431e8f3292ed201803de3
02c79f88fcb76430c114d95e8d8898c111423289c5930d37c4df9492d71285db68 # + 3b67371d6431e8f3292ed201803de3
02d28f2badb89e7a2f8f44911f7fc8129984888a5b6f80747c4740f1bdf4cf881a # - 4f34497c8597e14436e91802005284
02158b81d7de72a35b5a6d5003656122eaf808392673451125e41694efcabb1b48 # + 4f34497c8597e14436e91802005284
02765794a6e3e7c5e73415a2e8a671d7080e8bd6f44e504bf4e88e9d5f09ff10e8 # - 63015bdba6fdd99544a35e02806725
02c224d28864179657ec8796c22f93b18350fa8b9fdf632c0ae43e272681a8db9b # + 63015bdba6fdd99544a35e02806725
0297828e7db0fbc26063bce0942755bc68ae983a9160cc393ce757d9a5ffc039c3 # - 76ce6e3ac863d1e6525da403007bc6
03dfd21401944a19e3c3067343d43fa2acec2c041cce2e0de2cc775ca7fa86307b # + 76ce6e3ac863d1e6525da403007bc6
03f495895e94768ff4db43824ef319f4e1626476b784b686d9288f15d57ef06be5 # - 8a9b8099e9c9ca376017ea03809067
02e0212283d33a74ec5b98f1b33ad70b38b1cdbdf3b27d8169e0f95df21a12c799 # + 8a9b8099e9c9ca376017ea03809067
02f4958fd72f0550109d3c8a3f198156ad92f2658e2bef65ef7cedcbcd1ce10a99 # - 9e6892f90b2fc2886dd2300400a508
02665bf4da19df71e3fd721b8ccb53240a073333d7812776594c86b497a3bba14e # + 9e6892f90b2fc2886dd2300400a508
03a7a7035f849e1f3a043800141ce70734a3ebcff878f5dd98ad65b46cf09a8501 # - b235a5582c95bad97b8c760480b9a9
027bbdee3e1afa5c3e5e6d1a3e700f10214ea76a1261cf8f673de866c1b8e52ffb # + b235a5582c95bad97b8c760480b9a9
03557d8bb835ac1f812238c316dea5b18056c059896743ca4357e6e7df8f20bbcb # - c602b7b74dfbb32a8946bc0500ce4a
026ca2132db5aba0750c9e9f414325195b23dae070103ebcea9de9d10488691b9a # + c602b7b74dfbb32a8946bc0500ce4a
02e8b6285c9c2eeb5245923bcb5810b42fc6957f883a1bf06ebf3bddcf5d28e432 # - d9cfca166f61ab7b9701020580e2eb
03c21b1170a4b8a333e728eefb88c25273aec8b50cbf27acfc1a928bbc4e98a952 # + d9cfca166f61ab7b9701020580e2eb
03b0852769c61bc92ebb4b8e0325189803a7672d7aff8138fcaf7e0912fb6db83b # - ed9cdc7590c7a3cca4bb480600f78c
02f310ca33b5051d5dc5e5dc100b71f34da626fbc3671c67d761aca0d374c5d86e # + ed9cdc7590c7a3cca4bb480600f78c
0292b9a4a62c9b11c2b74f5a112c3ae6f8205a812e50e1a998b72a3572206b2e60 # - 10169eed4b22d9c1db2758e06810c2d
027b0134c41fde6e6c3e14c112694f6d15a6a26bada9927b75c610f2faca8d0c1f # + 10169eed4b22d9c1db2758e06810c2d
0283cd0f56a1f1444437bb9bb527e6e23fd187f39a46cf5baae15635204d0bce0b # - 115370133d393946ec02fd4070120ce
027397a1cb67d2cf66acdb0bef63165ead8a650c283be065e9c9ae71d56e310a69 # + 115370133d393946ec02fd4070120ce
021118f300af0fe59577e4ecefdc11f36d5cb910413d264726a767fd21a15dee1c # - 129041392f4f98cbfcdea1a0781356f
036e91521a16fc5d0cb95a0514fefa337e31493bc33fb3ebc660f8f8c6be6d1f56 # + 129041392f4f98cbfcdea1a0781356f
0385cd34fbe923f770a51febd5c7c3249727a049859bc6581ca53c997f76052709 # - 13cd125f2165f8510dba46008014a10
0293039b4f98a31cd72f5506fccdd5df34ab36995ea061b1fb8dcea66638e5041e # + 13cd125f2165f8510dba46008014a10
0265119a9e94a135bae5e03ad6f41da5d7d7cc5873448ffc7b2f2304b520dbe133 # target


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

Code:
0265119a9e94a135bae5e03ad6f41da5d7d7cc5873448ffc7b2f2304b520dbe133 - 411251959317150395439835231612326532
Result: 02158b81d7de72a35b5a6d5003656122eaf808392673451125e41694efcabb1b48

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.


newbie
Activity: 2
Merit: 0
now check the out put off ecc tool and subtract its not same alltime
hero member
Activity: 862
Merit: 662
@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:
Code:
./keysubtracter -p 0265119A9E94A135BAE5E03AD6F41DA5D7D7CC5873448FFC7B2F2304B520DBE133 -n 32 -o 0x10to0x10
0.txt -r 0:13CD125F2165F8510DBA46008014A09

Output:
Code:
02a5a025764100e0a61b73c3b6b3e7aaf2dc16d828156e06c39ef1fe6861dda86a # - 102812989829287598859958807903081633
0315a15bdb850ab50c8cf1a1c6f47d3b1cb07b124af1d8bf06bf913bb1f13cbc6c # + 102812989829287598859958807903081633
0310ca2b0afe2a8b218f56d9e5dda2a92b90dea6d5d45824464d3efcd297a6ae13 # - 205625979658575197719917615806163266
02323053201886533953796268b80edba0c0af7308de913af1082349c4a13374fb # + 205625979658575197719917615806163266
02da040aa5e121add16d5ae06b65e39801185401befb44f55fe8dc77ffc5fa756c # - 308438969487862796579876423709244899
02c79f88fcb76430c114d95e8d8898c111423289c5930d37c4df9492d71285db68 # + 308438969487862796579876423709244899
02d28f2badb89e7a2f8f44911f7fc8129984888a5b6f80747c4740f1bdf4cf881a # - 411251959317150395439835231612326532
02158b81d7de72a35b5a6d5003656122eaf808392673451125e41694efcabb1b48 # + 411251959317150395439835231612326532
02765794a6e3e7c5e73415a2e8a671d7080e8bd6f44e504bf4e88e9d5f09ff10e8 # - 514064949146437994299794039515408165
02c224d28864179657ec8796c22f93b18350fa8b9fdf632c0ae43e272681a8db9b # + 514064949146437994299794039515408165
0297828e7db0fbc26063bce0942755bc68ae983a9160cc393ce757d9a5ffc039c3 # - 616877938975725593159752847418489798
03dfd21401944a19e3c3067343d43fa2acec2c041cce2e0de2cc775ca7fa86307b # + 616877938975725593159752847418489798
03f495895e94768ff4db43824ef319f4e1626476b784b686d9288f15d57ef06be5 # - 719690928805013192019711655321571431
02e0212283d33a74ec5b98f1b33ad70b38b1cdbdf3b27d8169e0f95df21a12c799 # + 719690928805013192019711655321571431
02f4958fd72f0550109d3c8a3f198156ad92f2658e2bef65ef7cedcbcd1ce10a99 # - 822503918634300790879670463224653064
02665bf4da19df71e3fd721b8ccb53240a073333d7812776594c86b497a3bba14e # + 822503918634300790879670463224653064
03a7a7035f849e1f3a043800141ce70734a3ebcff878f5dd98ad65b46cf09a8501 # - 925316908463588389739629271127734697
027bbdee3e1afa5c3e5e6d1a3e700f10214ea76a1261cf8f673de866c1b8e52ffb # + 925316908463588389739629271127734697
03557d8bb835ac1f812238c316dea5b18056c059896743ca4357e6e7df8f20bbcb # - 1028129898292875988599588079030816330
026ca2132db5aba0750c9e9f414325195b23dae070103ebcea9de9d10488691b9a # + 1028129898292875988599588079030816330
02e8b6285c9c2eeb5245923bcb5810b42fc6957f883a1bf06ebf3bddcf5d28e432 # - 1130942888122163587459546886933897963
03c21b1170a4b8a333e728eefb88c25273aec8b50cbf27acfc1a928bbc4e98a952 # + 1130942888122163587459546886933897963
03b0852769c61bc92ebb4b8e0325189803a7672d7aff8138fcaf7e0912fb6db83b # - 1233755877951451186319505694836979596
02f310ca33b5051d5dc5e5dc100b71f34da626fbc3671c67d761aca0d374c5d86e # + 1233755877951451186319505694836979596
0292b9a4a62c9b11c2b74f5a112c3ae6f8205a812e50e1a998b72a3572206b2e60 # - 1336568867780738785179464502740061229
027b0134c41fde6e6c3e14c112694f6d15a6a26bada9927b75c610f2faca8d0c1f # + 1336568867780738785179464502740061229
0283cd0f56a1f1444437bb9bb527e6e23fd187f39a46cf5baae15635204d0bce0b # - 1439381857610026384039423310643142862
027397a1cb67d2cf66acdb0bef63165ead8a650c283be065e9c9ae71d56e310a69 # + 1439381857610026384039423310643142862
021118f300af0fe59577e4ecefdc11f36d5cb910413d264726a767fd21a15dee1c # - 1542194847439313982899382118546224495
036e91521a16fc5d0cb95a0514fefa337e31493bc33fb3ebc660f8f8c6be6d1f56 # + 1542194847439313982899382118546224495
0385cd34fbe923f770a51febd5c7c3249727a049859bc6581ca53c997f76052709 # - 1645007837268601581759340926449306128
0293039b4f98a31cd72f5506fccdd5df34ab36995ea061b1fb8dcea66638e5041e # + 1645007837268601581759340926449306128
0265119a9e94a135bae5e03ad6f41da5d7d7cc5873448ffc7b2f2304b520dbe133 # target


Lets take any value example:
Code:
027bbdee3e1afa5c3e5e6d1a3e700f10214ea76a1261cf8f673de866c1b8e52ffb # + 925316908463588389739629271127734697

Now using modmath or keymath:

Code:
albertobsd:~/ecctools$ ./modmath 0x8F39E9339CB57B4FD233864AC7E50481DCFD8725979E79B487494451A6DE5B44 - 925316908463588389739629271127734697
Result: 8f39e9339cb57b4fd233864ac7e50481dc4b51803f71e3f9adcdb7dba25da19b

albertobsd:~/ecctools$ ./keymath 0265119A9E94A135BAE5E03AD6F41DA5D7D7CC5873448FFC7B2F2304B520DBE133 - 925316908463588389739629271127734697
Result: 027bbdee3e1afa5c3e5e6d1a3e700f10214ea76a1261cf8f673de866c1b8e52ffb

albertobsd:~/ecctools$ ./calculatefromkey 8f39e9339cb57b4fd233864ac7e50481dc4b51803f71e3f9adcdb7dba25da19b
privatekey: 8f39e9339cb57b4fd233864ac7e50481dc4b51803f71e3f9adcdb7dba25da19b
publickey compressed: 027bbdee3e1afa5c3e5e6d1a3e700f10214ea76a1261cf8f673de866c1b8e52ffb
public address compressed 1EDReX9xUxmnw35ZVEfCmikok1199Gz7KV
publickey uncompressed: 047bbdee3e1afa5c3e5e6d1a3e700f10214ea76a1261cf8f673de866c1b8e52ffbe49c0a8ba939325f0e6d285157c2ac47d2100d762ed44fc5645bd13d64bd1956
public address uncompressed 17eTsTDrMWC9Tgz8LzrHPmzUDAHomdDcnv

So in general if your substracted key is:
Code:
PublickKEY # + Something

the Target key is

Code:
Target = PublickKey - something

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

Hava a nice day
newbie
Activity: 2
Merit: 0
                                                                                                      8F39E9339CB57B4FD233864AC7E50481DCFD8725979E79B487494451A6DE5B44
 + 1645007837268601581759340926449306128 ====>                   +                                                         13CD125F2165F8510DBA46008014A10
                                                                                                      __________________________________________________________________
                                                                                                     8F39E9339CB57B4FD233864AC7E50481DE3A584B89B4D9399824E8B1AEDFA554 


but subtrac gave us this


8f39e9339cb57b4fd233864ac7e50481de3a584b89b4d9399824e8b1aedfa54d        036e531664a1356caf0e253a3c1cd6f46724358cbcc07892c6a34f94769f9554fa
newbie
Activity: 2
Merit: 0
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
newbie
Activity: 39
Merit: 0
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 Grin Great program btw
hero member
Activity: 862
Merit: 662
...   then on Kangaroo what range should I use ? The range for 135 bits key or the range for 90 bits ?

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
Code:
Subtracted key 5
Subtracted key 4
Subtracted key 3
Subtracted key 2
Subtracted key 1
Target key
Subtracted key -1
Subtracted key -2
Subtracted key -3
Subtracted key -4
Subtracted key -5

All those subtracted keys are near the target key and limited by the range that you select -r  or -b
newbie
Activity: 39
Merit: 0
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?
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.

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 ?
newbie
Activity: 6
Merit: 0
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.



full member
Activity: 1162
Merit: 237
Shooters Shoot...

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.


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

Quote
"Not sure how running a second or third time will help"

It helps if one wants more than 2^32 generated keys, not sure how else to explain it.
newbie
Activity: 6
Merit: 0

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.


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.
full member
Activity: 1162
Merit: 237
Shooters Shoot...
Is 'n' 32bit limited?

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



The number of pubs that can be generated?

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.
newbie
Activity: 6
Merit: 0
Is 'n' 32bit limited?

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



The number of pubs that can be generated?
full member
Activity: 1162
Merit: 237
Shooters Shoot...
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



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?
newbie
Activity: 6
Merit: 0
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

full member
Activity: 1162
Merit: 237
Shooters Shoot...
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!
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.

member
Activity: 43
Merit: 10
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!
member
Activity: 194
Merit: 14
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!
copper member
Activity: 1330
Merit: 899
🖤😏
Thanks for answer.

I am not doing that special thing, just some testing with pzzle 125 Smiley
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.

member
Activity: 194
Merit: 14
Thanks for answer.

I am not doing that special thing, just some testing with pzzle 125 Smiley
copper member
Activity: 1330
Merit: 899
🖤😏
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  Grin

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
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.
member
Activity: 194
Merit: 14
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  Grin

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
member
Activity: 194
Merit: 14
They are desktop developers. I assume noone here are Android developers.
copper member
Activity: 1330
Merit: 899
🖤😏
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?
hero member
Activity: 862
Merit: 662
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?

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

Code:
+Key M
+Key ...
+Key 3
+Key 2
+Key 1
Target
-Key 1
-Key 2
-Key 3
-Key ...
-Key M

That is why N should be Even:

Code:
M = N /2

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

Code:
./keysubtracter -p 02ceb6cbbcdbdf5ef7150682150f4ce2c6f4807b349827dcdbdd1f2efa885a2630 -n 10 -r 0:19
02231c58426010a60de22090bf73cc0ea14f1040273d5be74bc425cf7a82bb9c00 # - 5
033cdd67ebf89b79c953c8ca9b248a859aff02ebd69a4f17a850fa037cde0723b2 # + 5
023e40191ed19ba1c82d3948ffad7d11efc7352e8a071b09750fc0a62cba295f15 # - 10
02ad82cfd538d8f9a98ea7d2393a958962d3dd783456284353084ad74e459ca98c # + 10
02fca272f04368cc4e00cf283e075f1e6cace4754a4319c34258867f73c479f883 # - 15
0210bc32a1bcb978121653cfb6eba088969c3a7271cef1000e355da9785c74cf57 # + 15
029649575661e11d5c7c277d008c7a6d6a56c14824e31673a5a49809f94777858e # - 20
02a1c7e1fffa740388689234491047208e0f7c23a9bee61b61ef035a6d016a709c # + 20
020cbbd8790c965eab7f5ea396fe65e1ca3eb2e41febcc1a372159277adb8f8dd6 # - 25
033d21a2c11b8b32afeac80d3f1b391d98b388dd4ab78ca3926571114d7cc28ad8 # + 25
02ceb6cbbcdbdf5ef7150682150f4ce2c6f4807b349827dcdbdd1f2efa885a2630 # target

Odd numbers every ending 5

Range 15 (F Hex) divided bewteen 10

Code:
./keysubtracter -p 02ceb6cbbcdbdf5ef7150682150f4ce2c6f4807b349827dcdbdd1f2efa885a2630 -n 10 -r 0:F
0379c92f7fca55ac0710de44e86e31cf50742e63206af99e19d69a2fb9a179b82e # - 3
035738dc2e02ce16ab3d169ecd252154c763e5c9daaa8497ac3f0b8636ced8e6bd # + 3
02c88af07db06461a231177c827e43c8fe3d8aa5a19ba067b76d5ef41c8a29e4e0 # - 6
03b7d0c69eb53fa7008224d802e6bc2e56e9e11d00c575b91a9bde5f44556d3469 # + 6
03f3d29f5ec05cff300fc951e6e85b4707998473707d0a3e27f3ec0b3f5aab41e6 # - 9
03bc31bb00836f096f24cf8b8382e68011e71081919360dace116701074aa64684 # + 9
03d132cb27b0d70ee54c853eb4373b993847dca55ee66a1bb6f5b95a63db7eed8e # - 12
02e3ebf6a1ebf608fd9c70127d4f1f9da9adba02a3a3f1dee38d6396d2f0ac3aa4 # + 12
02fca272f04368cc4e00cf283e075f1e6cace4754a4319c34258867f73c479f883 # - 15
0210bc32a1bcb978121653cfb6eba088969c3a7271cef1000e355da9785c74cf57 # + 15
02ceb6cbbcdbdf5ef7150682150f4ce2c6f4807b349827dcdbdd1f2efa885a2630 # target

Odd numbers 3,9,15

I hope this examples help you
copper member
Activity: 1330
Merit: 899
🖤😏
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?
jr. member
Activity: 50
Merit: 1
./keysubtracter -p 02ceb6cbbcdbdf5ef7150682150f4ce2c6f4807b349827dcdbdd1f2efa885a2630-n 100 -b 120

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

Code:
03f1d41da8acf0506f3bf7140b5629dd33a5cf546133479530cd8065e335a97666 # - 13292279957849158729038070602803446
02000000000000000000000000000000000000000000000000000000000000000 # + 13292279957849158729038070602803446
02b70ae2dcb442548570313f652b91ca093a3acac3a2441cb64614e8195505b6b8 # - 26584559915698317458076141205606892
0367dabeef20a6a8b7b5555b162cc8c8489e3134dcec624fe028573c34dbbf20f6 # + 26584559915698317458076141205606892
02a1d21298779f888cd8169f9ed59e4383219cdadbdb342ba886034ef9013b89be # - 39876839873547476187114211808410338
02ae015703cbaee9570dc648d7bce78ac7cb438630e09d69eef4f1208655e1027d # + 39876839873547476187114211808410338

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



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





hero member
Activity: 862
Merit: 662
./keysubtracter -p 02ceb6cbbcdbdf5ef7150682150f4ce2c6f4807b349827dcdbdd1f2efa885a2630-n 100 -b 120

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.
copper member
Activity: 1330
Merit: 899
🖤😏
./keysubtracter -p 02ceb6cbbcdbdf5ef7150682150f4ce2c6f4807b349827dcdbdd1f2efa885a2630-n 100 -b 120

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

Code:
03f1d41da8acf0506f3bf7140b5629dd33a5cf546133479530cd8065e335a97666 # - 13292279957849158729038070602803446
02000000000000000000000000000000000000000000000000000000000000000 # + 13292279957849158729038070602803446
02b70ae2dcb442548570313f652b91ca093a3acac3a2441cb64614e8195505b6b8 # - 26584559915698317458076141205606892
0367dabeef20a6a8b7b5555b162cc8c8489e3134dcec624fe028573c34dbbf20f6 # + 26584559915698317458076141205606892
02a1d21298779f888cd8169f9ed59e4383219cdadbdb342ba886034ef9013b89be # - 39876839873547476187114211808410338
02ae015703cbaee9570dc648d7bce78ac7cb438630e09d69eef4f1208655e1027d # + 39876839873547476187114211808410338

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.😅
full member
Activity: 1162
Merit: 237
Shooters Shoot...
My man, * you 100 percent understand lol.
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.😅
When you can explain and show examples better, maybe it will be easier to understand what you are saying.

Your exact words:
Quote
0200000 # target

The #target is the supplied key.

I did not develop this tool, albert0 did.
copper member
Activity: 1330
Merit: 899
🖤😏
My man, * you 100 percent understand lol.
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.😅
full member
Activity: 1162
Merit: 237
Shooters Shoot...
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?
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.
copper member
Activity: 1330
Merit: 899
🖤😏
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?
copper member
Activity: 1330
Merit: 899
🖤😏
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.😅
full member
Activity: 1162
Merit: 237
Shooters Shoot...
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?
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.

copper member
Activity: 1330
Merit: 899
🖤😏
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?
full member
Activity: 1162
Merit: 237
Shooters Shoot...
@Op, in the output file I have several #targets, is that what we are looking for? How do I derive the private key now?
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.
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?
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?
copper member
Activity: 1330
Merit: 899
🖤😏
@Op, in the output file I have several #targets, is that what we are looking for? How do I derive the private key now?
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.
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?
full member
Activity: 1162
Merit: 237
Shooters Shoot...
@Op, in the output file I have several #targets, is that what we are looking for? How do I derive the private key now?
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.
copper member
Activity: 1330
Merit: 899
🖤😏
@Op, in the output file I have several #targets, is that what we are looking for? How do I derive the private key now?
hero member
Activity: 862
Merit: 662
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>>>>> ?

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.
jr. member
Activity: 50
Merit: 1
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>>>>> ?
newbie
Activity: 29
Merit: 0
Is 'n' 32bit limited?

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


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
hero member
Activity: 862
Merit: 662
Is 'n' 32bit limited?

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

newbie
Activity: 29
Merit: 0
Is 'n' 32bit limited?
full member
Activity: 1162
Merit: 237
Shooters Shoot...
Quote
could you give me an example command line for puzzle #125

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:

Code:
WindowsKeySubtractorV2.2 -p 0233709eb11e0d4439a729f21c2c443dedb727528229713f0065721ba8fa46f00e -s -n 1000 -r 1:fffff -o 125OffsetKeys.txt
pause

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

Code:
WindowsKeySubtractorV2.2 -p 0233709eb11e0d4439a729f21c2c443dedb727528229713f0065721ba8fa46f00e -z -s -n 1000 -r 1:fffff -o 125OffsetKeys.txt
pause

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



copper member
Activity: 1330
Merit: 899
🖤😏
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.
full member
Activity: 1162
Merit: 237
Shooters Shoot...
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

full member
Activity: 1162
Merit: 237
Shooters Shoot...
@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.

By same error, do you mean error message "collect2: error: ld returned 1 exit status"? I tried compiling this tool on newly installed Debian 11 and got similar error. My gcc version is gcc version 10.2.1 20210110 (Debian 10.2.1-6).

Code:
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/ccwgKfYZ.o:(.bss+0x0): first defined here
/usr/bin/ld: gmpecc.o:(.bss+0x0): multiple definition of `DoublingG'; /tmp/ccwgKfYZ.o:(.bss+0x40): first defined here
/usr/bin/ld: gmpecc.o:(.bss+0x2000): multiple definition of `G'; /tmp/ccwgKfYZ.o:(.bss+0x20): first defined here
collect2: error: ld returned 1 exit status
make: *** [Makefile:7: default] Error 1


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...
Code:

#include
//#include "gmpecc.h"


void Point_Doubling(struct Point *P, struct Point *R) {
mpz_t slope, temp;
mpz_init(temp);
mpz_init(slope);
if(mpz_cmp_ui(P->y, 0) != 0) {
mpz_mul_ui(temp, P->y, 2);
mpz_invert(temp, temp, EC.p);
mpz_mul(slope, P->x, P->x);
mpz_mul_ui(slope, slope, 3);
mpz_mul(slope, slope, temp);
mpz_mod(slope, slope, EC.p);
mpz_mul(R->x, slope, slope);
mpz_sub(R->x, R->x, P->x);
mpz_sub(R->x, R->x, P->x);
mpz_mod(R->x, R->x, EC.p);
mpz_sub(temp, P->x, R->x);
mpz_mul(R->y, slope, temp);
mpz_sub(R->y, R->y, P->y);
mpz_mod(R->y, R->y, EC.p);
} else {
mpz_set_ui(R->x, 0);
mpz_set_ui(R->y, 0);
}
mpz_clear(temp);
mpz_clear(slope);
}

void Point_Addition(struct Point *P, struct Point *Q, struct Point *R) {
mpz_t PA_temp,PA_slope;
mpz_init(PA_temp);
mpz_init(PA_slope);
if(mpz_cmp_ui(P->x, 0) == 0 && mpz_cmp_ui(P->y, 0) == 0) {
mpz_set(R->x, Q->x);
mpz_set(R->y, Q->y);
}
else {
if(mpz_cmp_ui(Q->x, 0) == 0 && mpz_cmp_ui(Q->y, 0) == 0) {
mpz_set(R->x, P->x);
mpz_set(R->y, P->y);
}
else {
if(mpz_cmp_ui(Q->y, 0) != 0) {
mpz_sub(PA_temp, EC.p, Q->y);
mpz_mod(PA_temp, PA_temp, EC.p);
}
else {
mpz_set_ui(PA_temp, 0);
}
if(mpz_cmp(P->y, PA_temp) == 0 && mpz_cmp(P->x, Q->x) == 0) {
mpz_set_ui(R->x, 0);
mpz_set_ui(R->y, 0);
}
else {
if(mpz_cmp(P->x, Q->x) == 0 && mpz_cmp(P->y, Q->y) == 0) {
Point_Doubling(P, R);
}
else {
mpz_set_ui(PA_slope, 0);
mpz_sub(PA_temp, P->x, Q->x); //dx = B.x - A.x
mpz_mod(PA_temp, PA_temp, EC.p); ///dx = dx % p
mpz_invert(PA_temp, PA_temp, EC.p); //gmpy2.invert(dx, p) % p
mpz_sub(PA_slope, P->y, Q->y);
mpz_mul(PA_slope, PA_slope, PA_temp);
mpz_mod(PA_slope, PA_slope, EC.p);
mpz_mul(R->x, PA_slope, PA_slope); //c*c
mpz_sub(R->x, R->x, P->x); // c*c - A.x
mpz_sub(R->x, R->x, Q->x); //(c*c - A.x) - B.x
mpz_mod(R->x, R->x, EC.p); // Rx % p
mpz_sub(PA_temp, P->x, R->x);
mpz_mul(R->y, PA_slope, PA_temp);
mpz_sub(R->y, R->y, P->y);
mpz_mod(R->y, R->y, EC.p);
}
}
}
}
mpz_clear(PA_temp);
mpz_clear(PA_slope);
}

void Scalar_Multiplication(struct Point P, struct Point *R, mpz_t m) {
struct Point SM_T,SM_Q;
int no_of_bits, i;
no_of_bits = mpz_sizeinbase(m, 2);
mpz_init_set_ui(SM_Q.x,0);
mpz_init_set_ui(SM_Q.y,0);
mpz_init_set_ui(SM_T.x,0);
mpz_init_set_ui(SM_T.y,0);
mpz_set_ui(R->x, 0);
mpz_set_ui(R->y, 0);
if(mpz_cmp_ui(m, 0) != 0) {
mpz_set(SM_Q.x, P.x);
mpz_set(SM_Q.y, P.y);
for(i = 0; i < no_of_bits; i++) {
if(mpz_tstbit(m, i)) {
mpz_set(SM_T.x, R->x);
mpz_set(SM_T.y, R->y);
mpz_set(SM_Q.x,DoublingG[i].x);
mpz_set(SM_Q.y,DoublingG[i].y);
Point_Addition(&SM_T, &SM_Q, R);
}
}
}
mpz_clear(SM_T.x);
mpz_clear(SM_T.y);
mpz_clear(SM_Q.x);
mpz_clear(SM_Q.y);
}

void Point_Negation(struct Point *A, struct Point *S) {
mpz_sub(S->y, EC.p, A->y);
mpz_set(S->x, A->x);
}

/*
Precalculate G Doublings for Scalar_Multiplication
*/
void init_doublingG(struct Point *P) {
int i = 0;
mpz_init(DoublingG[i].x);
mpz_init(DoublingG[i].y);
mpz_set(DoublingG[i].x,P->x);
mpz_set(DoublingG[i].y,P->y);
i = 1;
while(i < 256){
mpz_init(DoublingG[i].x);
mpz_init(DoublingG[i].y);
Point_Doubling(&DoublingG[i-1] ,&DoublingG[i]);
mpz_mod(DoublingG[i].x, DoublingG[i].x, EC.p);
mpz_mod(DoublingG[i].y, DoublingG[i].y, EC.p);
i++;
}
}

and place it all in keysubtracter.c after :
Code:
mpz_t min_range,max_range,diff,TWO,base_key,sum_key,dst_key;
gmp_randstate_t state;

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.
full member
Activity: 1162
Merit: 237
Shooters Shoot...
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!
copper member
Activity: 1330
Merit: 899
🖤😏
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?
newbie
Activity: 5
Merit: 0
@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.

By same error, do you mean error message "collect2: error: ld returned 1 exit status"? I tried compiling this tool on newly installed Debian 11 and got similar error. My gcc version is gcc version 10.2.1 20210110 (Debian 10.2.1-6).

Code:
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/ccwgKfYZ.o:(.bss+0x0): first defined here
/usr/bin/ld: gmpecc.o:(.bss+0x0): multiple definition of `DoublingG'; /tmp/ccwgKfYZ.o:(.bss+0x40): first defined here
/usr/bin/ld: gmpecc.o:(.bss+0x2000): multiple definition of `G'; /tmp/ccwgKfYZ.o:(.bss+0x20): first defined here
collect2: error: ld returned 1 exit status
make: *** [Makefile:7: default] Error 1




@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.
newbie
Activity: 1
Merit: 0
 @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.
hero member
Activity: 862
Merit: 662
What version of Ubuntu do you have?

Code:
uname -a

What version of gcc do you have?

Code:
gcc -v
newbie
Activity: 1
Merit: 0
Quote
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/ccmArVbb.o:(.bss+0x0): first defined here
/usr/bin/ld: gmpecc.o:(.bss+0x0): multiple definition of `DoublingG'; /tmp/ccmArVbb.o:(.bss+0x40): first defined here
/usr/bin/ld: gmpecc.o:(.bss+0x2000): multiple definition of `G'; /tmp/ccmArVbb.o:(.bss+0x20): first defined here
collect2: error: ld returned 1 exit status
make: *** [Makefile:7: default] Error 1

Hello everyone,
i can't build this on windows ubuntu shell
member
Activity: 406
Merit: 47

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)
hero member
Activity: 862
Merit: 662
please write easy understand make python or explain mathematicaly

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!

jr. member
Activity: 70
Merit: 1
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
full member
Activity: 1162
Merit: 237
Shooters Shoot...
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.
full member
Activity: 1162
Merit: 237
Shooters Shoot...
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
full member
Activity: 1162
Merit: 237
Shooters Shoot...
I also used "make" command for KeyHunt and it compiled and worked perfectly.

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

Code:
#pragma once

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

This did not work...I will work on it more later today. Thanks for responding!
hero member
Activity: 862
Merit: 662
I also used "make" command for KeyHunt and it compiled and worked perfectly.

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

Code:
#pragma once

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
full member
Activity: 1162
Merit: 237
Shooters Shoot...
Quote
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

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!
full member
Activity: 1162
Merit: 237
Shooters Shoot...
Quote
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?
Yes, I am using the "make" command in Mingw64.

I also used "make" command for KeyHunt and it compiled and worked perfectly.
hero member
Activity: 862
Merit: 662

How many bits does it subtract it by?

Code:
03f1d41da8acf0506f3bf7140b5629dd33a5cf546133479530cd8065e335a97666 # - 13292279957849158729038070602803446
022ec3a210bcb8ef6cf7b703b39539a83dc0c1318ccdb42daf48db2f0742971239 # + 13292279957849158729038070602803446
02b70ae2dcb442548570313f652b91ca093a3acac3a2441cb64614e8195505b6b8 # - 26584559915698317458076141205606892
0367dabeef20a6a8b7b5555b162cc8c8489e3134dcec624fe028573c34dbbf20f6 # + 26584559915698317458076141205606892
02a1d21298779f888cd8169f9ed59e4383219cdadbdb342ba886034ef9013b89be # - 39876839873547476187114211808410338
02ae015703cbaee9570dc648d7bce78ac7cb438630e09d69eef4f1208655e1027d # + 39876839873547476187114211808410338
(Output omitted)

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

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.

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


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

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?
full member
Activity: 1162
Merit: 237
Shooters Shoot...
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.



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.
full member
Activity: 1162
Merit: 237
Shooters Shoot...
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:

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

Output
Code:
03f1d41da8acf0506f3bf7140b5629dd33a5cf546133479530cd8065e335a97666 # - 13292279957849158729038070602803446
022ec3a210bcb8ef6cf7b703b39539a83dc0c1318ccdb42daf48db2f0742971239 # + 13292279957849158729038070602803446
02b70ae2dcb442548570313f652b91ca093a3acac3a2441cb64614e8195505b6b8 # - 26584559915698317458076141205606892
0367dabeef20a6a8b7b5555b162cc8c8489e3134dcec624fe028573c34dbbf20f6 # + 26584559915698317458076141205606892
02a1d21298779f888cd8169f9ed59e4383219cdadbdb342ba886034ef9013b89be # - 39876839873547476187114211808410338
02ae015703cbaee9570dc648d7bce78ac7cb438630e09d69eef4f1208655e1027d # + 39876839873547476187114211808410338
(Output omitted)

but what that mean:

Code:
./keysubtracter -p  -n  -b  

Output:
Code:
New Publickey 1 # offset from original publickey
New Publickey 2 # offset from original publickey
...


How many bits does it subtract it by?
It will subtract by however many bits you tell it to.
In his example:
Code:
./keysubtracter -p 02ceb6cbbcdbdf5ef7150682150f4ce2c6f4807b349827dcdbdd1f2efa885a2630 -n 100 -b 120
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
full member
Activity: 1162
Merit: 237
Shooters Shoot...
I have built the KeyHunt for Windows using Mingw64 -make, but I receive this error when trying to use the make for keysubtracter:

Code:
C:/msys64/mingw64/bin/../lib/gcc/x86_64-w64-mingw32/10.3.0/../../../../x86_64-w64-mingw32/bin/ld.exe: gmpecc.o:gmpecc.c:(.bss+0x2000): multiple definition of `G'; C:\msys64\tmp\ccQTx1CF.o:keysubtracter.:(.bss+0x20): first defined here
collect2.exe: error: ld returned 1 exit status
make: *** [Makefile:7: default] Error 1

I know you mainly build for Linux but wasn't sure if this was something you have seen/experienced before.
jr. member
Activity: 31
Merit: 5
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.


full member
Activity: 706
Merit: 111
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:

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

Output
Code:
03f1d41da8acf0506f3bf7140b5629dd33a5cf546133479530cd8065e335a97666 # - 13292279957849158729038070602803446
022ec3a210bcb8ef6cf7b703b39539a83dc0c1318ccdb42daf48db2f0742971239 # + 13292279957849158729038070602803446
02b70ae2dcb442548570313f652b91ca093a3acac3a2441cb64614e8195505b6b8 # - 26584559915698317458076141205606892
0367dabeef20a6a8b7b5555b162cc8c8489e3134dcec624fe028573c34dbbf20f6 # + 26584559915698317458076141205606892
02a1d21298779f888cd8169f9ed59e4383219cdadbdb342ba886034ef9013b89be # - 39876839873547476187114211808410338
02ae015703cbaee9570dc648d7bce78ac7cb438630e09d69eef4f1208655e1027d # + 39876839873547476187114211808410338
(Output omitted)

but what that mean:

Code:
./keysubtracter -p  -n  -b  

Output:
Code:
New Publickey 1 # offset from original publickey
New Publickey 2 # offset from original publickey
...


How many bits does it subtract it by?
jr. member
Activity: 38
Merit: 13
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.
hero member
Activity: 862
Merit: 662
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:

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

Output
Code:
03f1d41da8acf0506f3bf7140b5629dd33a5cf546133479530cd8065e335a97666 # - 13292279957849158729038070602803446
022ec3a210bcb8ef6cf7b703b39539a83dc0c1318ccdb42daf48db2f0742971239 # + 13292279957849158729038070602803446
02b70ae2dcb442548570313f652b91ca093a3acac3a2441cb64614e8195505b6b8 # - 26584559915698317458076141205606892
0367dabeef20a6a8b7b5555b162cc8c8489e3134dcec624fe028573c34dbbf20f6 # + 26584559915698317458076141205606892
02a1d21298779f888cd8169f9ed59e4383219cdadbdb342ba886034ef9013b89be # - 39876839873547476187114211808410338
02ae015703cbaee9570dc648d7bce78ac7cb438630e09d69eef4f1208655e1027d # + 39876839873547476187114211808410338
(Output omitted)

but what that mean:

Code:
./keysubtracter -p  -n  -b  

Output:
Code:
New Publickey 1 # offset from original publickey
New Publickey 2 # offset from original publickey
...

Windows version thanks to WanderingPhilospher

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