Is it possible to continuously create new wallets until you “create” an already existing wallet

private-keypublic-keywallets

This question is inspired after reading How are ethereum addresses generated?

This is the section of interest

There are three main steps to get from private -> address:

Create a random private key (64 (hex) characters / 256 bits / 32 bytes)

Derive the public key from this private key (128 (hex) characters / 512 bits / 64 bytes)

Derive the address from this public key. (40 (hex) characters / 160 bits / 20 bytes)

From this simplified explanation, it seems that if you create a random private key that someone previously generated, you would be able to gain access to their account. This is clearly not the case since many accounts have been created and I have never heard of this happening. So, what exactly am I missing here?

Best Answer

Everything is about probably of collision to happen. Fast answer, no you can't find a collision by chance (an existing randomly generated private key) as the probability is far too small.

See this Reddit thread where people give some comparisons of the numbers and probability to find one by chance.

The entire cryptographic world, almost every robust cryptographic algorithm ever written in computer code, relies on pure chance to avoid key collisions. The key space is simply chosen to be large enough to make collisions unlikely before the heat death of the universe. But unlikely is not the same as impossible. It's not something I'm worried about at all but I've always found it fascinating.

An interesting non technical article for you could be https://www.wired.com/story/blockchain-bandit-ethereum-weak-private-keys/

the odds of guessing a randomly generated Ethereum private key is 1 in 115 quattuorvigintillion. (Or, as a fraction: 1/2256.) That denominator is very roughly around the number of atoms in the universe. Bednarek compares the task of identifying a random Ethereum key to choosing a grain of sand on a beach, and later asking a friend to find that same grain among a "billion gazillion" beaches.

But note that even not by chance, even if you try hard to find one, it would take you so much time that you would be dead long before even having as much chance to find one than for the entire humanity to find a winning lottery number at the same time.

Related Solutions

[Ethereum] use the same private key for Ethereum and Bitcoin

Yes, both cryptocoins use the same elliptic curve SECP256K1.

Perhaps a better alternative is to use a BIP32 wallet. You have a master key that is not directly used for transactions, but it is used to derive child keys than can be used.

You can derive separate keys for bitcoin and ethereum. You will always be able to use the master key to sign transactions for both keys.

[Ethereum] Is each Ethereum address shared by (theoretically) 2 ** 96 private keys

Your calculations are right, except there aren't exactly 2^256 private keys -- there are "FFFFFFFF FFFFFFFF FFFFFFFF FFFFFFFE BAAEDCE6 AF48A03B BFD25E8C D0364141" (this number is named N in the ETH source code, and is the order of the generator of the elliptic curve secp256k1, from which Ethereum key pairs are generated).

In answer to your question, yes, private keys mapping to the same address will both be able to spend the money in that address on a first come first served basis. They will create the same public key, which the ECDSA verification algorithm is performed against, and so signatures generated by either private key will verify against the same address!

In go-ethereum/accounts/key.go, we have a private key generated from S256 which is secp256k1's curve, meaning they will be less than N be default.

func newKeyFromECDSA(privateKeyECDSA *ecdsa.PrivateKey) *Key {
    id := uuid.NewRandom()
    key := &Key{
        Id:         id,
        Address:    crypto.PubkeyToAddress(privateKeyECDSA.PublicKey),
        PrivateKey: privateKeyECDSA,
    }
    return key
}

func newKey(rand io.Reader) (*Key, error) {
    privateKeyECDSA, err := ecdsa.GenerateKey(secp256k1.S256(), rand)
    if err != nil {
        return nil, err
    }
    return newKeyFromECDSA(privateKeyECDSA), nil
}

go-ethereum/crypto/secp256k1/secp256 also generates the key pairs in accordance with secp2656k1 albeit in a slightly different way :)

Cool illustrative explanation for what `N` really is and why 2 keys will be able to spend money from the same account

Imagine private keys are miles driven in your car, and public keys are number of miles on your car's odometer. If the odometer rolls over from 999,999 to 000,000, a person with miles driven = 1,000,001 will have the same 'public key', and hence the same address, as a person with miles driven = 1.

EC group arithmetic is surprisingly similar to this, but rather than 999,999, we have the seemingly arbitrary number given above! Due to this property, even with your different 'private keys', you will be able to create signatures that verify against the same public key, and hence spend ETH from the same address!!

Boring math explanation

Private keys are 256 bit numbers, and to calculate the public key from a private key you multiply by the generator, g, of the elliptic curve group. The generator in use is defined in the parameters of the secp256k1 libraries being used in ETH. It itself is also an elliptic curve point, and as elliptic curves are cyclic, there exists an n such that n.g = 1 (this is called the generator order).

With this equation we can see that if we had a private key k with k>n, we would have k.g = (k-n).g = k'.g, for a k' that is possibly someone else's private key! So we have keys generated at random modulo n, rather than 2^256.