Search content
Sort by
Showing 15 of 15 results by hskun
One more piece of science! 
Everybody knows that when we calculate "NextPoint = PreviousPoint + JumpPoint", we can also quickly calculate "PreviousPoint - JumpPoint" because the inversion is the same.
Therefore, if the inversion calculation takes a lot of time, this second point is cheap for us, and we can use it to improve K.
I updated Part #1: Added "SOTA+" method with K = 1.02.
Everybody knows that when we calculate "NextPoint = PreviousPoint + JumpPoint", we can also quickly calculate "PreviousPoint - JumpPoint" because the inversion is the same.
Therefore, if the inversion calculation takes a lot of time, this second point is cheap for us, and we can use it to improve K.
I updated Part #1: Added "SOTA+" method with K = 1.02.
I still study your code, especially the gpu part, which gives me a lot to learn.
I think JLP applied this trick in his BSGS/kangaroo.
https://github.com/JeanLucPons/BSGS/blob/master/BSGS.cpp#L347
Yes, he did it for BSGS, and now I’ve figured out how to apply it to Kangaroo.
I took a closer look at JLP's code, and kangaroo's code does not have this.
This PreviousPoint - JumpPoint jump is equivalent to PreviousPoint jumping JumpPoint backwards.
One more piece of science!
Everybody knows that when we calculate "NextPoint = PreviousPoint + JumpPoint", we can also quickly calculate "PreviousPoint - JumpPoint" because the inversion is the same.
Therefore, if the inversion calculation takes a lot of time, this second point is cheap for us, and we can use it to improve K.
I updated Part #1: Added "SOTA+" method with K = 1.02.
Everybody knows that when we calculate "NextPoint = PreviousPoint + JumpPoint", we can also quickly calculate "PreviousPoint - JumpPoint" because the inversion is the same.
Therefore, if the inversion calculation takes a lot of time, this second point is cheap for us, and we can use it to improve K.
I updated Part #1: Added "SOTA+" method with K = 1.02.
I think JLP has already applied this trick in his BSGS/kangaroo.
https://github.com/JeanLucPons/BSGS/blob/master/BSGS.cpp#L347
Code:
...
// We use the fact that P + i*G and P - i*G has the same deltax, so the same inverse
// We compute key in the positive and negative way from the center of the group
// center point
pts[CPU_GRP_SIZE / 2] = startP;
for(i = 0; i<hLength; i++) {
pp = startP;
pn = startP;
// P = startP + i*G
dy.ModSub(&GSn[i].y,&pp.y);
_s.ModMulK1(&dy,&dx[i]); // s = (p2.y-p1.y)*inverse(p2.x-p1.x);
_p.ModSquareK1(&_s); // _p = pow2(s)
pp.x.ModNeg();
pp.x.ModAdd(&_p);
pp.x.ModSub(&GSn[i].x); // rx = pow2(s) - p1.x - p2.x;
#if 0
pp.y.ModSub(&GSn[i].x,&pp.x);
pp.y.ModMulK1(&_s);
pp.y.ModSub(&GSn[i].y); // ry = - p2.y - s*(ret.x-p2.x);
#endif
// P = startP - i*G , if (x,y) = i*G then (x,-y) = -i*G
dyn.Set(&GSn[i].y);
dyn.ModNeg();
dyn.ModSub(&pn.y);
_s.ModMulK1(&dyn,&dx[i]); // s = (p2.y-p1.y)*inverse(p2.x-p1.x);
_p.ModSquareK1(&_s); // _p = pow2(s)
pn.x.ModNeg();
pn.x.ModAdd(&_p);
pn.x.ModSub(&GSn[i].x); // rx = pow2(s) - p1.x - p2.x;
#if 0
pn.y.ModSub(&GSn[i].x,&pn.x);
pn.y.ModMulK1(&_s);
pn.y.ModAdd(&GSn[i].y); // ry = - p2.y - s*(ret.x-p2.x);
#endif
pts[CPU_GRP_SIZE / 2 + (i + 1)] = pp;
pts[CPU_GRP_SIZE / 2 - (i + 1)] = pn;
}
// First point (startP - (GRP_SZIE/2)*G)
pn = startP;
dyn.Set(&GSn[i].y);
dyn.ModNeg();
dyn.ModSub(&pn.y);
_s.ModMulK1(&dyn,&dx[i]);
_p.ModSquareK1(&_s);
pn.x.ModNeg();
pn.x.ModAdd(&_p);
pn.x.ModSub(&GSn[i].x);
#if 0
pn.y.ModSub(&GSn[i].x,&pn.x);
pn.y.ModMulK1(&_s);
pn.y.ModAdd(&GSn[i].y);
#endif
pts[0] = pn;
...
// We use the fact that P + i*G and P - i*G has the same deltax, so the same inverse
// We compute key in the positive and negative way from the center of the group
// center point
pts[CPU_GRP_SIZE / 2] = startP;
for(i = 0; i<hLength; i++) {
pp = startP;
pn = startP;
// P = startP + i*G
dy.ModSub(&GSn[i].y,&pp.y);
_s.ModMulK1(&dy,&dx[i]); // s = (p2.y-p1.y)*inverse(p2.x-p1.x);
_p.ModSquareK1(&_s); // _p = pow2(s)
pp.x.ModNeg();
pp.x.ModAdd(&_p);
pp.x.ModSub(&GSn[i].x); // rx = pow2(s) - p1.x - p2.x;
#if 0
pp.y.ModSub(&GSn[i].x,&pp.x);
pp.y.ModMulK1(&_s);
pp.y.ModSub(&GSn[i].y); // ry = - p2.y - s*(ret.x-p2.x);
#endif
// P = startP - i*G , if (x,y) = i*G then (x,-y) = -i*G
dyn.Set(&GSn[i].y);
dyn.ModNeg();
dyn.ModSub(&pn.y);
_s.ModMulK1(&dyn,&dx[i]); // s = (p2.y-p1.y)*inverse(p2.x-p1.x);
_p.ModSquareK1(&_s); // _p = pow2(s)
pn.x.ModNeg();
pn.x.ModAdd(&_p);
pn.x.ModSub(&GSn[i].x); // rx = pow2(s) - p1.x - p2.x;
#if 0
pn.y.ModSub(&GSn[i].x,&pn.x);
pn.y.ModMulK1(&_s);
pn.y.ModAdd(&GSn[i].y); // ry = - p2.y - s*(ret.x-p2.x);
#endif
pts[CPU_GRP_SIZE / 2 + (i + 1)] = pp;
pts[CPU_GRP_SIZE / 2 - (i + 1)] = pn;
}
// First point (startP - (GRP_SZIE/2)*G)
pn = startP;
dyn.Set(&GSn[i].y);
dyn.ModNeg();
dyn.ModSub(&pn.y);
_s.ModMulK1(&dyn,&dx[i]);
_p.ModSquareK1(&_s);
pn.x.ModNeg();
pn.x.ModAdd(&_p);
pn.x.ModSub(&GSn[i].x);
#if 0
pn.y.ModSub(&GSn[i].x,&pn.x);
pn.y.ModMulK1(&_s);
pn.y.ModAdd(&GSn[i].y);
#endif
pts[0] = pn;
...
LLE. Damn, you made me go back to the drawing board, just thinking on what you might have used to get to such speeds. For some of the things I came up with as explanation, there's literally just a couple of results on the entire web, but if those work as advertised, I may get a 3x speedup as well, just by freeing up a lot of registers that keep useless information. There's no other way I see, since I already got 100% compute throughput in the CUDA profiler but I'm nowhere near your speed. Great, now I also have a headache.
Don't work so hard, there is no reason for that
One more tip for you. As far as I remember there is one more problem in original JLP GPU code: every GPU thread processes A LOT of kangs. It will cause an issue with DPs for high-number puzzles like #130. It's obvious but it seems nobody understands it. Don't you see it too?
I remember that JLP kangaroo only support less than 125bit interval search as the output dist is only 32*4 bits?
I appreciate it for your great work!
It work fine for my A3000 and it more faster than JPL about 30%!
Will you work for the client/server version the next setp?
Thanks.
It work fine for my A3000 and it more faster than JPL about 30%!
Will you work for the client/server version the next setp?
Thanks.
Re: Searching (who am I kidding, crack) private keys using FPGA and mining chips
Also, are you only planning to use the ASIC chips to compute one SHA256?
I said earlier: the data must be prepared. For example, shifted by nonce (4-byte) and some other operations. The nonce should be loaded as well (is now a part of data). A golden nonce in Bitcoin mining is a nonce which results in a hash value lower than the target. What happens if the target == 0xFFFF....FF? 
Right: any result will be returned.There are several ways to generate keys. In some, you have to complete 100k SHA256 hashes (or 50k double hashes). This way allows to reduce the enumeration range, by the way.
Finally, which ASIC do you mean? There are many chips: https://en.bitcoin.it/wiki/List_of_Bitcoin_mining_ASICs
Only Bitmain has four actual chips right now. All chips are different, have different OCD paths, "some ASIC chip" does not exist.
I read the BM1385 datasheet, it seem just only return the nonce not the hash result .
Can you tell more detail about this part?
Thanks.
here is the reason for Rand() not to work:
in BSGS code the function rseed() in Random.cpp is never called
so, without seeding no harvest.....
in BSGS code the function rseed() in Random.cpp is never called
so, without seeding no harvest.....
yes, you can add the rseed()here:
.....
int main(int argc, char* argv[]) {
// Global Init
Timer::Init();
rseed(Timer::getSeed32());
.....
Hi WanderingPhilospher, thanks for test the program.
Keyhunt use a Bloom filter to check if the generated address or hash is on the list, this will lead in some false positive collision (Error rate is one in a million or something like that), so if the the bloom filter return a positive result, it use a second check, this is a binary search over all the address or items in the list, it can dertermine if one item is on the list perfoming only log(N)/log(2) operation, for 15 Milllions of addres this process only take 24 comparations.
This is like the hash table but i prefer keep those separated becuase there are some trick with the bloom filter that allow you use a little less ram in the case of the BSGS mode.
And no, in keyhunt there are no key drop or anything like that.
Yes you are totally right this will be changed soon.
Im working in some migration from libgmp to the secp256k1 library used in the JLP BSGS Code, i already check that librery and with some hardware and code tricks it can be 4 or 5 times more faster for publickey generations, this will boost all the modes speeds, address, rmd160, xpoint and bsgs mode in the code.
Best regards!
I can get 1 MKey/s with a list of 15 million addresses (i5-4690 running 4 threads). I am curious, does/will your Keyhunt program handle that many addresses and if so, does the Key/s drop?
Keyhunt use a Bloom filter to check if the generated address or hash is on the list, this will lead in some false positive collision (Error rate is one in a million or something like that), so if the the bloom filter return a positive result, it use a second check, this is a binary search over all the address or items in the list, it can dertermine if one item is on the list perfoming only log(N)/log(2) operation, for 15 Milllions of addres this process only take 24 comparations.
This is like the hash table but i prefer keep those separated becuase there are some trick with the bloom filter that allow you use a little less ram in the case of the BSGS mode.
And no, in keyhunt there are no key drop or anything like that.
why not read the input file of full addresses, convert them to RIPE, and then do the search on RIPE?
Yes you are totally right this will be changed soon.
Im working in some migration from libgmp to the secp256k1 library used in the JLP BSGS Code, i already check that librery and with some hardware and code tricks it can be 4 or 5 times more faster for publickey generations, this will boost all the modes speeds, address, rmd160, xpoint and bsgs mode in the code.
Best regards!
Hi albert0bsd,
have any progress about the program?
I think you can try xor filter, it's more faster.
https://github.com/FastFilter/xor_singleheader
https://github.com/FastFilter/xor_singleheader
Y+(-Y) = FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFC2F(MODULO)
There no know relationship between Y and -Y. Atleast for polynominal. Thats why im trying to use neural network to discover that,
Have any idea baout Y, -Y relationship?
privateKey="FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD036413B",
publicKey="02FFF97BD5755EEEA420453A14355235D382F6472F8568A18B2F057A1460297556"
X= FFF97BD5755EEEA420453A14355235D382F6472F8568A18B2F057A1460297556
Y= 51ED8885530449DF0C4169FE80BA3A9F217F0F09AE701B5FC378F3C84F8A0998
Y= AE12777AACFBB620F3BE96017F45C560DE80F0F6518FE4A03C870C36B075F297
privateKey="0000000000000000000000000000000000000000000000000000000000000006", publicKey="03FFF97BD5755EEEA420453A14355235D382F6472F8568A18B2F057A1460297556"
X= FFF97BD5755EEEA420453A14355235D382F6472F8568A18B2F057A1460297556
Y= 51ED8885530449DF0C4169FE80BA3A9F217F0F09AE701B5FC378F3C84F8A0998
Y= AE12777AACFBB620F3BE96017F45C560DE80F0F6518FE4A03C870C36B075F297
privateKey="FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD036413B",
publicKey="02FFF97BD5755EEEA420453A14355235D382F6472F8568A18B2F057A1460297556"
X= FFF97BD5755EEEA420453A14355235D382F6472F8568A18B2F057A1460297556
Y= 51ED8885530449DF0C4169FE80BA3A9F217F0F09AE701B5FC378F3C84F8A0998
Y= AE12777AACFBB620F3BE96017F45C560DE80F0F6518FE4A03C870C36B075F297
privateKey="0000000000000000000000000000000000000000000000000000000000000006", publicKey="03FFF97BD5755EEEA420453A14355235D382F6472F8568A18B2F057A1460297556"
X= FFF97BD5755EEEA420453A14355235D382F6472F8568A18B2F057A1460297556
Y= 51ED8885530449DF0C4169FE80BA3A9F217F0F09AE701B5FC378F3C84F8A0998
Y= AE12777AACFBB620F3BE96017F45C560DE80F0F6518FE4A03C870C36B075F297
As far as I know, it is exactly 50% of keys. For any public key you can negate it and switch it from 02 to 03 or from 03 to 02. It is totally symmetric, I cannot see a single example where it would be ambiguous or where more than a pair of keys could be produced in that way. You can see it simply by using G and -G and incrementing or decrementing points. You would see a pairs of private keys: (1;-1);(2;-2);(3;-3);... When dealing with private keys, you can simply subtract your private key from the maximum and get your negated private key. For public keys, you can switch between 02 and 03 prefix. That's all.
Code:
privateKey="FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD036413B", publicKey="02FFF97BD5755EEEA420453A14355235D382F6472F8568A18B2F057A1460297556"
privateKey="FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD036413C", publicKey="032F8BDE4D1A07209355B4A7250A5C5128E88B84BDDC619AB7CBA8D569B240EFE4"
privateKey="FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD036413D", publicKey="03E493DBF1C10D80F3581E4904930B1404CC6C13900EE0758474FA94ABE8C4CD13"
privateKey="FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD036413E", publicKey="03F9308A019258C31049344F85F89D5229B531C845836F99B08601F113BCE036F9"
privateKey="FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD036413F", publicKey="03C6047F9441ED7D6D3045406E95C07CD85C778E4B8CEF3CA7ABAC09B95C709EE5"
privateKey="FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364140", publicKey="0379BE667EF9DCBBAC55A06295CE870B07029BFCDB2DCE28D959F2815B16F81798"
privateKey="0000000000000000000000000000000000000000000000000000000000000001", publicKey="0279BE667EF9DCBBAC55A06295CE870B07029BFCDB2DCE28D959F2815B16F81798"
privateKey="0000000000000000000000000000000000000000000000000000000000000002", publicKey="02C6047F9441ED7D6D3045406E95C07CD85C778E4B8CEF3CA7ABAC09B95C709EE5"
privateKey="0000000000000000000000000000000000000000000000000000000000000003", publicKey="02F9308A019258C31049344F85F89D5229B531C845836F99B08601F113BCE036F9"
privateKey="0000000000000000000000000000000000000000000000000000000000000004", publicKey="02E493DBF1C10D80F3581E4904930B1404CC6C13900EE0758474FA94ABE8C4CD13"
privateKey="0000000000000000000000000000000000000000000000000000000000000005", publicKey="022F8BDE4D1A07209355B4A7250A5C5128E88B84BDDC619AB7CBA8D569B240EFE4"
privateKey="0000000000000000000000000000000000000000000000000000000000000006", publicKey="03FFF97BD5755EEEA420453A14355235D382F6472F8568A18B2F057A1460297556"
privateKey="FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD036413C", publicKey="032F8BDE4D1A07209355B4A7250A5C5128E88B84BDDC619AB7CBA8D569B240EFE4"
privateKey="FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD036413D", publicKey="03E493DBF1C10D80F3581E4904930B1404CC6C13900EE0758474FA94ABE8C4CD13"
privateKey="FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD036413E", publicKey="03F9308A019258C31049344F85F89D5229B531C845836F99B08601F113BCE036F9"
privateKey="FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD036413F", publicKey="03C6047F9441ED7D6D3045406E95C07CD85C778E4B8CEF3CA7ABAC09B95C709EE5"
privateKey="FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364140", publicKey="0379BE667EF9DCBBAC55A06295CE870B07029BFCDB2DCE28D959F2815B16F81798"
privateKey="0000000000000000000000000000000000000000000000000000000000000001", publicKey="0279BE667EF9DCBBAC55A06295CE870B07029BFCDB2DCE28D959F2815B16F81798"
privateKey="0000000000000000000000000000000000000000000000000000000000000002", publicKey="02C6047F9441ED7D6D3045406E95C07CD85C778E4B8CEF3CA7ABAC09B95C709EE5"
privateKey="0000000000000000000000000000000000000000000000000000000000000003", publicKey="02F9308A019258C31049344F85F89D5229B531C845836F99B08601F113BCE036F9"
privateKey="0000000000000000000000000000000000000000000000000000000000000004", publicKey="02E493DBF1C10D80F3581E4904930B1404CC6C13900EE0758474FA94ABE8C4CD13"
privateKey="0000000000000000000000000000000000000000000000000000000000000005", publicKey="022F8BDE4D1A07209355B4A7250A5C5128E88B84BDDC619AB7CBA8D569B240EFE4"
privateKey="0000000000000000000000000000000000000000000000000000000000000006", publicKey="03FFF97BD5755EEEA420453A14355235D382F6472F8568A18B2F057A1460297556"
There no know relationship between Y and -Y. Atleast for polynominal. Thats why im trying to use neural network to discover that,
Have any idea baout Y, -Y relationship?
privateKey="FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD036413B",
publicKey="02FFF97BD5755EEEA420453A14355235D382F6472F8568A18B2F057A1460297556"
X= FFF97BD5755EEEA420453A14355235D382F6472F8568A18B2F057A1460297556
Y= 51ED8885530449DF0C4169FE80BA3A9F217F0F09AE701B5FC378F3C84F8A0998
Y= AE12777AACFBB620F3BE96017F45C560DE80F0F6518FE4A03C870C36B075F297
privateKey="0000000000000000000000000000000000000000000000000000000000000006", publicKey="03FFF97BD5755EEEA420453A14355235D382F6472F8568A18B2F057A1460297556"
X= FFF97BD5755EEEA420453A14355235D382F6472F8568A18B2F057A1460297556
Y= 51ED8885530449DF0C4169FE80BA3A9F217F0F09AE701B5FC378F3C84F8A0998
Y= AE12777AACFBB620F3BE96017F45C560DE80F0F6518FE4A03C870C36B075F297
privateKey="FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD036413B",
publicKey="02FFF97BD5755EEEA420453A14355235D382F6472F8568A18B2F057A1460297556"
X= FFF97BD5755EEEA420453A14355235D382F6472F8568A18B2F057A1460297556
Y= 51ED8885530449DF0C4169FE80BA3A9F217F0F09AE701B5FC378F3C84F8A0998
Y= AE12777AACFBB620F3BE96017F45C560DE80F0F6518FE4A03C870C36B075F297
privateKey="0000000000000000000000000000000000000000000000000000000000000006", publicKey="03FFF97BD5755EEEA420453A14355235D382F6472F8568A18B2F057A1460297556"
X= FFF97BD5755EEEA420453A14355235D382F6472F8568A18B2F057A1460297556
Y= 51ED8885530449DF0C4169FE80BA3A9F217F0F09AE701B5FC378F3C84F8A0998
Y= AE12777AACFBB620F3BE96017F45C560DE80F0F6518FE4A03C870C36B075F297
As far as I know, it is exactly 50% of keys. For any public key you can negate it and switch it from 02 to 03 or from 03 to 02. It is totally symmetric, I cannot see a single example where it would be ambiguous or where more than a pair of keys could be produced in that way. You can see it simply by using G and -G and incrementing or decrementing points. You would see a pairs of private keys: (1;-1);(2;-2);(3;-3);... When dealing with private keys, you can simply subtract your private key from the maximum and get your negated private key. For public keys, you can switch between 02 and 03 prefix. That's all.
Code:
privateKey="FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD036413B", publicKey="02FFF97BD5755EEEA420453A14355235D382F6472F8568A18B2F057A1460297556"
privateKey="FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD036413C", publicKey="032F8BDE4D1A07209355B4A7250A5C5128E88B84BDDC619AB7CBA8D569B240EFE4"
privateKey="FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD036413D", publicKey="03E493DBF1C10D80F3581E4904930B1404CC6C13900EE0758474FA94ABE8C4CD13"
privateKey="FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD036413E", publicKey="03F9308A019258C31049344F85F89D5229B531C845836F99B08601F113BCE036F9"
privateKey="FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD036413F", publicKey="03C6047F9441ED7D6D3045406E95C07CD85C778E4B8CEF3CA7ABAC09B95C709EE5"
privateKey="FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364140", publicKey="0379BE667EF9DCBBAC55A06295CE870B07029BFCDB2DCE28D959F2815B16F81798"
privateKey="0000000000000000000000000000000000000000000000000000000000000001", publicKey="0279BE667EF9DCBBAC55A06295CE870B07029BFCDB2DCE28D959F2815B16F81798"
privateKey="0000000000000000000000000000000000000000000000000000000000000002", publicKey="02C6047F9441ED7D6D3045406E95C07CD85C778E4B8CEF3CA7ABAC09B95C709EE5"
privateKey="0000000000000000000000000000000000000000000000000000000000000003", publicKey="02F9308A019258C31049344F85F89D5229B531C845836F99B08601F113BCE036F9"
privateKey="0000000000000000000000000000000000000000000000000000000000000004", publicKey="02E493DBF1C10D80F3581E4904930B1404CC6C13900EE0758474FA94ABE8C4CD13"
privateKey="0000000000000000000000000000000000000000000000000000000000000005", publicKey="022F8BDE4D1A07209355B4A7250A5C5128E88B84BDDC619AB7CBA8D569B240EFE4"
privateKey="0000000000000000000000000000000000000000000000000000000000000006", publicKey="03FFF97BD5755EEEA420453A14355235D382F6472F8568A18B2F057A1460297556"
privateKey="FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD036413C", publicKey="032F8BDE4D1A07209355B4A7250A5C5128E88B84BDDC619AB7CBA8D569B240EFE4"
privateKey="FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD036413D", publicKey="03E493DBF1C10D80F3581E4904930B1404CC6C13900EE0758474FA94ABE8C4CD13"
privateKey="FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD036413E", publicKey="03F9308A019258C31049344F85F89D5229B531C845836F99B08601F113BCE036F9"
privateKey="FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD036413F", publicKey="03C6047F9441ED7D6D3045406E95C07CD85C778E4B8CEF3CA7ABAC09B95C709EE5"
privateKey="FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364140", publicKey="0379BE667EF9DCBBAC55A06295CE870B07029BFCDB2DCE28D959F2815B16F81798"
privateKey="0000000000000000000000000000000000000000000000000000000000000001", publicKey="0279BE667EF9DCBBAC55A06295CE870B07029BFCDB2DCE28D959F2815B16F81798"
privateKey="0000000000000000000000000000000000000000000000000000000000000002", publicKey="02C6047F9441ED7D6D3045406E95C07CD85C778E4B8CEF3CA7ABAC09B95C709EE5"
privateKey="0000000000000000000000000000000000000000000000000000000000000003", publicKey="02F9308A019258C31049344F85F89D5229B531C845836F99B08601F113BCE036F9"
privateKey="0000000000000000000000000000000000000000000000000000000000000004", publicKey="02E493DBF1C10D80F3581E4904930B1404CC6C13900EE0758474FA94ABE8C4CD13"
privateKey="0000000000000000000000000000000000000000000000000000000000000005", publicKey="022F8BDE4D1A07209355B4A7250A5C5128E88B84BDDC619AB7CBA8D569B240EFE4"
privateKey="0000000000000000000000000000000000000000000000000000000000000006", publicKey="03FFF97BD5755EEEA420453A14355235D382F6472F8568A18B2F057A1460297556"
you do not know the private even or odd.
you can find the public key even or odd.
https://learnmeabitcoin.com/technical/images/public-key/public-key-compressed.png
2548/2 = 1274
2548/10 = 254.8
2548/100= 25.48
2548/1000= 2.548
next
10 - 2.548 = 7.452
....
Do you write in English by yourself or you use translator? It is difficult to understand you because you do not use full sentences, just a few words all the time.
At the end - what do you say you are able to accomplish? Find private key from public key (on any range)? What database you have - database of public keys in some range? Please, for the moment, think what you want to write and write it down slowly and carefully, maybe use google translator if you need.
I had understand his idea.....
but #120 private key is unknown number...this method must know unknown private key number is even or odd ..
#120 ( we can't know private key is even or odd from public key )
CEB6CBBCDBDF5EF7150682150F4CE2C6F4807B349827DCDBDD1F2EFA885A2630 , 2B195386BEA3F5F002DC033B92CFC2C9E71B586302B09CFE535E1FF290B1B5AC
https://bitcointalk.org/index.php?topic=4455904.0
ex:
public key
4CE119C96E2FA357200B559B2F7DD5A5F02D5290AFF74B03F3E471B273211C97 , 12BA26DCB10EC1625DA61FA10A844C676162948271D96967450288EE9233DC3A
Code:
use ecc_double_point ( G * 1/2 )
4CE119C96E2FA357200B559B2F7DD5A5F02D5290AFF74B03F3E471B273211C97 , 12BA26DCB10EC1625DA61FA10A844C676162948271D96967450288EE9233DC3A (20)
A0434D9E47F3C86235477C7B1AE6AE5D3442D49B1943C2B752A68E2A47E247C7 , 893ABA425419BC27A3B6C7E693A24C696F794C2ED877A1593CBEE53B037368D7 (10)
2F8BDE4D1A07209355B4A7250A5C5128E88B84BDDC619AB7CBA8D569B240EFE4 , D8AC222636E5E3D6D4DBA9DDA6C9C426F788271BAB0D6840DCA87D3AA6AC62D6 (5)
5699B93FC6E1BD29E09A328D657A607B4155B61A6B5FCBEDD7C12DF7C67DF8F5 , 3EB81178EBCDAB6894D1ACB3196FD8B7D5A3CC237988CD5AF7CC70F98CC978A7 ( 2.5 )
1B53B6CD7378AD80BFE00A7737F8FD1FC3A417FD80A5F334B1793E40D09AC841 , 0D524B528812140D7D0B8314DDCED0D0B5B5DF618A5C4B4EF67E0C8079EE8061 ( 1.25 )
D06A2686686048A42F1DF9F46D376DEEC6F22D3DECF7659137FB02F779CAB2B8 , C607576EC851D8C049CA0782C9F2EE71B657D1857884D1D0BC8EA79ADEA91779 ( 0.625 )
all point lies on the elliptic curve
4CE119C96E2FA357200B559B2F7DD5A5F02D5290AFF74B03F3E471B273211C97 , 12BA26DCB10EC1625DA61FA10A844C676162948271D96967450288EE9233DC3A (20)
A0434D9E47F3C86235477C7B1AE6AE5D3442D49B1943C2B752A68E2A47E247C7 , 893ABA425419BC27A3B6C7E693A24C696F794C2ED877A1593CBEE53B037368D7 (10)
2F8BDE4D1A07209355B4A7250A5C5128E88B84BDDC619AB7CBA8D569B240EFE4 , D8AC222636E5E3D6D4DBA9DDA6C9C426F788271BAB0D6840DCA87D3AA6AC62D6 (5)
5699B93FC6E1BD29E09A328D657A607B4155B61A6B5FCBEDD7C12DF7C67DF8F5 , 3EB81178EBCDAB6894D1ACB3196FD8B7D5A3CC237988CD5AF7CC70F98CC978A7 ( 2.5 )
1B53B6CD7378AD80BFE00A7737F8FD1FC3A417FD80A5F334B1793E40D09AC841 , 0D524B528812140D7D0B8314DDCED0D0B5B5DF618A5C4B4EF67E0C8079EE8061 ( 1.25 )
D06A2686686048A42F1DF9F46D376DEEC6F22D3DECF7659137FB02F779CAB2B8 , C607576EC851D8C049CA0782C9F2EE71B657D1857884D1D0BC8EA79ADEA91779 ( 0.625 )
all point lies on the elliptic curve
if we can know unknown number is even or odd
( G public key only use + - * / Addition, subtraction, multiplication and division operator , can't use modulus % )
bitcoin private key will can crack from a public key ....
I tried to
make gpu=1 ccap=53 all
compile on nVidia jetson nano, but since it is ARM architecture, there is no x86 -m64 -mssse3, and i removed -m64 -mssse3 the compile has error.
Has anyone tried to compile on ARM?
GPU: 128-core NVIDIA Maxwell™ architecture-based GPU
CPU: Quad-core ARM® A57
Memory: 4 GB 64-bit LPDDR4; 25.6 gigabytes/second
make gpu=1 ccap=53 all
compile on nVidia jetson nano, but since it is ARM architecture, there is no x86 -m64 -mssse3, and i removed -m64 -mssse3 the compile has error.
Has anyone tried to compile on ARM?
GPU: 128-core NVIDIA Maxwell™ architecture-based GPU
CPU: Quad-core ARM® A57
Memory: 4 GB 64-bit LPDDR4; 25.6 gigabytes/second
Kangaroo uses some Intel assembly instructions baked inside the integer classes so you'd have to find their ARM equivalents and put a macro in them like this:
Code:
void Int::add(Int& a, In& b, Int& c) {
#ifdef ARM_CPU
/* Arm instructions */
#else
/* Intel instructions */
}
#ifdef ARM_CPU
/* Arm instructions */
#else
/* Intel instructions */
}
And then compile with ARM version of GCC or cross-compile using Clang.
yes, I see kangaroo use Intel __builtin_ia32_addcarryx_u64 _addcarry_u64 .
I try to search the way to replace those functions.
Thanks.
The follow error code:
Code:
In file included from SECPK1/IntGroup.h:21:0,
from SECPK1/IntGroup.cpp:18:
SECPK1/Int.h: In function ‘void imm_mul(uint64_t*, uint64_t, uint64_t*, uint64_t*)’:
SECPK1/Int.h:253:32: error: ‘__builtin_ia32_addcarryx_u64’ was not declared in this scope
#define _addcarry_u64(a,b,c,d) __builtin_ia32_addcarryx_u64(a,b,c,(long long unsigned int*)d);
^
SECPK1/Int.h:279:7: note: in expansion of macro ‘_addcarry_u64’
c = _addcarry_u64(c, _umul128(x[1], y, &h), carry, dst + 1); carry = h;
^~~~~~~~~~~~~
SECPK1/Int.h:253:32: note: suggested alternative: ‘__builtin_isnand64’
#define _addcarry_u64(a,b,c,d) __builtin_ia32_addcarryx_u64(a,b,c,(long long unsigned int*)d);
^
SECPK1/Int.h:279:7: note: in expansion of macro ‘_addcarry_u64’
c = _addcarry_u64(c, _umul128(x[1], y, &h), carry, dst + 1); carry = h;
^~~~~~~~~~~~~
SECPK1/Int.h: In function ‘void imm_imul(uint64_t*, uint64_t, uint64_t*, uint64_t*)’:
SECPK1/Int.h:253:32: error: ‘__builtin_ia32_addcarryx_u64’ was not declared in this scope
#define _addcarry_u64(a,b,c,d) __builtin_ia32_addcarryx_u64(a,b,c,(long long unsigned int*)d);
^
SECPK1/Int.h:298:7: note: in expansion of macro ‘_addcarry_u64’
c = _addcarry_u64(c,_umul128(x[1],y,&h),carry,dst + 1); carry = h;
^~~~~~~~~~~~~
SECPK1/Int.h:253:32: note: suggested alternative: ‘__builtin_isnand64’
#define _addcarry_u64(a,b,c,d) __builtin_ia32_addcarryx_u64(a,b,c,(long long unsigned int*)d);
^
SECPK1/Int.h:298:7: note: in expansion of macro ‘_addcarry_u64’
c = _addcarry_u64(c,_umul128(x[1],y,&h),carry,dst + 1); carry = h;
^~~~~~~~~~~~~
SECPK1/Int.h: In function ‘void imm_umul(uint64_t*, uint64_t, uint64_t*)’:
SECPK1/Int.h:253:32: error: ‘__builtin_ia32_addcarryx_u64’ was not declared in this scope
#define _addcarry_u64(a,b,c,d) __builtin_ia32_addcarryx_u64(a,b,c,(long long unsigned int*)d);
^
SECPK1/Int.h:318:7: note: in expansion of macro ‘_addcarry_u64’
c = _addcarry_u64(c, _umul128(x[1], y, &h), carry, dst + 1); carry = h;
^~~~~~~~~~~~~
SECPK1/Int.h:253:32: note: suggested alternative: ‘__builtin_isnand64’
#define _addcarry_u64(a,b,c,d) __builtin_ia32_addcarryx_u64(a,b,c,(long long unsigned int*)d);
^
SECPK1/Int.h:318:7: note: in expansion of macro ‘_addcarry_u64’
c = _addcarry_u64(c, _umul128(x[1], y, &h), carry, dst + 1); carry = h;
^~~~~~~~~~~~~
Makefile:80: recipe for target 'obj/SECPK1/IntGroup.o' failed
from SECPK1/IntGroup.cpp:18:
SECPK1/Int.h: In function ‘void imm_mul(uint64_t*, uint64_t, uint64_t*, uint64_t*)’:
SECPK1/Int.h:253:32: error: ‘__builtin_ia32_addcarryx_u64’ was not declared in this scope
#define _addcarry_u64(a,b,c,d) __builtin_ia32_addcarryx_u64(a,b,c,(long long unsigned int*)d);
^
SECPK1/Int.h:279:7: note: in expansion of macro ‘_addcarry_u64’
c = _addcarry_u64(c, _umul128(x[1], y, &h), carry, dst + 1); carry = h;
^~~~~~~~~~~~~
SECPK1/Int.h:253:32: note: suggested alternative: ‘__builtin_isnand64’
#define _addcarry_u64(a,b,c,d) __builtin_ia32_addcarryx_u64(a,b,c,(long long unsigned int*)d);
^
SECPK1/Int.h:279:7: note: in expansion of macro ‘_addcarry_u64’
c = _addcarry_u64(c, _umul128(x[1], y, &h), carry, dst + 1); carry = h;
^~~~~~~~~~~~~
SECPK1/Int.h: In function ‘void imm_imul(uint64_t*, uint64_t, uint64_t*, uint64_t*)’:
SECPK1/Int.h:253:32: error: ‘__builtin_ia32_addcarryx_u64’ was not declared in this scope
#define _addcarry_u64(a,b,c,d) __builtin_ia32_addcarryx_u64(a,b,c,(long long unsigned int*)d);
^
SECPK1/Int.h:298:7: note: in expansion of macro ‘_addcarry_u64’
c = _addcarry_u64(c,_umul128(x[1],y,&h),carry,dst + 1); carry = h;
^~~~~~~~~~~~~
SECPK1/Int.h:253:32: note: suggested alternative: ‘__builtin_isnand64’
#define _addcarry_u64(a,b,c,d) __builtin_ia32_addcarryx_u64(a,b,c,(long long unsigned int*)d);
^
SECPK1/Int.h:298:7: note: in expansion of macro ‘_addcarry_u64’
c = _addcarry_u64(c,_umul128(x[1],y,&h),carry,dst + 1); carry = h;
^~~~~~~~~~~~~
SECPK1/Int.h: In function ‘void imm_umul(uint64_t*, uint64_t, uint64_t*)’:
SECPK1/Int.h:253:32: error: ‘__builtin_ia32_addcarryx_u64’ was not declared in this scope
#define _addcarry_u64(a,b,c,d) __builtin_ia32_addcarryx_u64(a,b,c,(long long unsigned int*)d);
^
SECPK1/Int.h:318:7: note: in expansion of macro ‘_addcarry_u64’
c = _addcarry_u64(c, _umul128(x[1], y, &h), carry, dst + 1); carry = h;
^~~~~~~~~~~~~
SECPK1/Int.h:253:32: note: suggested alternative: ‘__builtin_isnand64’
#define _addcarry_u64(a,b,c,d) __builtin_ia32_addcarryx_u64(a,b,c,(long long unsigned int*)d);
^
SECPK1/Int.h:318:7: note: in expansion of macro ‘_addcarry_u64’
c = _addcarry_u64(c, _umul128(x[1], y, &h), carry, dst + 1); carry = h;
^~~~~~~~~~~~~
Makefile:80: recipe for target 'obj/SECPK1/IntGroup.o' failed
I tried to
make gpu=1 ccap=53 all
compile on nVidia jetson nano, but since it is ARM architecture, there is no x86 -m64 -mssse3, the compile has error.
Has anyone tried to compile on ARM?
GPU: 128-core NVIDIA Maxwell™ architecture-based GPU
CPU: Quad-core ARM® A57
Memory: 4 GB 64-bit LPDDR4; 25.6 gigabytes/second
make gpu=1 ccap=53 all
compile on nVidia jetson nano, but since it is ARM architecture, there is no x86 -m64 -mssse3, the compile has error.
Has anyone tried to compile on ARM?
GPU: 128-core NVIDIA Maxwell™ architecture-based GPU
CPU: Quad-core ARM® A57
Memory: 4 GB 64-bit LPDDR4; 25.6 gigabytes/second