[Ethereum] Generate Ethereum address from a private key

etherphpprivate-key

My question was first asked on stackoverflow but due lack of privileges I couldn't move it here directly.

I am trying to generate an Ethereum address based on a given private key following this "How are ethereum addresses generated?" and using this Keccak-256 Ethereum implementation. But it show this error:

Warning: openssl_pkey_get_details() expects parameter 1 to be resource, boolean given in /localweb/getethaddress.php on line 15

openssl_pkey_get_private error:0D07207B:asn1 encoding routines:ASN1_get_object:header too long
openssl_pkey_get_private error:0D068066:asn1 encoding routines:ASN1_CHECK_TLEN:bad object header
openssl_pkey_get_private error:0D07803A:asn1 encoding routines:ASN1_ITEM_EX_D2I:nested asn1 error
openssl_pkey_get_private error:10092010:elliptic curve routines:d2i_ECPrivateKey:EC lib
openssl_pkey_get_private error:100DE08E:elliptic curve routines:OLD_EC_PRIV_DECODE:decode error
openssl_pkey_get_private error:0D07207B:asn1 encoding routines:ASN1_get_object:header too long
openssl_pkey_get_private error:0D068066:asn1 encoding routines:ASN1_CHECK_TLEN:bad object header
openssl_pkey_get_private error:0D07803A:asn1 encoding routines:ASN1_ITEM_EX_D2I:nested asn1 error
openssl_pkey_get_private error:0907B00D:PEM

routines:PEM_READ_BIO_PRIVATEKEY:ASN1 lib

My implementation:

<?php
    require_once 'keccak256.php';


    // Format the private key as PEM
    $header_private_key = "-----BEGIN EC PRIVATE KEY-----\n";
    $footer_private_key = "\n-----END EC PRIVATE KEY-----";
    //echo hex2bin("1a63b5c735d66d827f40f7d3a257da777cd7997d48bd5d319c36683c0ad3b1de");
    $eth_private_key = $header_private_key . "1a63b5c735d66d827f40f7d3a257da777cd7997d48bd5d319c36683c0ad3b1de" . $footer_private_key;

    // Load private key from a string
    $private_key = openssl_pkey_get_private($eth_private_key);
    var_dump($private_key);
    while ($msg = openssl_error_string())
        echo "openssl_pkey_get_private " . $msg . "<br />\n";

    // Get the Public key
    $_public_key = openssl_pkey_get_details($private_key)['key'];
    $eth_public_key = openssl_pkey_get_public($_public_key);

    // hash the public key
    $hash_public_key = Keccak256\Keccak256::hash($eth_public_key, 256);; 
    $eth_address = '0x' . substr($hash_public_key, -40);


    echo 'Your generated address: ' . $eth_address . '<br>';
    echo 'Myetherwallet address: 0x47180b59dd8c81f46186900bbd29cbf675b3fbd9';


    /*
        a generated address from Myetherwallet 40: 47180b59dd8c81f46186900bbd29cbf675b3fbd9
        private key 64: 1a63b5c735d66d827f40f7d3a257da777cd7997d48bd5d319c36683c0ad3b1de
    */
?>

Best Answer

There are some functions in web3p toolset, but I have no Idea if it will work.

https://github.com/web3p/ethereum-util/blob/0815348c3513e004d7dfa65ebeb31cda9d41f77e/src/Util.php#L133-L172

Related Solutions

[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.

[Ethereum] EthereumJS: How to get public key from private key

ethereumjs-wallet can be used to get public key from private key:

> const hdkey = require('ethereumjs-wallet/hdkey')
> const privateKey = hdkey.fromMasterSeed('random')._hdkey._privateKey
> const Wallet = require('ethereumjs-wallet')
> const wallet = Wallet.fromPrivateKey(privateKey)
> wallet.getPublicKeyString()
'0x11f2b30c9479ccaa639962e943ca7cfd3498705258ddb49dfe25bba00a555e48cb35a79f3d084ce26dbac0e6bb887463774817cb80e89b20c0990bc47f9075d5'
> wallet.getPublicKey()
<Buffer 11 f2 b3 0c 94 79 cc aa 63 99 62 e9 43 ca 7c fd 34 98 70 52 58 dd b4 9d fe 25 bb a0 0a 55 5e 48 cb 35 a7 9f 3d 08 4c e2 6d ba c0 e6 bb 88 74 63 77 48 ... >

Another option is to use ethereumjs-util (which is used by ethereumjs-wallet internally):

> const util = require('ethereumjs-util')
> util.privateToPublic(privateKey)
<Buffer 11 f2 b3 0c 94 79 cc aa 63 99 62 e9 43 ca 7c fd 34 98 70 52 58 dd b4 9d fe 25 bb a0 0a 55 5e 48 cb 35 a7 9f 3d 08 4c e2 6d ba c0 e6 bb 88 74 63 77 48 ... >

Yet another option is secp256k1:

> const secp256k1 = require('secp256k1')
> secp256k1.publicKeyCreate(privateKey, false).slice(1)
<Buffer 11 f2 b3 0c 94 79 cc aa 63 99 62 e9 43 ca 7c fd 34 98 70 52 58 dd b4 9d fe 25 bb a0 0a 55 5e 48 cb 35 a7 9f 3d 08 4c e2 6d ba c0 e6 bb 88 74 63 77 48 ... >

slice(1) is to drop type byte which is hardcoded as 04 ethereum.