Ethereum: Official Documentation of the elliptic curve used for Ethereum

Official Documentation: Elliptic Curve Cryptography for Ethereum

Ethereum’s cryptographic infrastructure relies heavily on Elliptic Curve Cryptography (ECC), specifically the NIST-approved Secp256k1 curve. This curve is widely used in various aspects of the Ethereum network, including key generation, signing, and verification.

What is Secp256k1?

Secp256k1 is a public-key cryptography algorithm based on the Elliptic Curve Cryptography (ECC) specification defined by the National Institute of Standards and Technology (NIST). It is fast, secure, and efficient, making it suitable for a wide range of applications.

Ethereum Private/PublicKeys

To generate private/public keys for Ethereum, users must interact with the Ethereum mainnet or testnet through a node. The process involves using the Ethereum wallet software to create a new key pair on the Ethereum network. This key pair consists of:

–
Private Key (PK): A unique 64-byte string used to sign transactions and verify the authenticity of messages.

–
Public Key (PK): The corresponding digital signature of the private key.

The private/public key pairs are generated using the “eth-wallet” software package, which is part of the Ethereum ecosystem. This software provides a user-friendly interface for creating and managing Ethereum keys.

Signing Transactions

When a user sends a transaction to the Ethereum network, their Ethereum wallet uses the Elliptic Curve Cryptography (ECC) algorithm provided by Secp256k1 to generate a digital signature of the transaction. The digital signature serves as proof that the sender is in control of the transaction and verifies its authenticity on the receiving end.

Sample code

For illustration purposes, here is a sample code snippet using Solidity, the programming language for smart contracts on Ethereum, to demonstrate how to generate a private/public key pair and sign a transaction:

pragma solidity ^0.8.0;
import "
contract MyContract {
address public owner;
bytes32 public secp256k1Secret;
// Constructor function
constructor(address _owner) public {
owner = _owner;
secp256k1Secret = keccak256(abi.encodePacked("mysecp256k1"));
}
// Function to generate a new private/public key pair
function generateKeyPair() internal view returns (bytes32, bytes32) {
return keccak256(abi.encodePacked(address(this).asBytes(), secp256k1Secret));
}
// Function to sign a transaction with the generated key pair
function signTransaction(bytes memory _transaction) public pure returns (bytes32, bytes32) {
// Calculate the digital signature using Secp256k1
bytes32 signature = keccak256(abi.encodePacked(_transaction));
// Returns the private and public key as a tuple
return (signature, address(this).asBytes());
}
}

Conclusion

Ethereum’s use of Secp256k1 in its cryptographic infrastructure provides a secure and efficient solution for generating Ethereum private/public keys and signing transactions. This documentation has described the official sources used for this purpose, ensuring transparency and accuracy.

Additional resources

For more information on Ethereum’s cryptographic architecture, including additional resources and implementation details:

– [Ethereum Developer Documentation](

– [OpenZeppelin Solidity Documentation](

– [NIST’s Secp256k1 Specification](