Jeanluc not apear from
Last Active: October 31, 2020, 10:19:32 AM
any one have in contact with him, live not infected covid19, all ok with him,
from june most GPU developer are goes offline, like BitCrack, Alek-76, Telaurist, other same worked on forked, all offline from long time, no more GPU based developments,
any comments ?
Topic: Pollard's kangaroo ECDLP solver - page 78. (Read 59389 times)
where the processed keys are stored, why the RAM consumption has not increased in 8 days, only 5.5 MB ?
You got your DP set at 64, you got to go through 2^64 keys to get a DP, lower your DP so you can collect more DP's. Then you need to save your DP's, example:
Kangaroo.exe -ws -w save.work -wi 30 in.txt
where the processed keys are stored, why the RAM consumption has not increased in 8 days, only 5.5 MB ?
is there a bsgs gpu version out there, anywhere guys?
any news under the sun, love to read something new and great
once again in here,
any news under the sun, love to read something new and great
once again in here,
Its not a BSGS with a GPU yet and no new updates yet.
How can i use saved work file for another public key?
You can't do that, you will have to start over with a new public key.
How can i use saved work file for another public key?
is there a bsgs gpu version out there, anywhere guys?
any news under the sun, love to read something new and great
once again in here,
any news under the sun, love to read something new and great
once again in here,
Ok ? the best for 2080 CX ?
Code:
C:\Users\plex\Desktop\k>Kangaroo.exe -t 0 -gpu -ws -w save.work -wi 60 -o k.txt 120.txt
Kangaroo v2.2
Start:800000000000000000000000000000
Stop :FFFFFFFFFFFFFFFFFFFFFFFFFFFFFF
Keys :1
Number of CPU thread: 0
Range width: 2^119
Jump Avg distance: 2^58.98
Number of kangaroos: 2^20.52
Suggested DP: 36
Expected operations: 2^60.61
Expected RAM: 990.0MB
DP size: 36 [0xFFFFFFFFF0000000]
GPU: GPU #0 GeForce RTX 2080 (46x64 cores) Grid(92x128) (122.0 MB used)
SolveKeyGPU Thread GPU#0: creating kangaroos...
SolveKeyGPU Thread GPU#0: 2^20.52 kangaroos [8.3s]
[896.72 MK/s][GPU 896.72 MK/s][Count 2^35.24][Dead 0][51s (Avg 62.2988y)][2.0/4.0MB]
SaveWork: save.work................done [140.0 MB] [01s] Thu Nov 12 23:18:05 2020
[900.67 MK/s][GPU 900.67 MK/s][Count 2^36.34][Dead 0][01:52 (Avg 62.0259y)][2.0/4.0MB]
SaveWork: save.work................done [140.0 MB] [01s] Thu Nov 12 23:19:06 2020
[899.76 MK/s][GPU 899.76 MK/s][Count 2^36.95][Dead 0][02:52 (Avg 62.0887y)][2.0/4.0MB]
SaveWork: save.work................done [140.0 MB] [01s] Thu Nov 12 23:20:06 2020
[896.86 MK/s][GPU 896.86 MK/s][Count 2^37.39][Dead 0][03:53 (Avg 62.289y)][2.0/4.0MB]
Kangaroo v2.2
Start:800000000000000000000000000000
Stop :FFFFFFFFFFFFFFFFFFFFFFFFFFFFFF
Keys :1
Number of CPU thread: 0
Range width: 2^119
Jump Avg distance: 2^58.98
Number of kangaroos: 2^20.52
Suggested DP: 36
Expected operations: 2^60.61
Expected RAM: 990.0MB
DP size: 36 [0xFFFFFFFFF0000000]
GPU: GPU #0 GeForce RTX 2080 (46x64 cores) Grid(92x128) (122.0 MB used)
SolveKeyGPU Thread GPU#0: creating kangaroos...
SolveKeyGPU Thread GPU#0: 2^20.52 kangaroos [8.3s]
[896.72 MK/s][GPU 896.72 MK/s][Count 2^35.24][Dead 0][51s (Avg 62.2988y)][2.0/4.0MB]
SaveWork: save.work................done [140.0 MB] [01s] Thu Nov 12 23:18:05 2020
[900.67 MK/s][GPU 900.67 MK/s][Count 2^36.34][Dead 0][01:52 (Avg 62.0259y)][2.0/4.0MB]
SaveWork: save.work................done [140.0 MB] [01s] Thu Nov 12 23:19:06 2020
[899.76 MK/s][GPU 899.76 MK/s][Count 2^36.95][Dead 0][02:52 (Avg 62.0887y)][2.0/4.0MB]
SaveWork: save.work................done [140.0 MB] [01s] Thu Nov 12 23:20:06 2020
[896.86 MK/s][GPU 896.86 MK/s][Count 2^37.39][Dead 0][03:53 (Avg 62.289y)][2.0/4.0MB]
what does the letter B mean? Appeared a day later
It's only a text artifact because of the previously longer line [2.0/4.0MB].Why are you searching this address?
I have a CPU, does 256 bit work? I need the full range to be a small probability of finding the key in a short time if I lucky
CPU? ehhhh
Dude, you have no idea how much 'luck' you will need. On the full big range this method is almost this same like randomly picking the numbers from 1 to FFFF FFFF FFFF FFFF FFFF FFFF FFFF FFFE BAAE DCE6 AF48 A03B BFD2 5E8C D036 4140 and checking if you hit.
You think you still want to try?
Take 64bit puzzle and try to find the key - just throw 64 times coin and check if you find the key.
hello all
still no news from zeiler and Jluc, long time silent, can they confirm, what % work left from there side, and any new development, we little discus about point multiplication at gpu powered, still no comment and concern shown by Jluc and other developer, can we hear some news about level of finding puzzle 120bit
still no news from zeiler and Jluc, long time silent, can they confirm, what % work left from there side, and any new development, we little discus about point multiplication at gpu powered, still no comment and concern shown by Jluc and other developer, can we hear some news about level of finding puzzle 120bit
Thanks brainless
The reason I chose Jean_Luc's project
it can run its own uint_64 (own integer class) with GPU, I'm trying to understand this issue.
Source code includes AddDircet, DoubleDirect and ComputePublicKey (G * int). But EccMultipy (Point x int) does not exist.
I was just in the beginning, I guess this is not the right place to discuss. But even if I only use CPU it is much faster than python. I don't know if it is with a GPU.
I'm not sure what I'm learning, I am not aware of C or C ++ right now, for now (:
The reason I chose Jean_Luc's project
it can run its own uint_64 (own integer class) with GPU, I'm trying to understand this issue.
Source code includes AddDircet, DoubleDirect and ComputePublicKey (G * int). But EccMultipy (Point x int) does not exist.
I was just in the beginning, I guess this is not the right place to discuss. But even if I only use CPU it is much faster than python. I don't know if it is with a GPU.
I'm not sure what I'm learning, I am not aware of C or C ++ right now, for now (:
" ComputePublicKey (G * int) (G * int). But EccMultipy (Point x int) does not exist. "
G = point
G * int = its eccmultiply (Point x int)
only developer need to design as per above command for easy input/output at gpu work, let see who design it for community
JLuc code
Pubkey = ComputePublicKey (int); (G in this funciton, and G has some hash algroithm)
brainless
Is it possible to control -2**35 to 2**35 point operation in 3 seconds on CPU?
few sec on gpu
so I want to test a GPU-powered ECC operation with the GPU running at full performance. I have a few studies that I have tested with Sage,
I'm looking for a library that works with GPU where I can create functions and loops it in C or C ++.
Thanks for your interest brainless
you need to wait, for Jluc , maybe he come with some free time and mood, to create repo for community, where like above command for point multiplication at GPU
btw all community members read our chats, but they know best gpu developer and understand technology is Jluc and all will wait for his reply regading this subject,
Bitcrack developer brichard also can develop GPU based Point multiplication, but i feel he is no more interested for community to help due to some reason
Thanks brainless
The reason I chose Jean_Luc's project
it can run its own uint_64 (own integer class) with GPU, I'm trying to understand this issue.
Source code includes AddDircet, DoubleDirect and ComputePublicKey (G * int). But EccMultipy (Point x int) does not exist.
I was just in the beginning, I guess this is not the right place to discuss. But even if I only use CPU it is much faster than python. I don't know if it is with a GPU.
I'm not sure what I'm learning, I am not aware of C or C ++ right now, for now (:
The reason I chose Jean_Luc's project
it can run its own uint_64 (own integer class) with GPU, I'm trying to understand this issue.
Source code includes AddDircet, DoubleDirect and ComputePublicKey (G * int). But EccMultipy (Point x int) does not exist.
I was just in the beginning, I guess this is not the right place to discuss. But even if I only use CPU it is much faster than python. I don't know if it is with a GPU.
I'm not sure what I'm learning, I am not aware of C or C ++ right now, for now (:
" ComputePublicKey (G * int) (G * int). But EccMultipy (Point x int) does not exist. "
G = point
G * int = its eccmultiply (Point x int)
only developer need to design as per above command for easy input/output at gpu work, let see who design it for community
JLuc code
Pubkey = ComputePublicKey (int); (G in this funciton, and G has some hash algroithm)
brainless
Is it possible to control -2**35 to 2**35 point operation in 3 seconds on CPU?
few sec on gpu
so I want to test a GPU-powered ECC operation with the GPU running at full performance. I have a few studies that I have tested with Sage,
I'm looking for a library that works with GPU where I can create functions and loops it in C or C ++.
Thanks for your interest brainless
Thanks brainless
The reason I chose Jean_Luc's project
it can run its own uint_64 (own integer class) with GPU, I'm trying to understand this issue.
Source code includes AddDircet, DoubleDirect and ComputePublicKey (G * int). But EccMultipy (Point x int) does not exist.
I was just in the beginning, I guess this is not the right place to discuss. But even if I only use CPU it is much faster than python. I don't know if it is with a GPU.
I'm not sure what I'm learning, I am not aware of C or C ++ right now, for now (:
The reason I chose Jean_Luc's project
it can run its own uint_64 (own integer class) with GPU, I'm trying to understand this issue.
Source code includes AddDircet, DoubleDirect and ComputePublicKey (G * int). But EccMultipy (Point x int) does not exist.
I was just in the beginning, I guess this is not the right place to discuss. But even if I only use CPU it is much faster than python. I don't know if it is with a GPU.
I'm not sure what I'm learning, I am not aware of C or C ++ right now, for now (:
" ComputePublicKey (G * int) (G * int). But EccMultipy (Point x int) does not exist. "
G = point
G * int = its eccmultiply (Point x int)
only developer need to design as per above command for easy input/output at gpu work, let see who design it for community
JLuc code
Pubkey = ComputePublicKey (int); (G in this funciton, and G has some hash algroithm)
brainless
Is it possible to control -2**35 to 2**35 point operation in 3 seconds on CPU?
few sec on gpu
Thanks brainless
The reason I chose Jean_Luc's project
it can run its own uint_64 (own integer class) with GPU, I'm trying to understand this issue.
Source code includes AddDircet, DoubleDirect and ComputePublicKey (G * int). But EccMultipy (Point x int) does not exist.
I was just in the beginning, I guess this is not the right place to discuss. But even if I only use CPU it is much faster than python. I don't know if it is with a GPU.
I'm not sure what I'm learning, I am not aware of C or C ++ right now, for now (:
The reason I chose Jean_Luc's project
it can run its own uint_64 (own integer class) with GPU, I'm trying to understand this issue.
Source code includes AddDircet, DoubleDirect and ComputePublicKey (G * int). But EccMultipy (Point x int) does not exist.
I was just in the beginning, I guess this is not the right place to discuss. But even if I only use CPU it is much faster than python. I don't know if it is with a GPU.
I'm not sure what I'm learning, I am not aware of C or C ++ right now, for now (:
" ComputePublicKey (G * int) (G * int). But EccMultipy (Point x int) does not exist. "
G = point
G * int = its eccmultiply (Point x int)
only developer need to design as per above command for easy input/output at gpu work, let see who design it for community
JLuc code
Pubkey = ComputePublicKey (int); (G in this funciton, and G has some hash algroithm)
brainless
Is it possible to control -2**35 to 2**35 point operation in 3 seconds on CPU?
Thanks brainless
The reason I chose Jean_Luc's project
it can run its own uint_64 (own integer class) with GPU, I'm trying to understand this issue.
Source code includes AddDircet, DoubleDirect and ComputePublicKey (G * int). But EccMultipy (Point x int) does not exist.
I was just in the beginning, I guess this is not the right place to discuss. But even if I only use CPU it is much faster than python. I don't know if it is with a GPU.
I'm not sure what I'm learning, I am not aware of C or C ++ right now, for now (:
The reason I chose Jean_Luc's project
it can run its own uint_64 (own integer class) with GPU, I'm trying to understand this issue.
Source code includes AddDircet, DoubleDirect and ComputePublicKey (G * int). But EccMultipy (Point x int) does not exist.
I was just in the beginning, I guess this is not the right place to discuss. But even if I only use CPU it is much faster than python. I don't know if it is with a GPU.
I'm not sure what I'm learning, I am not aware of C or C ++ right now, for now (:
" ComputePublicKey (G * int). But EccMultipy (Point x int) does not exist. "
G = point
G * int = its eccmultiply (Point x int)
only developer need to design as per above command for easy input/output at gpu work, let see who design it for community
Thanks brainless
The reason I chose Jean_Luc's project
it can run its own uint_64 (own integer class) with GPU, I'm trying to understand this issue.
Source code includes AddDircet, DoubleDirect and ComputePublicKey (G * int). But EccMultipy (Point x int) does not exist.
I was just in the beginning, I guess this is not the right place to discuss. But even if I only use CPU it is much faster than python. I don't know if it is with a GPU.
I'm not sure what I'm learning, I am not aware of C or C ++ right now, for now (:
The reason I chose Jean_Luc's project
it can run its own uint_64 (own integer class) with GPU, I'm trying to understand this issue.
Source code includes AddDircet, DoubleDirect and ComputePublicKey (G * int). But EccMultipy (Point x int) does not exist.
I was just in the beginning, I guess this is not the right place to discuss. But even if I only use CPU it is much faster than python. I don't know if it is with a GPU.
I'm not sure what I'm learning, I am not aware of C or C ++ right now, for now (:
-snip-
I have some functions in Python and it runs very slow compared to C.
The sage I want to do with the GPU is as follows
Do you have any suggestions? What should I do ?
I wrote my question here because it is indirectly related to this project. Please forgive.
I have some functions in Python and it runs very slow compared to C.
The sage I want to do with the GPU is as follows
Code:
Pr = 115792089237316195423570985008687907853269984665640564039457584007908834671663
E = EllipticCurve (GF (P), [0,7])
N = E.order ()
G = E(55066263022277343669578718895168534326250603453777594175500187360389116729240,32670510020758816978083085130507043184471273380659243275938904335757337482424) # on E
T = E(26864879445837655118481716049217967286489564259939711339119540571911158650839,29571359081268663540055655726653840143920402820693420787986280659961264797165) # on E
numInt = 5646546546563131314723897429834729834798237429837498237498237489273948728934798237489723489723984729837489237498237498237498237498273493729847
numMod = numInt %N
numInv = pow(numMod ,N-2,N) # detail -> https://stackoverflow.com/questions/59234775/how-to-calculate-2-to-the-power-of-a-large-number-modulo-another-large-number
numMod * G
numMod * T
(T-G) * numInv
print (5*T)
print (2*G)
print (numMod * G)
print (numMod * (-G))
print (numMod * T)
print ((numMod-3) * (T-G))
E = EllipticCurve (GF (P), [0,7])
N = E.order ()
G = E(55066263022277343669578718895168534326250603453777594175500187360389116729240,32670510020758816978083085130507043184471273380659243275938904335757337482424) # on E
T = E(26864879445837655118481716049217967286489564259939711339119540571911158650839,29571359081268663540055655726653840143920402820693420787986280659961264797165) # on E
numInt = 5646546546563131314723897429834729834798237429837498237498237489273948728934798237489723489723984729837489237498237498237498237498273493729847
numMod = numInt %N
numInv = pow(numMod ,N-2,N) # detail -> https://stackoverflow.com/questions/59234775/how-to-calculate-2-to-the-power-of-a-large-number-modulo-another-large-number
numMod * G
numMod * T
(T-G) * numInv
print (5*T)
print (2*G)
print (numMod * G)
print (numMod * (-G))
print (numMod * T)
print ((numMod-3) * (T-G))
Do you have any suggestions? What should I do ?
I wrote my question here because it is indirectly related to this project. Please forgive.
Hi! The slowest part in your python is inverse function. Try to implement gmpy2 inverse function (included in gmpy2) - it is C-based and very fast:
https://www.lfd.uci.edu/~gohlke/pythonlibs/#gmpy
You can find the details here: https://bitcointalksearch.org/topic/m.55214449
When using Python, I use FastEcdsa(https://github.com/AntonKueltz/fastecdsa) library and mathematics similar to Sage. But can I do the math faster? I want to understand.
The FastEcdsa Library is fast, but I don't know if it uses the gmpy2 you suggested. My python script uses 17% of the CPU as a result. I wanted to write with Anaconda (for GPU), but I could not find a gpu running as fast as C or I could not.
Thank you MrFreeDragon .
No. you can't be faster then GPU on your CPU.
here are some example aspected commands
./vs-pub -c -gpu -input in.txt -output out.txt -add 0250863AD64A87AE8A2FE83C1AF1A8403CB53F53E486D8511DAD8A04887E5B2352 #pubkey
./vs-pub -c -gpu -input in.txt -output out.txt -mul 123456789 # its privatekey in num (not hex)
./vs-pub -c -gpu -input in.txt -output out.txt -sub 0250863AD64A87AE8A2FE83C1AF1A8403CB53F53E486D8511DAD8A04887E5B2352 #pubkey
./vs-pub -c -gpu -input in.txt -output out.txt -sub 0250863AD64A87AE8A2FE83C1AF1A8403CB53F53E486D8511DAD8A04887E5B2352 -r (reverse like
02508... pubkey substract to all listed pubkey inside in.txt
-c is compressed pubkey
-u is uncompressed pubkey
-input is load of compressed/uncompressed pubkeys list
-output is results output to file
-r is reverse of sub ( listed pubkey in command minus(-) in.txt (pubkeys)
-snip-
I have some functions in Python and it runs very slow compared to C.
The sage I want to do with the GPU is as follows
Do you have any suggestions? What should I do ?
I wrote my question here because it is indirectly related to this project. Please forgive.
I have some functions in Python and it runs very slow compared to C.
The sage I want to do with the GPU is as follows
Code:
Pr = 115792089237316195423570985008687907853269984665640564039457584007908834671663
E = EllipticCurve (GF (P), [0,7])
N = E.order ()
G = E(55066263022277343669578718895168534326250603453777594175500187360389116729240,32670510020758816978083085130507043184471273380659243275938904335757337482424) # on E
T = E(26864879445837655118481716049217967286489564259939711339119540571911158650839,29571359081268663540055655726653840143920402820693420787986280659961264797165) # on E
numInt = 5646546546563131314723897429834729834798237429837498237498237489273948728934798237489723489723984729837489237498237498237498237498273493729847
numMod = numInt %N
numInv = pow(numMod ,N-2,N) # detail -> https://stackoverflow.com/questions/59234775/how-to-calculate-2-to-the-power-of-a-large-number-modulo-another-large-number
numMod * G
numMod * T
(T-G) * numInv
print (5*T)
print (2*G)
print (numMod * G)
print (numMod * (-G))
print (numMod * T)
print ((numMod-3) * (T-G))
E = EllipticCurve (GF (P), [0,7])
N = E.order ()
G = E(55066263022277343669578718895168534326250603453777594175500187360389116729240,32670510020758816978083085130507043184471273380659243275938904335757337482424) # on E
T = E(26864879445837655118481716049217967286489564259939711339119540571911158650839,29571359081268663540055655726653840143920402820693420787986280659961264797165) # on E
numInt = 5646546546563131314723897429834729834798237429837498237498237489273948728934798237489723489723984729837489237498237498237498237498273493729847
numMod = numInt %N
numInv = pow(numMod ,N-2,N) # detail -> https://stackoverflow.com/questions/59234775/how-to-calculate-2-to-the-power-of-a-large-number-modulo-another-large-number
numMod * G
numMod * T
(T-G) * numInv
print (5*T)
print (2*G)
print (numMod * G)
print (numMod * (-G))
print (numMod * T)
print ((numMod-3) * (T-G))
Do you have any suggestions? What should I do ?
I wrote my question here because it is indirectly related to this project. Please forgive.
Hi! The slowest part in your python is inverse function. Try to implement gmpy2 inverse function (included in gmpy2) - it is C-based and very fast:
https://www.lfd.uci.edu/~gohlke/pythonlibs/#gmpy
You can find the details here: https://bitcointalksearch.org/topic/m.55214449
When using Python, I use FastEcdsa(https://github.com/AntonKueltz/fastecdsa) library and mathematics similar to Sage. But can I do the math faster? I want to understand.
The FastEcdsa Library is fast, but I don't know if it uses the gmpy2 you suggested. My python script uses 17% of the CPU as a result. I wanted to write with Anaconda (for GPU), but I could not find a gpu running as fast as C or I could not.
Thank you MrFreeDragon .
No. you can't be faster then GPU on your CPU.
-snip-
I have some functions in Python and it runs very slow compared to C.
The sage I want to do with the GPU is as follows
Do you have any suggestions? What should I do ?
I wrote my question here because it is indirectly related to this project. Please forgive.
I have some functions in Python and it runs very slow compared to C.
The sage I want to do with the GPU is as follows
Code:
Pr = 115792089237316195423570985008687907853269984665640564039457584007908834671663
E = EllipticCurve (GF (P), [0,7])
N = E.order ()
G = E(55066263022277343669578718895168534326250603453777594175500187360389116729240,32670510020758816978083085130507043184471273380659243275938904335757337482424) # on E
T = E(26864879445837655118481716049217967286489564259939711339119540571911158650839,29571359081268663540055655726653840143920402820693420787986280659961264797165) # on E
numInt = 5646546546563131314723897429834729834798237429837498237498237489273948728934798237489723489723984729837489237498237498237498237498273493729847
numMod = numInt %N
numInv = pow(numMod ,N-2,N) # detail -> https://stackoverflow.com/questions/59234775/how-to-calculate-2-to-the-power-of-a-large-number-modulo-another-large-number
numMod * G
numMod * T
(T-G) * numInv
print (5*T)
print (2*G)
print (numMod * G)
print (numMod * (-G))
print (numMod * T)
print ((numMod-3) * (T-G))
E = EllipticCurve (GF (P), [0,7])
N = E.order ()
G = E(55066263022277343669578718895168534326250603453777594175500187360389116729240,32670510020758816978083085130507043184471273380659243275938904335757337482424) # on E
T = E(26864879445837655118481716049217967286489564259939711339119540571911158650839,29571359081268663540055655726653840143920402820693420787986280659961264797165) # on E
numInt = 5646546546563131314723897429834729834798237429837498237498237489273948728934798237489723489723984729837489237498237498237498237498273493729847
numMod = numInt %N
numInv = pow(numMod ,N-2,N) # detail -> https://stackoverflow.com/questions/59234775/how-to-calculate-2-to-the-power-of-a-large-number-modulo-another-large-number
numMod * G
numMod * T
(T-G) * numInv
print (5*T)
print (2*G)
print (numMod * G)
print (numMod * (-G))
print (numMod * T)
print ((numMod-3) * (T-G))
Do you have any suggestions? What should I do ?
I wrote my question here because it is indirectly related to this project. Please forgive.
Hi! The slowest part in your python is inverse function. Try to implement gmpy2 inverse function (included in gmpy2) - it is C-based and very fast:
https://www.lfd.uci.edu/~gohlke/pythonlibs/#gmpy
You can find the details here: https://bitcointalksearch.org/topic/m.55214449
When using Python, I use FastEcdsa(https://github.com/AntonKueltz/fastecdsa) library and mathematics similar to Sage. But can I do the math faster? I want to understand.
The FastEcdsa Library is fast, but I don't know if it uses the gmpy2 you suggested. My python script uses 17% of the CPU as a result. I wanted to write with Anaconda (for GPU), but I could not find a gpu running as fast as C or I could not.
Thank you MrFreeDragon .
Jump to: