 Show Posts
|
|
Pages: [1]
|
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.....
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. 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? |
|
|
|
Y+(-Y) = FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFC2F(MODULO)  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 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. 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" 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 about Y, -Y relationship? 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. 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" |
|
|
|
you do not know the private even or odd. you can find the public key even or odd. 
2548/2 = 1274
2548/10 = 254.8
2548/100= 25.48
2548/1000= 2.548
next
10 - 2.548 = 7.452
....
Looks like a math from primary school 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.0ex: public key 4CE119C96E2FA357200B559B2F7DD5A5F02D5290AFF74B03F3E471B273211C97 , 12BA26DCB10EC1625DA61FA10A844C676162948271D96967450288EE9233DC3A 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
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
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: void Int::add(Int& a, In& b, Int& c) {
#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 etc. I try to search the way to replace those functions. Thanks. The follow error 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
|
|
|
|
|
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
|
|
|
|
|
