0

Let’s say I want to generate many private keys so I can generate one private key (and thus a public key) identical to the richest bitcoin address.

But I can’t do that because my computer power is not enough.

What about if I create many machines, like the mining machines, but instead of generating hashes, they would only generate private keys, Let’s call them “Keying machines”

So I have many of those Keying machines generating thousands of thousands of thousands of private keys per minute.

These machines will only stop if and only if they recreate the private key-public key of the richest bitcoin address : 385cR5DM96n1HvBDMzLHPYcw89fZAXULJP )

Is this idea actually possible?

Improve this question

3 Answers 3

Reset to default
2

Sure, it's possible. In fact, this is exactly what the Large Bitcoin Collider does - It has successfully located a few private keys, mostly from a puzzle transaction that seems to have been made to test its progress.

That said, it would still take you an unreasonably long amount of time - The Large Bitcoin Collider took 1 year and 3 months to search 8,000,000,000,000,000 keys (8000 trillion).

There are 2^256 possible keys. Even if you are able to search 1000 trillion keys per second, it would take you 2.7×10^44 × age of the universe to go through all the keys. It's simply not feasible.

As pointed out by G.Maxwell in the comments, the Large Bitcoin Collider should be not be interpreted as a viable, secure, or even reasonable approach to this problem. There have been concerns about its safety and accuract (reddit source).

Improve this answer
7
  • Right, but the more “keying machines” you have the more closer you get to the number of possible keys.
    – Juan
    Commented Feb 28, 2019 at 17:52
  • 4
    I cringe at any mention of "large bitcoin collider" -- because from all appearances it's a scam to get greedy people to run malware. Its claim about being able to crack keys make no sense (see your math), and the software worked by sending arbitrary code to clients (behavior which was obfuscated in the codebase).
    – G. Maxwell
    Commented Feb 28, 2019 at 18:24
  • 3
    @Juan The basis for (almost) all cryptography's security is some computationally infeasible problem. That means that if an attacker can amass a large enough amount of computation power, they can break it. The question is only how hard it needs to be made for them so that this is infeasible. In this case, literally all computers in the world combined wouldn't be able to solve it within a large multiple of the age of the universe in time.
    – Pieter Wuille
    Commented Feb 28, 2019 at 18:32
  • 1
    @Juan: Closer, yes. In the same sense that if I start with one brick, and then I get 1000 more bricks, I am "closer" to being able to build a tower that reaches to Alpha Centauri. Being "closer" isn't very relevant if you're still absurdly far away.
    – Nate Eldredge
    Commented Feb 28, 2019 at 18:42
  • 1
    My example already assumed 1000 trillion hashes per second, and you still end up with a dominant multiplier of 10^44. Even if could do 10^44 * 1000 trillions hashes per second, you would still need 2.7 times the age of the universe to compute all keys.
    – Raghav Sood
    Commented Feb 28, 2019 at 19:02
0

These machines will only stop if and only if they recreate the private key-public key of the richest bitcoin address : 385cR5DM96n1HvBDMzLHPYcw89fZAXULJP

We do not need to use ECDSA math, calculating private and public keys and so on to steal funds from this address. In fact, this is P2SH address and the only thing we need is to find a good bitcoin script with a given hash160 value.

The good news are that finding such script is much more easier than finding a private key.

The bad news are that finding such script still takes more energy than our Sun can provide :)

Some pseudocode:

// push <20 bytes> OP_DROP OP_TRUE
for ( i = 0x1400000000000000000000000000000000000000007551; 
     i <= 0x14ffffffffffffffffffffffffffffffffffffffff7551; i += 0x10000 )
{
//if ( unspent.contains ( hash160 ( i ) )
  if ( hash160 ( i ) == 385cR5DM96n1HvBDMzLHPYcw89fZAXULJP )
    println ( i );
}
Improve this answer
-2

Yes, it's possible but also (very,...) highly improbable.

Improve this answer

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Not the answer you're looking for? Browse other questions tagged or ask your own question.