ECDSA_SIGN(3ossl)

📦

version 3.5.9 · 8 versions

3.5.9 · fedora 43, fedora 44 (latest)
3.5.9 · centos-stream 9
3.5.9 · centos-stream 10
3.5.9 · alpine 3.22
3.5.9 · alpine 3.23, alpine 3.24
3.5.8 · fedora 43
3.5.1 · fedora 43
3.5.5 · fedora 44

💖 ECDSA_size, ECDSA_sign, ECDSA_do_sign, ECDSA_verify, ECDSA_do_verify, ECDSA_sign_setup, ECDSA_sign_ex, ECDSA_do_sign_ex — the deprecated low-level elliptic curve digital signature algorithm (ECDSA) girlies 💅

okay bestie, so this is the OpenSSL manpage for the low-level ECDSA functions, and I need you to know upfront: every single one of these is deprecated. like, they're the vintage collection. still iconic, still in the docs, but we do not build new stuff on them. periodt.

✨ NAME ✨

ECDSA_size, ECDSA_sign, ECDSA_do_sign, ECDSA_verify, ECDSA_do_verify, ECDSA_sign_setup, ECDSA_sign_ex, ECDSA_do_sign_ex — deprecated low-level elliptic curve digital signature algorithm (ECDSA) functions. 🦋

✨ SYNOPSIS ✨

#include <openssl/ecdsa.h>

🚨 bestie listen. The following functions have been deprecated since OpenSSL 3.0, and can be hidden entirely by defining OPENSSL_API_COMPAT with a suitable version value, see openssl_user_macros(7). yes, they can just... vanish on you. no cap.

int ECDSA_size(const EC_KEY *eckey);

int ECDSA_sign(int type, const unsigned char *dgst, int dgstlen,
               unsigned char *sig, unsigned int *siglen, EC_KEY *eckey);
ECDSA_SIG *ECDSA_do_sign(const unsigned char *dgst, int dgst_len,
                         EC_KEY *eckey);

int ECDSA_verify(int type, const unsigned char *dgst, int dgstlen,
                 const unsigned char *sig, int siglen, EC_KEY *eckey);
int ECDSA_do_verify(const unsigned char *dgst, int dgst_len,
                    const ECDSA_SIG *sig, EC_KEY* eckey);

ECDSA_SIG *ECDSA_do_sign_ex(const unsigned char *dgst, int dgstlen,
                            const BIGNUM *kinv, const BIGNUM *rp,
                            EC_KEY *eckey);
int ECDSA_sign_setup(EC_KEY *eckey, BN_CTX *ctx, BIGNUM **kinv, BIGNUM **rp);
int ECDSA_sign_ex(int type, const unsigned char *dgst, int dgstlen,
                  unsigned char *sig, unsigned int *siglen,
                  const BIGNUM *kinv, const BIGNUM *rp, EC_KEY *eckey);

🌸 DESCRIPTION 🌸

Want the tea on the ECDSA_SIG object itself? Go read ECDSA_SIG_new(3), it's all there. 💜

Encoding and decoding ECDSA signatures to/from DER? That's i2d_ECDSA_SIG(3) and d2i_ECDSA_SIG(3). 🎀

All of the functions described below are deprecated. Like, every one. Applications should use the higher level EVP interface such as EVP_DigestSignInit(3) or EVP_DigestVerifyInit(3) instead. that's the glow-up, bestie. ✨

ECDSA_size() — returns the maximum length of a DER encoded ECDSA signature created with the private EC key eckey. Wanna know the actual signature size instead of the ceiling? Use EVP_PKEY_sign(3) with a NULL sig parameter. 👑
ECDSA_sign() — computes a digital signature of the dgstlen bytes hash value dgst using the private EC key eckey. The DER encoded signature gets stored in sig and its length comes back in siglen. ⚠️ Note: sig must point to ECDSA_size(eckey) bytes of memory. The parameter type is currently ignored (literally just vibing there, doing nothing). ECDSA_sign() is a wrapper function for ECDSA_sign_ex() with kinv and rp set to NULL.
ECDSA_do_sign() — similar to ECDSA_sign() except the signature is returned as a newly allocated ECDSA_SIG structure (or NULL on error). It's a wrapper function for ECDSA_do_sign_ex() with kinv and rp set to NULL. 🫶
ECDSA_verify() — verifies that the signature in sig of size siglen is a valid ECDSA signature of the hash value dgst of size dgstlen using the public key eckey. The parameter type is ignored. vibe check passed or not, we'll see. 💅
ECDSA_do_verify() — similar to ECDSA_verify() except the signature is presented in the form of a pointer to an ECDSA_SIG structure.

