ECC Key Pair Generator & Verifier

Key Pair Generation

A key pair consists of a private key and a corresponding public key. The private key must be kept secret, while the public key can be shared freely.

• Private Key: A randomly generated 256-bit value
• Public Key: Derived mathematically from the private key

In this tool, keys are generated using a cryptographically secure random number generator and displayed in hexadecimal format.

Example (JavaScript)

// Generate a private key
const privateKey = curve.utils.randomPrivateKey();

// Derive the public key (uncompressed)
const publicKey = curve.getPublicKey(privateKey, false);
  

ECDSA – Digital Signatures

ECDSA (Elliptic Curve Digital Signature Algorithm) is used to prove the authenticity and integrity of a message. A signature is created using a private key and can be verified by anyone holding the corresponding public key.

Typical Use Cases

• Authenticating API requests
• Blockchain transactions
• Software integrity verification

Signing a Message

const message = new TextEncoder().encode("Hello, ECC");
const signature = curve.sign(message, privateKey);

// Compact hex representation
const signatureHex = signature.toCompactHex();
  

Verifying a Signature

const isValid = curve.verify(
  signatureHex,
  message,
  publicKey
);
  

If the verification succeeds, it confirms that the message has not been altered and was signed by the holder of the private key.

ECDH – Secure Key Exchange

ECDH (Elliptic Curve Diffie–Hellman) allows two parties to derive the same shared secret over an insecure channel without ever transmitting the secret itself.

Each party combines their own private key with the other party’s public key to compute an identical shared secret.

Common Applications

• Secure session key negotiation
• End-to-end encrypted messaging
• TLS and secure transport protocols

Example (JavaScript)

// Alice's private key + Bob's public key
const sharedSecret = curve.getSharedSecret(
  alicePrivateKey,
  bobPublicKey
);

// Derive a symmetric key (SHA-256)
const derivedKey = sha256(sharedSecret);
  

The derived key is typically used as input for symmetric encryption algorithms such as AES.

Security Notes & Best Practices

• Never share or reuse private keys across environments
• Use ECDSA for authentication, not encryption
• Use ECDH only to derive keys, not as a direct encryption mechanism
• Always hash shared secrets before using them as encryption keys
• Prefer modern curves such as secp256k1 or P-256

This tool is intended for educational, testing, and development purposes. For production systems, always rely on well-audited cryptographic libraries and follow established security standards.