 Show Posts
|
|
Pages: [1] 2 »
|
Thanks, I'll take a look. I'm no programmer though, so I'd still like to find someone who could do this for me. |
|
|
|
|
If anyone is willing and has the skills to help me with this, I am more than happy to pay for the help.
Please dm me for the full details if interested.
Thanks.
|
|
|
|
Thanks, but there is only an .exe and no source code to look at unfortunately, only the readme inside the zip.
It's closed-source I believe, so it only works for Windows. Were you looking to run it on Linux? If you're just running CPU search, WINE is going to be super slow but it should work under it correctly. Ok, thanks. Yeah, running on Ubuntu 20.04. |
|
|
|
Thanks, but there is only an .exe and no source code to look at unfortunately, only the readme inside the zip. |
|
|
|
Just remove the EC_KEY_generate_key function at line 129 and increment the private key, and then use something like BN_set_word to increment the private key int manually and then run EC_POINT_mul to multiply it by G. Disclaimer: The linear search will probably be faster, I suspect that the key generation method is slow. The other thing to keep in mind, you can edit code to make it start at same point/key, each and every time, but when using a GPU, normally the code works like this: take GPU x and y grid size; let's say our is 10x10 then the program takes your range/keyspace, let's say we have a range of 1000000 now the program divides the range by the grid size, in our example: grid is 10x10 = 100 range size = 1000000 so the program spreads out each GPU thread every 10000 keys/points, and then works incrementally. Same is true for CPU threads as well. Now you can control this via only using 1 CPU thread and that 1 thread will count incrementally. But if you plan on using GPU, you will need to edit the code more or just know that while it will start from same point, it will be same point plus grid/range. Also, if you have nothing to tell the program that x amount of keys have been reached/searched, then your GPU threads will be redoing the keys already ran by other GPU threads. So you have to put in a "nextkey" function that basically says, take grid, take range, take speed, calculate those things, and jump all threads forward by the calculation, once the calculation has been met. Thanks so much for this... I am only using CPU, but would obviously like to use all threads to work on the search. Do you think you could provide the code I need to make it work incrementally? I would really appreciate it. Thanks in advance. |
|
|
|
|
Yes, I completely agree, hence me putting up such a large sum as incentive.
The only way I think it may be possible is if, by sheer luck, one of these addresses have already been key paired on a database somewhere. But odds are almost nil.
|
|
|
|
|
Hey all,
This is a genuine competition.
My friend and I have a bet.
He says that because Bitcoin has been around so long now, it should be possible to crowd source a private key for almost any specific public address as he reckons there will now be databases out there with trillions upon trillions of matched key pairs. I say this is rubbish and it cannot be done.
So, here are 100 addresses. They are all zero balance, sorry.
If anyone can provide a correct private key for any of these addresses, I will give you 0.1 btc.
I don't think it can be done and I'm putting my money where my mouth is.
Prove me wrong haha!
If you do, then you can just post the private key in here for me to check.
Good luck!
1NqCDAp9Tavw6BEu2iWR25kZUvCVttWBJa
1CPvaFoqKi7uEPnT4PXEPBqPjweX2d1HzY
18hS4y6VcBDPqMokWryEyzxZMchTysJ2Rf
1GzYf2bBTEFVcQ13WxbZQAmfhhEipHNhd8
1Q2svhTBsmCRniEGvrWYJtFcPpbz16tWw1
1KiVNDeZKjKEYPceFYKcxiCv9QsJh8SJrq
1Hte44gbcKtP41fsMZf5wQTJsmiqPQNNPe
1A4H4YMVjGfwJxLzsEhXKmCtrejLsvsf5j
113aDW21DoZRn9jvnhV6ddBXYtMUtaDGCR
1D7AU4YNDDMtb3H6XuGAGeLt9McxKSYr7E
1BjiZ39ymLEzwtgDy5k9zC7kMoKhpYGwkW
1BuhEPp3nqFxmGMcAgAHd85uBHtjF5uvoa
1J8GeeNt7PMGVweJpXXDesTCyRpXg8SgXa
1DvMaTcPXWnkHxcxagMAJzTKbhgjwvjy3C
18Y99oqAt4soUnWNyjNphVX3Eyej1kq5aW
1E51ggHBXw34xUdMYk7KguvCz9bEBNQ8Ri
17anXnwqKNE162A1xanxwdaTXHqTsRF8Tq
175jUpJsn4c6muM78xFRS1Mju1yA32Pois
1MCwiqM8VHZdRsBY3bheHqw3zdbcHRutLr
1DNw69JjXRdkBQYLFiCfLToUReywu937mC
1KV3RYVYgEctFUVwopwyyhVY74FVDTLHiG
184CJQdvMPumXE98r1ziSSAeGePgX9YkUf
1FNrs1oGKxgSzRHwgQk4wyVwWXqnVZzB6S
1Esn8xsY1xjyinmF3nNZXayu9scfojBmsL
16S5xgveTb3kG5ckTjGBsUqUzBENMB993j
1L2YmVJeUHBAe7U66uMrQ4VEiNW5yqJw9i
1KncMzFHG6axBPK7BhDxD8R7uwEziVLoAg
1MoPamP7inUG2yoceo4TEZw8SuNx8Fhj4f
1KCLk7pWvHsZBpP6PCwPG6YPyRBYevsPpM
19RczRGkZHdZi2ue27dEepnmQAsWv1g7Pb
14ZEGHyc8aEvMSxyPXEEnzbgUQsWWak4iX
1dnkV5aaxoV9jB9yPzW2tBYJPGiGSmmZe
1E7XkfR5EReYCuEZJDqQG7SUf6QtNkw9r
1m9sWgK71fnjDFk2H4ZXq9gb7LD5rfSfC
1E96MiuNJySUeh7s6kP9qRUxEak7L6AbHJ
1Keqt1UnTk8Boc2NoL7qfY5evyj9m8Vkxr
1361JiHgJvt26W6EET2F8hfWb5yo2THbfY
17b4s2tbCVtz7z3srKP1MLsLUoMuCeuxax
19jkPFVxSGoXQobM8dRrb3g4L3JJoMrpo3
1JfFwLSyUKEWfuu7qC8WTe64LSHJ1Aghd9
1HQYW5DUSkysQwN8LvSL5E9zgeDaAHz4wF
12AHkbifFnTQN6dmqGp1TcPMSSgjJBASWy
12fzPa3abwZXHkpdf4LUKJh41NAKomKYEe
1JK3ixeZZsr186ot8wosczACVbRk2sMU5G
1jaKLEApPwDvszkzA9XjoVEjkt26tsLXj
1EGwHxGpoR8H8YNdLayMBfyhhGFmrgsxRg
1dFiUzLmAFegTHtej8chYsbyMs9K7WDQf
1G3tZz4dSxTzgMF1RS8cQVY9rM5grqAy2g
1HANzSZuscWWmzDPV4szoicAmAMLLjmz3b
1DFqH2jymspJ3z7cRu83tA8o3AP9yhLBjY
1Km3tfxGEU4TtarcipYVLhi7CPehC2q148
1KvkAeqLhasgXscBGhsmrxw1hZ2FJk5vYi
1H9jhMwH9vS4Mzc8xmw4ogLApXvuyojZiy
1F4wVVGULN8wW2MUqh8jwhwjJ1K94rFRpE
1Nff2VjurvibZ16nTHeaSZ5w8pT59QwxyF
1QCD8UWMfckuQiQKPt9YLpK6TtvEj9SYZ8
1GrPXgrk4zzu7Maf75uzuw9STDEDYAKxvj
18Be3aTrQ4WcwN1cNjXFpa3eVRcP9nKpH8
1BvQTnx7DPXFW4VKzrGfNSqt75Nqp8eDei
1KE5m9vZs7UWwCbm697LStJJsc9f9vtcaH
1AXH5iCs7xjPzqBjmvTWLRdKWvQbah9XNH
1Ad76X9Phky6WmNStB2ArLomDtkSFzxy6e
1CiYAuUkENDWemrCBgJUWqLxJnotDkui4h
1CXzrxjSvpFnhH3BJnGZEVZMm5MaAzT67f
1N4QZcV4jUEHv2nmEhCoZbs41R9W5BNfvF
17b4GXGhRGxLBJsBeRPgFb5FeDN7E9u1Lf
1EHfmVnoNe2vyo8vEXHk1mH61jaYcVpXun
1CBpT59ggRSRsB1rceXkVWDxCYbajn9gp4
18wGWJq9mRjQjcQNqP3WDpcMucc26eVn5q
17t8mi1AkUwx4s6cUGfswzHYXDgXpg3Vdp
1BoW3EiURSxGPSyyFpSM8Qu2WCRovRDUto
18Zp38j2bYpJwuKNMKvzRcRjnx5jJSsiDP
19VjALc3RGkUgMJWyd3MdCrrs8NCbG5UBL
1DcbTVXt5UX6687KRTsKy36EXGBL8bLRcq
1Lmw8TSgvBK3bjGKAzk9Cc38ZBa6voTaFk
1CpYYmmvAZCvYJouhhJeha7Mo2stFcKEGF
1Lv7z7FpfYXRRCbgNvmJTgGU6MmMY6guHv
1Ld3oJVX5dyMtZ5SojLjJt5WhHAY2Yq6qo
193iVaGqazkxHQfc874Ww9KcrA1qDzov2Z
1CWFm49hzXbTMYnp5DNtXNvRzg5E33CPNn
1EjFX9bBXvGsLXt4UEzhuYnx3tHFpB473K
1Ai67DQexCNDEyDiWSXncYgCu3tYJzpS4f
1KfgjDnn8YjB6tmtdkzrCxadwCNAhBvrfR
12N8sUyPCP4q2KZ4FpDrqdheCvnbgnzXyQ
1PPgefvNdEp9vhmxw83DZykb1shWLpFywk
1LrjXVqjuMGWg7ck5yKaWXn3KpeWsse4GL
1FHwEr4SfADjXNUxo8hL2STBx7Yy5rH9pS
1B8DZzvqqmGXqU2ZfQYMHBn39fn6Pa7gAZ
151BfH2Mo2uweQU8jjBmct4wp9vXpkLdnq
1CwkvpjidScyNZGe4ARVCSUhuunoMeMa1w
1PrfTaFCszftTeRaVMYjh41HG8JUa6rESa
1J2wtW5LPCEMWaxNK2LuyWE6inyD7grCoQ
165GopXq5h7JSnapF3knSZu8Nmtp5bqmAX
1ERuvnYkeotXUHQsgryq5frgnwhStD5ZVq
1CmBA5M5mhTvRjc8UGM6YiyNeWVse7DGWh
1CvMvmpHmXZfwuUEjSiSafpDz6gA8Lr1un
1ArTfRaDTzwnW8X65UyYBEHeHomEWrrHHs
13iuoAoFfbgfDUNSKkH59ARNM43s8iFKoK
17Vxo5CfJ32FneKyDL8MYHKrEt2uwrqKv8
14cjhxJeUEywpEHUncZjiy5msWmXRFmmYn
|
|
|
|
If L = (y2 - y1) / (x2 - x1) what does 1 / (x2 - x1) mean?
It means that you take the result of x2 - x1 = xdiff, and then raise it to the (p-2)th power: xdiff p-2 mod p. (xdiff p-1 % p would be equal to 1, while xdiff p % p is simply xdiff) where p is the curve characteristic. It's just a shorthand way of writing the above expression as division doesn't really exist in elliptic curves but modular inverses do. I get this It means that you take the result of x2 - x1 = xdiff
but I totally don't uderstand this then raise it to the (p-2)th power: xdiffp-2 mod p. (xdiffp-1 % p would be equal to 1
I need this explained in the simplest possible terms please. That's why I asked for a step by step breakdown (every step) would be much appreciated. |
|
|
|
L = (y2 - y1) / (x2 - x1)
x3 = L^2 - x1 - x2
y3 = L(x1 - x3) - y1
y2 - y1 = 94553076844452666078538149424419144783741135675920254371088167625192913487275
x2 - x1 = 75694105346914480362575934586442506821074289349400393707630734405845016901087
1 / (x2 - x1) = 57109544797366026611537207709745816878454354988638946088653096565731074851657
L = 26260209610829739695182151635707675950033180086458470318530731088353219693361
L^2 = 85396884292048511216639145930585800795235676868516676403763378131573495159908
x3 = 22299113221787846994488776168920263850616409616156953345645360922861305118563
x1 - x3 = 87194808877201440358869426427379159064426064000963275369055864486481116123229
L(x1 - x3) = 114457103505967127914246148065726475976734011734324777350232007537745534737470
y3 = 4557556935953335244676085823642666982350217411134294760123069603436116216826
Thanks again for your help. To get L, can you break this down further for me please? 1 / (x2 - x1) = 57109544797366026611537207709745816878454354988638946088653096565731074851657
L = 26260209610829739695182151635707675950033180086458470318530731088353219693361
If L = (y2 - y1) / (x2 - x1) what does 1 / (x2 - x1) mean? I don't quite understand, sorry. Thank you. |
|
|
|
L = (y2 - y1) / (x2 - x1)
x3 = L^2 - x1 - x2
y3 = L(x1 - x3) - y1
y2 - y1 = 94553076844452666078538149424419144783741135675920254371088167625192913487275
x2 - x1 = 75694105346914480362575934586442506821074289349400393707630734405845016901087
1 / (x2 - x1) = 57109544797366026611537207709745816878454354988638946088653096565731074851657
L = 26260209610829739695182151635707675950033180086458470318530731088353219693361
L^2 = 85396884292048511216639145930585800795235676868516676403763378131573495159908
x3 = 22299113221787846994488776168920263850616409616156953345645360922861305118563
x1 - x3 = 87194808877201440358869426427379159064426064000963275369055864486481116123229
L(x1 - x3) = 114457103505967127914246148065726475976734011734324777350232007537745534737470
y3 = 4557556935953335244676085823642666982350217411134294760123069603436116216826
Thanks so much and please excuse my lack of math skills. How did you get y2-y1 to equal that? When I did it it ends up being a negative number. Also, where does modp come into it all? Thanks again. |
|
|
|
|
Thanks so much for everyone's input so far.
Could I ask if someone would be able to provide a manual step by step example of the point addition process using actual numbers?
Here are 2 random EC points to use from secp256k1.
Privkey: DBD5EBF749EDF69369B251A9434E9B782534294066797AEF1D25ED9B9672E821
x - 109493922098989287353358202596299422915042473617120228714701225409342421241792
y - 109899546570013792669570062242083808994383794323190482590108937934309418520644
+
Privkey: 9A309407E5266673F677C583BF1068615810AF4C1B90D5A8DBB335CC15D05959
x - 69395938208587572292363152174054021882846778300880058382874375807278603471216
y - 88660534177150263324537226657815045924854945333470172921739521551593497336256
I just need the (public key) point addition. No need to do anything with the private keys, they are just there for reference if needed.
I haven't seen this done anywhere (and I've looked a lot). This would be amazing to include in my project and for me to learn what this process actually looks like on paper.
Thanks so much in advance.
|
|
|
|
Thanks so much. I was looking at this on Desmos. It looks like a very useful tool. I want something for the finite field where I can input actual secp256k1 points. |
|
|
|
|
Does anyone know of a website or app where I can input the EC points and it will visually show the addition on a graph of the curve/field?
This would greatly help with my school presentation.
Thanks.
|
|
|
|
Ok, lots of people telling you it can't be done, and saying that it would break ECDSA, but not a lot of explanation about why or how to think about that.
Let's look at it this way....
I assume when you say "around the clock" what you really mean is that you've come back through the base point G, or rather that the point you've generated is equal to G plus something greater than the order of the curve.
Here lies the problem. If you can look at a point (a public key) and know that you had to add G more than a set number of times to get there, then you could calculate the private key from the point:
Was it greater than half the order? No? Ok, how about greater than a fourth of the order? Yes? Ok, how about greater than three-eighths of the order? Yes? Ok, how about greater than seven-sixteenths of the order... and so on until you narrowed in on the exact value of the private key.
There is no way to look at 2 points, and determine which one has the greater private key.
Points are added by calculating the line that passes between both of them, and then calculating where else that line intersects the curve. If you knew the private keys for those two points to start with, then you could figure out if the sum of the two private keys was greater than the order of the curve, but if you don't know the private keys, then you don't have any way of finding out what all the points are for all the private keys that you skipped over when you added the points together. As such, there's no way to know if any of those points were G. Again, if you could know that some given private key existed "in between" the private keys of 2 given points, then you could use that information to quickly and easily narrow in on the private key of any given point.
Does this help you understand why your question isn't going to have an answer? You are thinking about private keys, and how if the private key exceeds the order of the curve then it "wraps around" giving the same results as the new private key minus the order of the curve, but you aren't asking about private keys. You're asking about public keys. Since there is no way to calculate the private key from the public key, there's no way to know what the relationship is between the private keys for 2 given public keys. Which is greater? How far apart are they? You either need to know the private keys to start with, or you need to calculate every point in between to see if any of them are G.
Now, if you want to do your demonstration by picking 2 private keys, and then calculate the public keys from them... That's a different story. In that case, you already KNOW both the private keys. If the sum of those two integers is larger than the order of the curve, then you've wrapped around, if it isn't, then you haven't. That's a simple calculation, and doesn't need a script.
Thank you Danny. The time and care you have taken to explain this is very much appreciated. |
|
|
|
Would it be possible for some amazing kind person to write the script for me? I can't code. What kind of script? You can calculate the addition of those public keys really easily. Just take a program, such as Secp256k1 Calculator and fill the proper fields. Once you add those two points: x: 4BDC661EFDC05C536E1E116B9E059D0E36AA3A25253E18DFC0DDEFD4FACF36F3
y: 22D570A7D46E4F19E3D94869FEF6894ADFA93771837F36B03D3E8341FB15B62C
x: 05FC50574C83CC70A20BDE37F637F76EC53F7780A8FE6C4A4EA7EE9641FD5D39
y: C9523862EBE583E5A9B1423DDC54C789EB332DD9D30A2939CB10258D88987C1F You'll get this one as a result: x: 937192A2BA413909EA6AED1CA53E0AA294736BBB6F41164D159E0A7392926C00
y: 56AFE970031AD898FE0AAD818C133E131122EE682E8FF9C3F1DAB493754999EF Since it returns you coordinates, it's not outside the curve. Thanks so much, but I wanted to know if, during the calculation, it had to go past "0" to calculate the result like in the image I attached in my first post. I think I was using the wrong language by saying outside of the field or curve. I know that the addition always results in a valid point, but did it have to go "around the clock" to get there? I am trying to show the results in my school project so the Python script (or something) would be fantastic to show it in action. Thanks again. |
|
|
|
As others have explained, if it was possible to see when it went past "0" during addition, that would be equal to breaking all private keys. So of course no one is able to tell you a way to do that.
Oh, I don't really understand why, but ok thank you. |
|
|
|
Would it be possible for some amazing kind person to write the script for me? I can't code. It would be fantastic for my project to show this principal in action. So basically I would put in 2 public keys, for example: 044BDC661EFDC05C536E1E116B9E059D0E36AA3A25253E18DFC0DDEFD4FACF36F322D570A7D46E4 F19E3D94869FEF6894ADFA93771837F36B03D3E8341FB15B62C and 0405FC50574C83CC70A20BDE37F637F76EC53F7780A8FE6C4A4EA7EE9641FD5D39C9523862EBE58 3E5A9B1423DDC54C789EB332DD9D30A2939CB10258D88987C1F and the script would add them normally, but also tell me if it went outside the field during the addition process. I have just learned that it doesn't actually go "outside" the field, but more like past 0 and starts again. Thank you so much in advance if someone could do this  |
|
|
|
This is not point is outside becouse after this you do modulo.
The question propably was when the point are outside after finished addition -> so after reduction modulo.
that what have you below describe is not right, please show how to get point outside of the field after reduction modulo. I will give you 100 BTC:) becouse then I can break ECDSA
Not sure what you're referring to with the italic text because he never asked to get a point outside the field after modulo. Thanks. Again I'm sorry as I am so new to this. What I meant was during the public key addition. So I know that when you add 2 public keys together it always results in a valid point on the curve, but sometimes the calculation goes "around" and then back in the other side (if that makes sense) before finding the new point. As in the picture I put in my first post. I don't think this breaks anything does it as it's only on the public side. |
|
|
|
I am doing a school project about Bitcoin and more specifically point addition on the Elliptic Curve. I am very new to all this so please forgive my mistakes. I have been reading that when adding points together the result can go "outside of the bounds before intersecting a third point" as in this image.  This is fascinating but also a little confusing and I would like to know more. So my questions are: 1. Is it possible to know when the point addition process has gone outside of the field? And 2. Is there a way (like a Python script or something) that I could use to add 2 points and it would tell me if the result went outside of the field? I know that the result of the addition is still a valid point on the curve, but I would love to know if it passed out of bounds first. This would be fantastic for my project to show others how this works. I hope that made sense and thanks in advance for your help. |
|
|
|
|