The remaining functions utilise the internal kinv and r values used during signature computation. Most applications will never need to call these, and some external ECDSA ENGINE implementations may not support them at all if either kinv or r is not NULL. so like... proceed with caution, bestie. 😭

ECDSA_sign_setup() — may be used to precompute parts of the signing operation. eckey is the private EC key and ctx is a pointer to BN_CTX structure (or NULL). The precomputed values are returned in kinv and rp and can be used in a later call to ECDSA_sign_ex() or ECDSA_do_sign_ex(). pre-gaming the math, essentially. 🍓
ECDSA_sign_ex() — computes a digital signature of the dgstlen bytes hash value dgst using the private EC key eckey and the optional pre-computed values kinv and rp. The DER encoded signature is stored in sig and its length is returned in siglen. ⚠️ Note: sig must point to ECDSA_size(eckey) bytes of memory. The parameter type is ignored.
ECDSA_do_sign_ex() — similar to ECDSA_sign_ex() except the signature is returned as a newly allocated ECDSA_SIG structure (or NULL on error).

🌈 RETURN VALUES 🌈

ECDSA_size() — returns the maximum length signature, or 0 on error. 💀
ECDSA_sign(), ECDSA_sign_ex() and ECDSA_sign_setup() — return 1 if successful, or 0 on error.
ECDSA_do_sign() and ECDSA_do_sign_ex() — return a pointer to an allocated ECDSA_SIG structure, or NULL on error.
ECDSA_verify() and ECDSA_do_verify() — return 1 for a valid signature, 0 for an invalid signature, and -1 on error. The error codes can be obtained by ERR_get_error(3).

🫶 reminder that 1 / 0 / -1 are three different things here, bestie. don't conflate a bad signature with a broken call, iykyk.

🧚 EXAMPLES 🧚

Creating an ECDSA signature of a given SHA-256 hash value using the named curve prime256v1 (aka P-256). ⭐ This example uses deprecated functionality. See "DESCRIPTION". (yes we're using the vintage stuff on purpose, it's a museum tour 🎀)

First step: create an EC_KEY object (note: this part is not ECDSA specific)

int ret;
ECDSA_SIG *sig;
EC_KEY *eckey;

eckey = EC_KEY_new_by_curve_name(NID_X9_62_prime256v1);
if (eckey == NULL)
    /* error */
if (EC_KEY_generate_key(eckey) == 0)
    /* error */

Second step: compute the ECDSA signature of a SHA-256 hash value using ECDSA_do_sign():

sig = ECDSA_do_sign(digest, 32, eckey);
if (sig == NULL)
    /* error */

or using ECDSA_sign():

unsigned char *buffer, *pp;
int buf_len;

buf_len = ECDSA_size(eckey);
buffer = OPENSSL_malloc(buf_len);
pp = buffer;
if (ECDSA_sign(0, dgst, dgstlen, pp, &buf_len, eckey) == 0)
    /* error */

Third step: verify the created ECDSA signature using ECDSA_do_verify():

ret = ECDSA_do_verify(digest, 32, sig, eckey);

or using ECDSA_verify():

ret = ECDSA_verify(0, digest, 32, buffer, buf_len, eckey);

and finally evaluate the return value:

if (ret == 1)
    /* signature ok */
else if (ret == 0)
    /* incorrect signature */
else
    /* error */

👑 CONFORMING TO 👑

ANSI X9.62, US Federal Information Processing Standard FIPS186-2 (Digital Signature Standard, DSS). she's certified, she's compliant, she's got receipts. 💅

🦋 HISTORY 🦋

All functionality described here was deprecated in OpenSSL 3.0. like, the whole page. every function. rest in peace to the low-level era. 😭

📜 COPYRIGHT 📜

Licensed under the Apache License 2.0 (the "License"). You may not use this file except in compliance with the License. You can obtain a copy in the file LICENSE in the source distribution or at <https://www.openssl.org/source/license.html>.

and that's the whole page, bestie!! 💖 this was ECDSA_SIGN(3ossl) from OpenSSL 3.5.9, dated 2026-09-29 — so go forth, use the EVP interface instead, and stay iconic. mwah. 💅✨🎀

📦 where this page comes from

fedora 43: openssl-devel 1:3.5.9-1.fc43 · Apache-2.0
fedora 43: openssl-devel 1:3.5.9-1.fc43 · Apache-2.0
fedora 44: openssl-devel 1:3.5.9-1.fc44 · Apache-2.0
fedora 44: openssl-devel 1:3.5.9-1.fc44 · Apache-2.0
💖 girlified by deepseek-ai/DeepSeek-V4.1-Flash on 2026-10-14: a language model's rewrite of the original, under its terms