A Simple Python secp256k1 ECDSA Sign & Verify Tutorial

pip install ecdsa

Let's generate them:

import ecdsa
import hashlib

# Generate a new private key on the secp256k1 curve
private_key = ecdsa.SigningKey.generate(curve=ecdsa.SECP256k1)

# Derive the public key from the private key
public_key = private_key.verifying_key

# You can print them to see what they look like (as hex strings)
print(f"Private Key: {private_key.to_string().hex()}")
print(f"Public Key: {public_key.to_string('compressed').hex()}")

Keep these keys handy; we'll need them in the next steps. Notice we're explicitly telling the library to use the `ecdsa.SECP256k1` curve.

Step 2: Crafting Your Message

Next, we need something to sign. This could be anything: a simple string, a JSON object, or the contents of a file. A crucial point here is that we don't sign the message directly. Instead, for efficiency and security, we sign a hash of the message.

The standard hashing algorithm to pair with `secp256k1` is SHA-256.

# The message you want to sign (must be bytes)
message = b"Sending 1 BTC to Bob"

# Hash the message using SHA-256
message_hash = hashlib.sha256(message).digest()

print(f"Message: {message.decode()}")
print(f"Message Hash: {message_hash.hex()}")

Hashing creates a fixed-size, unique fingerprint of your data. If even one bit of the original message changes, the hash will change completely.

Step 3: The Signature - Putting Pen to Digital Paper

Now for the magic. We use our private key to sign the message hash. This creates the digital signature, which is mathematical proof that the owner of the private key approved this specific message.

# Sign the hash of the message with the private key
signature = private_key.sign(message_hash)

print(f"Signature: {signature.hex()}")

This `signature` is the piece of data you would send along with your original message. It's useless on its own but powerful when combined with the public key and message.

Step 4: The Moment of Truth - Verification

This is the final and most critical step. Imagine you are a third party who has received the message, the signature, and the sender's public key. Your job is to verify that the signature is valid.

The verification process requires three things:

1. The Public Key
2. The Message Hash (which you recalculate from the original message)
3. The Signature

The `ecdsa` library makes this simple. The `verify()` method will return `True` if the signature is valid. If it's invalid for any reason (wrong key, modified message, or tampered signature), it will raise a `BadSignatureError` exception.

try:
    # To verify, you need the public key, the signature, and the original message hash
    is_valid = public_key.verify(signature, message_hash)
    if is_valid:
        print("\nVerification successful! The signature is valid.")
except ecdsa.BadSignatureError:
    print("\nVerification failed! The signature is invalid.")

Putting It All Together

Here is a complete, runnable script that combines everything we've done. You can save it as a .py file and run it yourself!

import ecdsa
import hashlib

# --- 1. Key Generation ---
# The sender generates a key pair
private_key = ecdsa.SigningKey.generate(curve=ecdsa.SECP256k1)
public_key = private_key.verifying_key

print("--- Keys ---")
print(f"Private Key: {private_key.to_string().hex()}")
print(f"Public Key: {public_key.to_string('compressed').hex()}\n")

# --- 2. Message & Signing ---
# The sender creates a message and signs its hash
message = b"This is a secret message for the world's best developers."
message_hash = hashlib.sha256(message).digest()
signature = private_key.sign(message_hash)

print("--- Signing Process ---")
print(f"Original Message: {message.decode()}")
print(f"Message Hash: {message_hash.hex()}")
print(f"Signature: {signature.hex()}\n")

# --- 3. Verification ---
# The receiver gets the public key, message, and signature.
# They re-calculate the message hash and verify.

# Let's pretend we are the receiver
received_public_key = public_key
received_message = message
received_signature = signature

# Receiver hashes the message they received
receiver_hash = hashlib.sha256(received_message).digest()

print("--- Verification Process ---")
try:
    # The verify method returns True or raises BadSignatureError
    if received_public_key.verify(received_signature, receiver_hash):
        print("SUCCESS: The signature is valid.")
except ecdsa.BadSignatureError:
    print("ERROR: The signature is invalid.")

# --- Tampering Example ---
# What if the message was tampered with?
tampered_message = b"This is a malicious message!"
tampered_hash = hashlib.sha256(tampered_message).digest()

print("\n--- Tampering Check ---")
print(f"Tampered Message: {tampered_message.decode()}")
try:
    if received_public_key.verify(received_signature, tampered_hash):
        print("SUCCESS: The signature is valid.") # This won't be printed
except ecdsa.BadSignatureError:
    print("ERROR: Verification failed for the tampered message. As expected!")

Sidestepping Common Pitfalls

While the process is straightforward, a few common mistakes can trip you up.

Keep Your Private Key Private!

This cannot be stressed enough. Your private key is your identity. If it's compromised, anyone can sign messages as you. Store it securely, for example in an encrypted wallet, a hardware security module (HSM), or a secure environment variable—never hard-code it into your source code.

Don't Sign the Raw Message!

Always sign the hash of the message, not the message itself. This ensures that the data being signed is a fixed size, which is a requirement for the ECDSA algorithm, and it provides better security against certain types of cryptographic attacks.

Encoding Matters

Computers work with bytes, not characters. When you hash your message, ensure you're using a consistent character encoding (like UTF-8) on both the signing and verifying sides. A mismatch in encoding will result in a different hash and a failed verification.

message_string = "Hello, World!"
message_bytes = message_string.encode('utf-8')
message_hash = hashlib.sha256(message_bytes).digest()

Cryptography in Your Hands

And there you have it. You’ve just walked through the entire lifecycle of a digital signature, from key creation to final verification. It’s not black magic; it’s elegant mathematics made accessible through powerful, easy-to-use Python libraries.

Understanding how `secp256k1` and ECDSA work is more than an academic exercise. It’s a foundational skill for anyone building applications in the world of blockchain, decentralized finance, or any system that requires verifiable, trustless communication. You now have the tools to build systems where authenticity isn't just a promise—it's a mathematical certainty.