Pollard's kangaroo ECDLP solver

[wedom]

-snip-
One of the anti-viruses found a trojan: TrojanSpy.Carberp.eut
I have no complaints. Just wondering why.
https://www.virustotal.com/gui/file/d92bd6d9ff7f2f6239b731d3529dfd6827e9d6ce853a115a768d0f16fc799126

Can`t say. I use PBv5.31 to compile app. It is licensed version(not cracked or so.) But I think if the other more well-known antiviruses did not find anything, then this is a false alarm. And so decide for yourself.

I'm sure it's a false positive, too. This is the first time I've seen the name of this antivirus and it doesn't inspire confidence in me.

[1714498665]

1714498665

[1714498665]

1714498665

[Etar]

I put source files to the github, so anybody can compile by self.

[NotATether]

Why no linux version ?

I think Etar only does Windows releases.


Anyway, this is the script I promised I'd show you guys in my previous post: https://gist.github.com/ZenulAbidin/cbe69f8a2496514773140516e3666519

You give it any public key in the file input.txt, adjust the script values such as the number of trailing bits, number of results etc. and it will print you the list of most likely public keys.

Warning: bit numbers >20 will cause you to run out of memory fast. Also it might take about an hour or so to complete depending on the bit size. I am working on a fix for both of these.

-snip-
One of the anti-viruses found a trojan: TrojanSpy.Carberp.eut
I have no complaints. Just wondering why.
https://www.virustotal.com/gui/file/d92bd6d9ff7f2f6239b731d3529dfd6827e9d6ce853a115a768d0f16fc799126

Can`t say. I use PBv5.31 to compile app. It is licensed version(not cracked or so.) But I think if the other more well-known antiviruses did not find anything, then this is a false alarm. And so decide for yourself.

I wouldn't worry about it given that only 3 obscure AV vendors flagged it. Perhaps they don't like CPU-intensive loops with multiple threads. 

[Etar]

