ECDSA (Elliptic Curve Digital Signature Algorithm)
ECDSA (Elliptic Curve Digital Signature Algorithm) is the specific cryptographic algorithm that most major blockchains, including Bitcoin and Ethereum, use to sign transactions and prove that whoever is spending funds actually controls the private key for that address, without ever revealing the private key itself. It is built on top of elliptic curve cryptography, the broader mathematical framework used to generate the public/private key pairs in the first place - ECDSA is specifically the signing procedure that uses those keys, not the key-generation math itself. In short: elliptic curve cryptography is the general toolkit, and ECDSA is one specific tool built from it, dedicated purely to producing and checking signatures.
In practice, when a wallet sends a Bitcoin or Ethereum transaction, it uses ECDSA together with the sender's private key to produce a digital signature attached to that transaction. That signature is a pair of numbers, conventionally called r and s, generated through a specific mathematical procedure involving the private key, the transaction data, and a random number. Anyone on the network can then take the sender's public key (which is not secret), the transaction data, and the signature, and run a separate verification calculation to confirm the signature is valid for that specific transaction and could only have been produced by someone holding the matching private key - without that verifier ever learning the private key itself. Bitcoin and Ethereum both use a specific elliptic curve called secp256k1 for this process, and every full node on both networks independently re-runs this verification for every transaction before accepting it into a block.
ECDSA has one critical requirement that is easy to get wrong: every single signature must use a fresh, unpredictable random number (called the nonce, or "k-value") that is never reused across two different signatures made with the same private key. The math behind why this matters is fairly simple to state even for a non-technical reader: a valid ECDSA signature effectively encodes one equation relating the message, the nonce, and the private key. One signature with one unknown nonce is safe, because there's no way to isolate the private key from a single equation with two unknowns (the nonce and the key). But if the same k-value is reused across two different signatures, an attacker who obtains both signatures now has two equations sharing the same unknown nonce - enough information to solve for both unknowns and recover the private key directly, using nothing more advanced than algebra. No brute-force guessing or supercomputer is required; the flaw is purely a logic error in how the signature was generated, not a weakness in elliptic curve math itself.
This is not a theoretical risk. In December 2010, the hacking group fail0verflow demonstrated at the Chaos Communication Congress (27C3) that Sony had made exactly this mistake in the PlayStation 3's code-signing system: instead of generating a new random nonce for each ECDSA signature, Sony's implementation reused a constant value every time it signed a piece of authorized software. Because Sony's own signing service had produced many signatures with the identical k-value over time, researchers were able to collect several of those signatures and extract Sony's private signing key outright. From that point on, anyone could use the recovered key to sign and run unauthorized software on any PS3 console, permanently and irreversibly breaking the console's entire code-signing security model - Sony could not simply patch the flaw after the fact, because the private key itself, not just a piece of software, had leaked. The requirement to regenerate the nonce for every signature had been explicitly stated in the U.S. government's FIPS 186 cryptographic standard since 1994, which made the error especially costly and embarrassing for a company with Sony's engineering resources; the incident remains one of the most frequently cited real-world case studies of ECDSA nonce reuse in security literature.
ECDSA is not the only digital signature scheme used in crypto, and it is worth knowing how it compares to the alternatives. Bitcoin's 2021 Taproot upgrade introduced optional support for an alternative called Schnorr signatures, which are mathematically simpler, allow multiple signatures to be combined ("aggregated") into one, and have provable security properties that are easier for cryptographers to reason about, though correct randomness still matters for both schemes. Ethereum, meanwhile, continues to rely on ECDSA with secp256k1 for standard account signatures, with newer account-abstraction proposals exploring additional signature schemes alongside it rather than replacing it outright. Some newer blockchains bypass ECDSA entirely in favor of a different elliptic-curve signature scheme called EdDSA (used with the Ed25519 curve), which was specifically designed so that its nonce is generated deterministically from the private key and message rather than from a separate random number source - directly closing off the exact category of vulnerability that broke the PS3.
For crypto traders and holders, the practical lesson is less about implementing ECDSA themselves and more about trusting wallet software that does: a well-audited wallet (hardware or software) generates a properly random - or, in the RFC 6979 deterministic-nonce standard now common in modern wallets, properly derived - nonce for every signature automatically, and this is one of the reasons using reputable, widely-audited wallet software matters far more than most users realize. A subtle nonce bug can leak private keys with no warning to the user until funds are already stolen, and unlike a stolen password, a compromised private key cannot simply be reset - any funds still at that address remain permanently at risk until they are moved to a new, uncompromised key.
There is a second, quieter failure mode worth knowing about alongside nonce reuse, because it is what actually bit early Bitcoin users. A nonce does not have to repeat exactly to be dangerous - it only has to be predictable, or drawn from too small a range. If the random number generator produces values with any detectable bias, the private key can be recovered from a collection of signatures using lattice techniques rather than simple algebra, and each additional signature makes the attack easier. In August 2013 a flaw in Android's random number generator affected several Bitcoin wallets on that platform for exactly this reason, and funds were stolen from addresses whose owners had done nothing wrong.
That history explains why the deterministic approach became standard. Deriving the nonce from the private key and the message itself, as RFC 6979 specifies, removes the dependence on the device's randomness entirely - the same message signed by the same key always produces the same signature, which is not a weakness because the key is still needed to produce it. Hardware wallets go further by keeping the key inside a chip designed never to expose it, so even a compromised computer cannot extract what it needs. Neither measure is something a user configures; both are reasons that the choice of wallet is a security decision rather than a matter of interface preference.