I create new topic for BSGS cuda https://bitcointalk.org/index.php?topic=5364845.new#new
Because i don`t want to make offtop on this thread.

[math09183]

Hmm.
One of the anti-viruses found a trojan: TrojanSpy.Carberp.eut
I have no complaints. Just wondering why.
https://www.virustotal.com/gui/file/d92bd6d9ff7f2f6239b731d3529dfd6827e9d6ce853a115a768d0f16fc799126

 

What do you think, why there are no sources attached? 
How do you know what that program does?

[superkatchu]

PureBasic executables get false positives by AV heuristic cause some ransomware used PureBasic. You can search it with google.

[bigvito19]

Anyway, this is the script I promised I'd show you guys in my previous post: https://gist.github.com/ZenulAbidin/cbe69f8a2496514773140516e3666519

You give it any public key in the file input.txt, adjust the script values such as the number of trailing bits, number of results etc. and it will print you the list of most likely public keys.

Warning: bit numbers >20 will cause you to run out of memory fast. Also it might take about an hour or so to complete depending on the bit size. I am working on a fix for both of these.

What does Std. Deviation: 1.1902380714238083 mean?

[NotATether]

What does Std. Deviation: 1.1902380714238083 mean?

That it's likely a human-generated private key.

The standard deviations start from 0 to just over +-1, where +-1 (and above) mean that the key is definitely human-generated and 0 means it's definitely computer-generated.

None of the keys have std. deviation = 0 because you can never be quite sure whether a computer really did generate a key. But at low std. deviations you can be sure that the private key resembles as much as a random private key as possible.

[bigvito19]

What does Std. Deviation: 1.1902380714238083 mean?

That it's likely a human-generated private key.

The standard deviations start from 0 to just over +-1, where +-1 (and above) mean that the key is definitely human-generated and 0 means it's definitely computer-generated.

None of the keys have std. deviation = 0 because you can never be quite sure whether a computer really did generate a key. But at low std. deviations you can be sure that the private key resembles as much as a random private key as possible.

Do you put a private key or public key in the input.txt because I used 1 public key. When I ran the script it gave me just 1 public key.

[NotATether]

Do you put a private key or public key in the input.txt because I used 1 public key. When I ran the script it gave me just 1 public key.

Oh you just use public keys.

Just change the nkeys variable at the top to be the number of keys you want to receive (and make sure bits_toinspect is greater than or equal to log2(nkeys).)

[math09183]

Do you put a private key or public key in the input.txt because I used 1 public key. When I ran the script it gave me just 1 public key.

Oh you just use public keys.

Just change the nkeys variable at the top to be the number of keys you want to receive (and make sure bits_toinspect is greater than or equal to log2(nkeys).)

Does it have any REAL value other than purely statistical?

[sky59sky59]

I have a newbie question.
If I need to find just one private key somewhere in 256bit space does it have a meaning to use gpu? Or cpu is enough?
When gpu is used either for bsgs or kangaroo how many % of gpu power is used? Because if I am not wrong common gpu has got hundrets to thousands cores but over here in forum I could see examples running just a few threads on gpu? How is it? What is the principle for gpu usage? Each core mskes exactly the same task just for different interval?

[NotATether]

Do you put a private key or public key in the input.txt because I used 1 public key. When I ran the script it gave me just 1 public key.

Oh you just use public keys.

Just change the nkeys variable at the top to be the number of keys you want to receive (and make sure bits_toinspect is greater than or equal to log2(nkeys).)

Does it have any REAL value other than purely statistical?

Yes, provided I can figure out how to jump from one low std. deviation key to the next without pregenerating them all. [and without too much computational increase from addition].

I have a newbie question.
If I need to find just one private key somewhere in 256bit space does it have a meaning to use gpu? Or cpu is enough?
When gpu is used either for bsgs or kangaroo how many % of gpu power is used? Because if I am not wrong common gpu has got hundrets to thousands cores but over here in forum I could see examples running just a few threads on gpu? How is it? What is the principle for gpu usage? Each core mskes exactly the same task just for different interval?

GPU cores get dozens of smaller ranges loaded in them at once, these get searched quickly so that they can be loaded again, that's why GPUs are much faster than CPU.

[PrivatePerson]

If I need to find just one private key somewhere in 256bit space does it have a meaning to use gpu? Or cpu is enough?

At the moment it is impossible to find a 256 bit private key, it takes thousands of the most powerful GPUs and a lot of time.

[ymgve2]

If I need to find just one private key somewhere in 256bit space does it have a meaning to use gpu? Or cpu is enough?

At the moment it is impossible to find a 256 bit private key, it takes thousands of the most powerful GPUs and a lot of time.

That's not even close. It takes more than a quintillion of the most powerful GPUs running for 1000 YEARS to find a single 256 bit private key. And that is with Kangaroo/BSGS methods.

[COBRAS]

Sure.

Load these 1000 example hex private keys (they are randomly generated which means don't waste your time trying to find money in these - I didn't load them).

https://pastebin.com/WNJLJd2r (too large to post here)

The script will analyze how frequently a 1 or 0 occurs in a certain bit position.

Then it uses the analysis results to estimate the probability of a 1 or 0 occurring in that position.

It also supports analyzing the probability of a sequence of bits occurring in multiple positions, but be warned that that increasing the number of positions to estimate together, uses a lot of memory (A LOT!).

This particular output makes the following result:

Code:

========== TOP 260 MOST LIKELY BIT CONFIGURATIONS (Highest probability first) ==========
Output format: <probability> [(<bit number between 0-255>, <0 or 1>), ...]
[(9.399999999999997, [(33, 0)]),
 (8.600000000000009, [(127, 1)]),
 (7.399999999999995, [(135, 0)]),
 (7.199999999999996, [(153, 0)]),
 (6.999999999999995, [(53, 0)]),
 (6.600000000000006, [(142, 1)]),
 (6.400000000000006, [(32, 1)]),
 (6.400000000000006, [(88, 1)]),
 (6.400000000000006, [(186, 1)]),
 (6.399999999999995, [(124, 0)]),
 (6.399999999999995, [(227, 0)]),
 (6.2000000000000055, [(43, 0)]),
 (5.800000000000005, [(0, 0)]),
 (5.800000000000005, [(2, 0)]),
 (5.800000000000005, [(9, 0)]),
 (5.600000000000005, [(76, 0)]),
 (5.600000000000005, [(94, 1)]),
 (5.600000000000005, [(111, 0)]),
 (5.600000000000005, [(137, 1)]),
 (5.600000000000005, [(196, 1)]),
 (5.600000000000005, [(208, 1)]),
 (5.400000000000005, [(16, 1)]),
 (5.400000000000005, [(247, 1)]),
 (5.200000000000005, [(15, 1)]),
 (5.200000000000005, [(89, 1)]),
 (5.200000000000005, [(147, 1)]),
 (5.200000000000005, [(170, 1)]),
 (5.200000000000005, [(190, 0)]),
 (5.200000000000005, [(212, 0)]),
 (5.200000000000005, [(219, 0)]),
 (5.000000000000004, [(3, 1)]),
 (5.000000000000004, [(36, 1)]),
 (5.000000000000004, [(41, 1)]),
 (4.800000000000004, [(165, 1)]),
 (4.800000000000004, [(169, 0)]),
 (4.600000000000004, [(19, 1)]),
 (4.600000000000004, [(31, 1)]),
 (4.600000000000004, [(112, 1)]),
 (4.600000000000004, [(140, 1)]),
 (4.600000000000004, [(191, 0)]),
 (4.400000000000004, [(22, 1)]),
 (4.400000000000004, [(93, 1)]),
 (4.200000000000004, [(18, 0)]),
 (4.200000000000004, [(64, 1)]),
 (4.200000000000004, [(68, 0)]),
 (4.200000000000004, [(84, 0)]),
 (4.200000000000004, [(174, 1)]),
 (4.200000000000004, [(181, 0)]),
 (4.0000000000000036, [(117, 0)]),
 (4.0000000000000036, [(144, 0)]),
 (4.0000000000000036, [(195, 0)]),
 (4.0000000000000036, [(199, 0)]),
 (4.0000000000000036, [(213, 0)]),
 (4.0000000000000036, [(228, 1)]),
 (3.8000000000000034, [(26, 0)]),
 (3.8000000000000034, [(47, 1)]),
 (3.8000000000000034, [(77, 0)]),
 (3.8000000000000034, [(109, 1)]),
 (3.8000000000000034, [(168, 0)]),
 (3.8000000000000034, [(222, 0)]),
 (3.600000000000003, [(35, 0)]),
 (3.600000000000003, [(61, 1)]),
 (3.600000000000003, [(92, 0)]),
 (3.600000000000003, [(224, 0)]),
 (3.600000000000003, [(225, 1)]),
 (3.600000000000003, [(232, 0)]),
 (3.400000000000003, [(1, 0)]),
 (3.400000000000003, [(40, 0)]),
 (3.400000000000003, [(102, 1)]),
 (3.400000000000003, [(116, 1)]),
 (3.400000000000003, [(188, 1)]),
 (3.400000000000003, [(244, 1)]),
 (3.200000000000003, [(103, 1)]),
 (3.200000000000003, [(108, 0)]),
 (3.200000000000003, [(129, 0)]),
 (3.200000000000003, [(132, 0)]),
 (3.200000000000003, [(139, 1)]),
 (3.200000000000003, [(159, 1)]),
 (3.200000000000003, [(238, 0)]),
 (3.0000000000000027, [(7, 0)]),
 (3.0000000000000027, [(10, 1)]),
 (3.0000000000000027, [(25, 1)]),
 (3.0000000000000027, [(45, 1)]),
 (3.0000000000000027, [(72, 1)]),
 (3.0000000000000027, [(85, 0)]),
 (3.0000000000000027, [(98, 1)]),
 (3.0000000000000027, [(99, 1)]),
 (3.0000000000000027, [(157, 0)]),
 (3.0000000000000027, [(180, 1)]),
 (3.0000000000000027, [(185, 0)]),
 (3.0000000000000027, [(206, 1)]),
 (3.0000000000000027, [(242, 0)]),
 (2.8000000000000025, [(23, 0)]),
 (2.8000000000000025, [(82, 1)]),
 (2.8000000000000025, [(160, 1)]),
 (2.8000000000000025, [(173, 0)]),
 (2.8000000000000025, [(175, 1)]),
 (2.8000000000000025, [(204, 1)]),
 (2.8000000000000025, [(210, 0)]),
 (2.8000000000000025, [(216, 0)]),
 (2.8000000000000025, [(250, 0)]),
 (2.6000000000000023, [(63, 1)]),
 (2.6000000000000023, [(83, 0)]),
 (2.6000000000000023, [(97, 0)]),
 (2.6000000000000023, [(107, 0)]),
 (2.6000000000000023, [(164, 0)]),
 (2.6000000000000023, [(233, 0)]),
 (2.6000000000000023, [(235, 0)]),
 (2.6000000000000023, [(237, 0)]),
 (2.400000000000002, [(105, 1)]),
 (2.400000000000002, [(128, 0)]),
 (2.400000000000002, [(149, 1)]),
 (2.400000000000002, [(158, 0)]),
 (2.400000000000002, [(162, 1)]),
 (2.400000000000002, [(177, 0)]),
 (2.400000000000002, [(179, 1)]),
 (2.400000000000002, [(245, 0)]),
 (2.200000000000002, [(14, 1)]),
 (2.200000000000002, [(27, 1)]),
 (2.200000000000002, [(34, 0)]),
 (2.200000000000002, [(46, 0)]),
 (2.200000000000002, [(95, 1)]),
 (2.200000000000002, [(115, 0)]),
 (2.200000000000002, [(134, 0)]),
 (2.200000000000002, [(146, 1)]),
 (2.200000000000002, [(183, 0)]),
 (2.200000000000002, [(189, 1)]),
 (2.200000000000002, [(200, 0)]),
 (2.200000000000002, [(205, 0)]),
 (2.200000000000002, [(241, 1)]),
 (2.200000000000002, [(243, 1)]),
 (2.0000000000000018, [(54, 0)]),
 (2.0000000000000018, [(58, 0)]),
 (2.0000000000000018, [(113, 0)]),
 (2.0000000000000018, [(119, 1)]),
 (2.0000000000000018, [(133, 0)]),
 (2.0000000000000018, [(155, 1)]),
 (2.0000000000000018, [(194, 0)]),
 (2.0000000000000018, [(240, 1)]),
 (1.8000000000000016, [(42, 0)]),
 (1.8000000000000016, [(62, 0)]),
 (1.8000000000000016, [(65, 1)]),
 (1.8000000000000016, [(67, 0)]),
 (1.8000000000000016, [(104, 0)]),
 (1.8000000000000016, [(131, 0)]),
 (1.8000000000000016, [(152, 1)]),
 (1.8000000000000016, [(176, 0)]),
 (1.8000000000000016, [(217, 0)]),
 (1.8000000000000016, [(226, 1)]),
 (1.6000000000000014, [(39, 0)]),
 (1.6000000000000014, [(57, 0)]),
 (1.6000000000000014, [(74, 1)]),
 (1.6000000000000014, [(80, 1)]),
 (1.6000000000000014, [(121, 1)]),
 (1.6000000000000014, [(182, 0)]),
 (1.6000000000000014, [(215, 1)]),
 (1.4000000000000012, [(6, 1)]),
 (1.4000000000000012, [(52, 0)]),
 (1.4000000000000012, [(75, 1)]),
 (1.4000000000000012, [(81, 1)]),
 (1.4000000000000012, [(87, 1)]),
 (1.4000000000000012, [(101, 1)]),
 (1.4000000000000012, [(123, 1)]),
 (1.4000000000000012, [(198, 1)]),
 (1.4000000000000012, [(214, 0)]),
 (1.4000000000000012, [(236, 1)]),
 (1.4000000000000012, [(249, 1)]),
 (1.4000000000000012, [(253, 0)]),
 (1.4000000000000012, [(255, 0)]),
 (1.200000000000001, [(66, 1)]),
 (1.200000000000001, [(78, 1)]),
 (1.200000000000001, [(86, 1)]),
 (1.200000000000001, [(118, 1)]),
 (1.200000000000001, [(120, 1)]),
 (1.200000000000001, [(130, 0)]),
 (1.200000000000001, [(136, 1)]),
 (1.200000000000001, [(143, 0)]),
 (1.200000000000001, [(145, 0)]),
 (1.200000000000001, [(148, 0)]),
 (1.200000000000001, [(156, 0)]),
 (1.200000000000001, [(218, 1)]),
 (1.200000000000001, [(220, 1)]),
 (1.0000000000000009, [(4, 1)]),
 (1.0000000000000009, [(12, 1)]),
 (1.0000000000000009, [(37, 0)]),
 (1.0000000000000009, [(71, 0)]),
 (1.0000000000000009, [(79, 0)]),
 (1.0000000000000009, [(96, 0)]),
 (1.0000000000000009, [(141, 1)]),
 (1.0000000000000009, [(172, 0)]),
 (1.0000000000000009, [(192, 0)]),
 (1.0000000000000009, [(202, 0)]),
 (1.0000000000000009, [(209, 1)]),
 (1.0000000000000009, [(211, 0)]),
 (1.0000000000000009, [(254, 1)]),
 (0.8084000000000005, [(33, 0), (127, 1)]),
 (0.8000000000000007, [(8, 1)]),
 (0.8000000000000007, [(21, 1)]),
 (0.8000000000000007, [(56, 0)]),
 (0.8000000000000007, [(69, 1)]),
 (0.8000000000000007, [(106, 1)]),
 (0.8000000000000007, [(122, 0)]),
 (0.8000000000000007, [(150, 0)]),
 (0.8000000000000007, [(163, 1)]),
 (0.8000000000000007, [(167, 0)]),
 (0.8000000000000007, [(193, 1)]),
 (0.8000000000000007, [(203, 1)]),
 (0.8000000000000007, [(207, 0)]),
 (0.8000000000000007, [(229, 1)]),
 (0.8000000000000007, [(230, 0)]),
 (0.8000000000000007, [(248, 0)]),
 (0.8000000000000007, [(252, 0)]),
 (0.6955999999999993, [(33, 0), (135, 0)]),
 (0.6767999999999994, [(33, 0), (153, 0)]),
 (0.6579999999999994, [(33, 0), (53, 0)]),
 (0.6364000000000002, [(127, 1), (135, 0)]),
 (0.6204000000000004, [(33, 0), (142, 1)]),
 (0.6192000000000001, [(127, 1), (153, 0)]),
 (0.6020000000000001, [(127, 1), (53, 0)]),
 (0.6016000000000004, [(33, 0), (32, 1)]),
 (0.6016000000000004, [(33, 0), (88, 1)]),
 (0.6016000000000004, [(33, 0), (186, 1)]),
 (0.6015999999999994, [(33, 0), (124, 0)]),
 (0.6015999999999994, [(33, 0), (227, 0)]),
 (0.6000000000000005, [(20, 0)]),
 (0.6000000000000005, [(29, 0)]),
 (0.6000000000000005, [(48, 1)]),
 (0.6000000000000005, [(49, 0)]),
 (0.6000000000000005, [(50, 1)]),
 (0.6000000000000005, [(90, 1)]),
 (0.6000000000000005, [(114, 0)]),
 (0.6000000000000005, [(151, 1)]),
 (0.6000000000000005, [(166, 1)]),
 (0.6000000000000005, [(171, 0)]),
 (0.6000000000000005, [(197, 0)]),
 (0.6000000000000005, [(221, 1)]),
 (0.6000000000000005, [(234, 1)]),
 (0.5828000000000003, [(33, 0), (43, 0)]),
 (0.567600000000001, [(127, 1), (142, 1)]),
 (0.550400000000001, [(127, 1), (32, 1)]),
 (0.550400000000001, [(127, 1), (88, 1)]),
 (0.550400000000001, [(127, 1), (186, 1)]),
 (0.5504, [(127, 1), (124, 0)]),
 (0.5504, [(127, 1), (227, 0)]),
 (0.5452000000000002, [(33, 0), (0, 0)]),
 (0.5452000000000002, [(33, 0), (2, 0)]),
 (0.5452000000000002, [(33, 0), (9, 0)]),
 (0.5332000000000009, [(127, 1), (43, 0)]),
 (0.5327999999999994, [(135, 0), (153, 0)]),
 (0.5264000000000003, [(33, 0), (76, 0)]),
 (0.5264000000000003, [(33, 0), (94, 1)]),
 (0.5264000000000003, [(33, 0), (111, 0)]),
 (0.5264000000000003, [(33, 0), (137, 1)]),
 (0.5264000000000003, [(33, 0), (196, 1)]),
 (0.5264000000000003, [(33, 0), (208, 1)]),
 (0.5179999999999993, [(135, 0), (53, 0)]),
 (0.5076000000000003, [(33, 0), (16, 1)]),
 (0.5076000000000003, [(33, 0), (247, 1)]),
 (0.5039999999999993, [(153, 0), (53, 0)]),
 (0.4988000000000009, [(127, 1), (0, 0)])]

The values on the left, are probabilities of the bit positions on the left (beginning with 0 and ending at 255)  being a 1 or 0 respectively (the second number in the tuple).

Normally when e.g. 40% of bits are 1, that means 60% of them are 0 (another version of this script using this algo can be found here https://gist.github.com/ZenulAbidin/63d13b05f5adda18f03ef2cab577fca3)

But I am calculating the probabilities above, a little differently here.

say 400 out of 1000 of keys have a specific bit at 1 like the example above, that would mean coefficient of 0.4 (where valid values are from 0 to 1 - likeliness of a bit being 1). 0.5 means that the bits are perfectly distributed evenly.

So I take this coefficient and subtract it by 0.5 - which gives a metric of how "chaotic" this bit is [n.b. this has nothing to do with quantum computers and all that].

Negative values here means the bit is more likely to be zero, Positive means more likely to be one. But the larger the absolute value of this result, the less "chaotic" (less likely to vary among larger sample size) this bit is.

This script multiplies these values by 2 to get a result between -1 and 1 (as opposed to -0.5 and 0.5), to allow interpretation as a percentage.

So 0% would be absolute chaos (equivalent to 50/50 probability of 0 or 1 for a given position). 100% would be no chaos at all (since the bit stays the same) and this is what the script is measuring.

<so this script in the form I showed you does not help you guess private key bits, it's just a scientific study of random numbers.>


The other script I linked in this post is using regular probabilities, not chaos percentages by the way.

Bro, Hello.

How to check only 1,2,3 pubkeys with this scrypt ? Without random ganeration, and without many publick keys ?

Thx

[NotATether]

~

Bro, Hello.

How to check only 1,2,3 pubkeys with this scrypt ? Without random ganeration, and without many publick keys ?

Thx

By placing just the 3 public keys in input.txt file and adjusting the "nsamples" (or maybe it was called "nkeys") parameter in the script to be just 1,2,3 or like that, to print that many divisions per key.

[bigvito19]

Do you put a private key or public key in the input.txt because I used 1 public key. When I ran the script it gave me just 1 public key.

Oh you just use public keys.

Just change the nkeys variable at the top to be the number of keys you want to receive (and make sure bits_toinspect is greater than or equal to log2(nkeys).)

That's equivalent to knowing the very lowest bit of the private key so you've effectively reduced your search range by a power of 2 e.g. 2^60 --- 2^59. It's not useful enough in a practical setting though. Not to mention there isn't a foolproof way to guess the private key's parity in the first place.

Do you have an example of that?

[a.a]

Take the privatekey of 4. Half it, you get 2. Take the privatekey of 5 you get 2.5. 2.5 means, 2 + N/2. To get the "half" you subtract 1 and then halve it and get 2.

So if you can determine if the lowest bit is 0 or 1 you can half it properly. But there is no method to determine 0 or 1. Thats why you can theoretically halve multiple times but have to use the false keys. Like you take a big number with 2^120 bit, and can halve it and get two keys were you know one is 2^119 and one is "wrong". Use both keys and halve them. You know one is 2^118 and three are false. Take those four keys and halve them again, one is 2^117 and 7 are false.

So you get exponentially more keys each halving. Which is useful for e.g. 2^60 as you can get 2^45 with 2^15 (15 times halved, you can do more halvings if you like) potential keys to check in very few minutes. But you can not do it with 2^120 as you still get 2^105 range with 2^15 keys, which takes still a long time to crack. Doing 2^120 halvings is basically bruteforcing the key.

[NotATether]

Do you put a private key or public key in the input.txt because I used 1 public key. When I ran the script it gave me just 1 public key.

Oh you just use public keys.

Just change the nkeys variable at the top to be the number of keys you want to receive (and make sure bits_toinspect is greater than or equal to log2(nkeys).)

That's equivalent to knowing the very lowest bit of the private key so you've effectively reduced your search range by a power of 2 e.g. 2^60 --- 2^59. It's not useful enough in a practical setting though. Not to mention there isn't a foolproof way to guess the private key's parity in the first place.

Do you have an example of that?

Example of which one? You are quoting two different problems here. The latter one is "how to guess the lowest bit of all PKs with 100% confidence" which is impossible to do.