ecdsa.h
mbedtls/private_access.h
mbedtls/build_info.h
mbedtls/ecp.h
mbedtls/md.h
crypto_builtin_composites.h
pk.h
mbedtls/bignum.h
mbedtls/build_info.h
mbedtls/check_config.h
mbedtls/config_adjust_legacy_crypto.h
mbedtls/config_adjust_psa_from_legacy.h
mbedtls/config_adjust_psa_superset_legacy.h
mbedtls/config_adjust_ssl.h
mbedtls/config_adjust_x509.h
mbedtls/config_psa.h
ecdsa.h
mbedtls/ecp.h
mbedtls/mbedtls_config.h
mbedtls/md.h
mbedtls/platform_time.h
mbedtls/platform_util.h
mbedtls/private_access.h
psa/crypto_adjust_auto_enabled.h
psa/crypto_adjust_config_dependencies.h
psa/crypto_adjust_config_key_pair_types.h
psa/crypto_adjust_config_synonyms.h
psa/crypto_legacy.h
inttypes.h
limits.h
stddef.h
stdint.h
stdio.h
time.h
debug.h
ecdsa.h
net_sockets.h
oid.h
pk.h
pkcs7.h
psa_util.h
ssl.h
ssl_cache.h
ssl_ciphersuites.h
ssl_cookie.h
ssl_ticket.h
x509.h
x509_crl.h
x509_crt.h
x509_csr.h
crypto.h
crypto_builtin_composites.h
crypto_driver_contexts_composites.h
crypto_struct.h
MBEDTLS_ECDSA_MAX_SIG_LEN
bits
(/*T,L of SEQUENCE*/ ((bits) >= 61 * 8 ? 3 : 2) + \ /*T,L of r,s*/ 2 * (((bits) >= 127 * 8 ? 3 : 2) + \ /*V of r,s*/ ((bits) + 8) / 8))

Maximum ECDSA signature size for a given curve bit size.

bits

Curve size in bits

Maximum signature size in bytes

This macro returns a compile-time constant if its argument is one. It may evaluate its argument multiple times.

MBEDTLS_ECDSA_MAX_LEN
MBEDTLS_ECDSA_MAX_SIG_LEN
(MBEDTLS_ECP_MAX_BITS)

The maximal size of an ECDSA signature in Bytes.

mbedtls_ecp_keypair typedef mbedtls_ecp_keypair mbedtls_ecdsa_context mbedtls_ecdsa_context

The ECDSA context structure.

Performing multiple operations concurrently on the same ECDSA context is not supported; objects of this type should not be shared between multiple threads.

pk_wrap module assumes that "ecdsa_context" is identical to "ecp_keypair" (see for example structure "mbedtls_eckey_info" where ECDSA sign/verify functions are used also for EC key)

void typedef void mbedtls_ecdsa_restart_ctx mbedtls_ecdsa_restart_ctx
int int mbedtls_ecdsa_can_do (mbedtls_ecp_group_id gid) mbedtls_ecdsa_can_do mbedtls_ecp_group_id gid

This function checks whether a given group can be used for ECDSA.

gid

The ECP group ID to check.

`1` if the group can be used, `0` otherwise

int int mbedtls_ecdsa_sign (mbedtls_ecp_group *grp, mbedtls_mpi *r, mbedtls_mpi *s, const mbedtls_mpi *d, const unsigned char *buf, size_t blen, int(*f_rng)(void *, unsigned char *, size_t), void *p_rng) mbedtls_ecdsa_sign mbedtls_ecp_group * grp mbedtls_mpi * r mbedtls_mpi * s const mbedtls_mpi * d const unsigned char * buf size_t blen int(*)(void *, unsigned char *, size_t) f_rng void * p_rng

This function computes the ECDSA signature of a previously-hashed message.

The deterministic version implemented in mbedtls_ecdsa_sign_det_ext() is usually preferred.

If the bitlength of the message hash is larger than the bitlength of the group order, then the hash is truncated as defined in Standards for Efficient Cryptography Group (SECG): SEC1 Elliptic Curve Cryptography, section 4.1.3, step 5.

ecp.h

grp

The context for the elliptic curve to use. This must be initialized and have group parameters set, for example through mbedtls_ecp_group_load().

r

The MPI context in which to store the first part the signature. This must be initialized.

s

The MPI context in which to store the second part the signature. This must be initialized.

d

The private signing key. This must be initialized.

buf

The content to be signed. This is usually the hash of the original data to be signed. This must be a readable buffer of length `blen` Bytes. It may be `NULL` if `blen` is zero.

blen

The length of `buf` in Bytes.

f_rng

The RNG function. This must not be `NULL`.

p_rng

The RNG context to be passed to `f_rng`. This may be `NULL` if `f_rng` doesn't need a context parameter.

`0` on success.

An `MBEDTLS_ERR_ECP_XXX` or `MBEDTLS_MPI_XXX` error code on failure.

int int mbedtls_ecdsa_sign_det_ext (mbedtls_ecp_group *grp, mbedtls_mpi *r, mbedtls_mpi *s, const mbedtls_mpi *d, const unsigned char *buf, size_t blen, mbedtls_md_type_t md_alg, int(*f_rng_blind)(void *, unsigned char *, size_t), void *p_rng_blind) mbedtls_ecdsa_sign_det_ext mbedtls_ecp_group * grp mbedtls_mpi * r mbedtls_mpi * s const mbedtls_mpi * d const unsigned char * buf size_t blen mbedtls_md_type_t md_alg int(*)(void *, unsigned char *, size_t) f_rng_blind void * p_rng_blind

This function computes the ECDSA signature of a previously-hashed message, deterministic version.

For more information, see RFC-6979: Deterministic Usage of the Digital Signature Algorithm (DSA) and Elliptic Curve Digital Signature Algorithm (ECDSA).

If the bitlength of the message hash is larger than the bitlength of the group order, then the hash is truncated as defined in Standards for Efficient Cryptography Group (SECG): SEC1 Elliptic Curve Cryptography, section 4.1.3, step 5.

ecp.h

grp

The context for the elliptic curve to use. This must be initialized and have group parameters set, for example through mbedtls_ecp_group_load().

r

The MPI context in which to store the first part the signature. This must be initialized.

s

The MPI context in which to store the second part the signature. This must be initialized.

d

The private signing key. This must be initialized and setup, for example through mbedtls_ecp_gen_privkey().

buf

The hashed content to be signed. This must be a readable buffer of length `blen` Bytes. It may be `NULL` if `blen` is zero.

blen

The length of `buf` in Bytes.

md_alg

The hash algorithm used to hash the original data.

f_rng_blind

The RNG function used for blinding. This must not be `NULL`.

p_rng_blind

The RNG context to be passed to `f_rng_blind`. This may be `NULL` if `f_rng_blind` doesn't need a context parameter.

`0` on success.

An `MBEDTLS_ERR_ECP_XXX` or `MBEDTLS_MPI_XXX` error code on failure.

int int mbedtls_ecdsa_sign_restartable (mbedtls_ecp_group *grp, mbedtls_mpi *r, mbedtls_mpi *s, const mbedtls_mpi *d, const unsigned char *buf, size_t blen, int(*f_rng)(void *, unsigned char *, size_t), void *p_rng, int(*f_rng_blind)(void *, unsigned char *, size_t), void *p_rng_blind, mbedtls_ecdsa_restart_ctx *rs_ctx) mbedtls_ecdsa_sign_restartable mbedtls_ecp_group * grp mbedtls_mpi * r mbedtls_mpi * s const mbedtls_mpi * d const unsigned char * buf size_t blen int(*)(void *, unsigned char *, size_t) f_rng void * p_rng int(*)(void *, unsigned char *, size_t) f_rng_blind void * p_rng_blind mbedtls_ecdsa_restart_ctx * rs_ctx

This function computes the ECDSA signature of a previously-hashed message, in a restartable way.

The deterministic version implemented in mbedtls_ecdsa_sign_det_restartable() is usually preferred.

This function is like `mbedtls_ecdsa_sign()` but it can return early and restart according to the limit set with `mbedtls_ecp_set_max_ops()` to reduce blocking.

If the bitlength of the message hash is larger than the bitlength of the group order, then the hash is truncated as defined in Standards for Efficient Cryptography Group (SECG): SEC1 Elliptic Curve Cryptography, section 4.1.3, step 5.

ecp.h

grp

The context for the elliptic curve to use. This must be initialized and have group parameters set, for example through mbedtls_ecp_group_load().

r

The MPI context in which to store the first part the signature. This must be initialized.

s

The MPI context in which to store the second part the signature. This must be initialized.

d

The private signing key. This must be initialized and setup, for example through mbedtls_ecp_gen_privkey().

buf

The hashed content to be signed. This must be a readable buffer of length `blen` Bytes. It may be `NULL` if `blen` is zero.

blen

The length of `buf` in Bytes.

f_rng

The RNG function. This must not be `NULL`.

p_rng

The RNG context to be passed to `f_rng`. This may be `NULL` if `f_rng` doesn't need a context parameter.

f_rng_blind

The RNG function used for blinding. This must not be `NULL`.

p_rng_blind

The RNG context to be passed to `f_rng`. This may be `NULL` if `f_rng` doesn't need a context parameter.

rs_ctx

The restart context to use. This may be `NULL` to disable restarting. If it is not `NULL`, it must point to an initialized restart context.

`0` on success.

MBEDTLS_ERR_ECP_IN_PROGRESS if maximum number of operations was reached: see `mbedtls_ecp_set_max_ops()`.

Another `MBEDTLS_ERR_ECP_XXX`, `MBEDTLS_ERR_MPI_XXX` or `MBEDTLS_ERR_ASN1_XXX` error code on failure.

int int mbedtls_ecdsa_sign_det_restartable (mbedtls_ecp_group *grp, mbedtls_mpi *r, mbedtls_mpi *s, const mbedtls_mpi *d, const unsigned char *buf, size_t blen, mbedtls_md_type_t md_alg, int(*f_rng_blind)(void *, unsigned char *, size_t), void *p_rng_blind, mbedtls_ecdsa_restart_ctx *rs_ctx) mbedtls_ecdsa_sign_det_restartable mbedtls_ecp_group * grp mbedtls_mpi * r mbedtls_mpi * s const mbedtls_mpi * d const unsigned char * buf size_t blen mbedtls_md_type_t md_alg int(*)(void *, unsigned char *, size_t) f_rng_blind void * p_rng_blind mbedtls_ecdsa_restart_ctx * rs_ctx

This function computes the ECDSA signature of a previously-hashed message, in a restartable way.

This function is like `mbedtls_ecdsa_sign_det_ext()` but it can return early and restart according to the limit set with `mbedtls_ecp_set_max_ops()` to reduce blocking.

If the bitlength of the message hash is larger than the bitlength of the group order, then the hash is truncated as defined in Standards for Efficient Cryptography Group (SECG): SEC1 Elliptic Curve Cryptography, section 4.1.3, step 5.

ecp.h

grp

The context for the elliptic curve to use. This must be initialized and have group parameters set, for example through mbedtls_ecp_group_load().

r

The MPI context in which to store the first part the signature. This must be initialized.

s

The MPI context in which to store the second part the signature. This must be initialized.

d

The private signing key. This must be initialized and setup, for example through mbedtls_ecp_gen_privkey().

buf

The hashed content to be signed. This must be a readable buffer of length `blen` Bytes. It may be `NULL` if `blen` is zero.

blen

The length of `buf` in Bytes.

md_alg

The hash algorithm used to hash the original data.

f_rng_blind

The RNG function used for blinding. This must not be `NULL`.

p_rng_blind

The RNG context to be passed to `f_rng_blind`. This may be `NULL` if `f_rng_blind` doesn't need a context parameter.

rs_ctx

The restart context to use. This may be `NULL` to disable restarting. If it is not `NULL`, it must point to an initialized restart context.

`0` on success.

MBEDTLS_ERR_ECP_IN_PROGRESS if maximum number of operations was reached: see `mbedtls_ecp_set_max_ops()`.

Another `MBEDTLS_ERR_ECP_XXX`, `MBEDTLS_ERR_MPI_XXX` or `MBEDTLS_ERR_ASN1_XXX` error code on failure.

int int mbedtls_ecdsa_verify (mbedtls_ecp_group *grp, const unsigned char *buf, size_t blen, const mbedtls_ecp_point *Q, const mbedtls_mpi *r, const mbedtls_mpi *s) mbedtls_ecdsa_verify mbedtls_ecp_group * grp const unsigned char * buf size_t blen const mbedtls_ecp_point * Q const mbedtls_mpi * r const mbedtls_mpi * s

This function verifies the ECDSA signature of a previously-hashed message.

If the bitlength of the message hash is larger than the bitlength of the group order, then the hash is truncated as defined in Standards for Efficient Cryptography Group (SECG): SEC1 Elliptic Curve Cryptography, section 4.1.4, step 3.

ecp.h

grp

The ECP group to use. This must be initialized and have group parameters set, for example through mbedtls_ecp_group_load().

buf

The hashed content that was signed. This must be a readable buffer of length `blen` Bytes. It may be `NULL` if `blen` is zero.

blen

The length of `buf` in Bytes.

Q

The public key to use for verification. This must be initialized and setup.

r

The first integer of the signature. This must be initialized.

s

The second integer of the signature. This must be initialized.

`0` on success.

An `MBEDTLS_ERR_ECP_XXX` or `MBEDTLS_MPI_XXX` error code on failure.

int int mbedtls_ecdsa_verify_restartable (mbedtls_ecp_group *grp, const unsigned char *buf, size_t blen, const mbedtls_ecp_point *Q, const mbedtls_mpi *r, const mbedtls_mpi *s, mbedtls_ecdsa_restart_ctx *rs_ctx) mbedtls_ecdsa_verify_restartable mbedtls_ecp_group * grp const unsigned char * buf size_t blen const mbedtls_ecp_point * Q const mbedtls_mpi * r const mbedtls_mpi * s mbedtls_ecdsa_restart_ctx * rs_ctx

This function verifies the ECDSA signature of a previously-hashed message, in a restartable manner.

If the bitlength of the message hash is larger than the bitlength of the group order, then the hash is truncated as defined in Standards for Efficient Cryptography Group (SECG): SEC1 Elliptic Curve Cryptography, section 4.1.4, step 3.

ecp.h

grp

The ECP group to use. This must be initialized and have group parameters set, for example through mbedtls_ecp_group_load().

buf

The hashed content that was signed. This must be a readable buffer of length `blen` Bytes. It may be `NULL` if `blen` is zero.

blen

The length of `buf` in Bytes.

Q

The public key to use for verification. This must be initialized and setup.

r

The first integer of the signature. This must be initialized.

s

The second integer of the signature. This must be initialized.

rs_ctx

The restart context to use. This may be `NULL` to disable restarting. If it is not `NULL`, it must point to an initialized restart context.

`0` on success.

MBEDTLS_ERR_ECP_IN_PROGRESS if maximum number of operations was reached: see `mbedtls_ecp_set_max_ops()`.

An `MBEDTLS_ERR_ECP_XXX` or `MBEDTLS_MPI_XXX` error code on failure.

int int mbedtls_ecdsa_write_signature (mbedtls_ecdsa_context *ctx, mbedtls_md_type_t md_alg, const unsigned char *hash, size_t hlen, unsigned char *sig, size_t sig_size, size_t *slen, int(*f_rng)(void *, unsigned char *, size_t), void *p_rng) mbedtls_ecdsa_write_signature mbedtls_ecdsa_context * ctx mbedtls_md_type_t md_alg const unsigned char * hash size_t hlen unsigned char * sig size_t sig_size size_t * slen int(*)(void *, unsigned char *, size_t) f_rng void * p_rng

This function computes the ECDSA signature and writes it to a buffer, serialized as defined in RFC-4492: Elliptic Curve Cryptography (ECC) Cipher Suites for Transport Layer Security (TLS).

It is not thread-safe to use the same context in multiple threads.

The deterministic version is used if MBEDTLS_ECDSA_DETERMINISTIC is defined. For more information, see RFC-6979: Deterministic Usage of the Digital Signature Algorithm (DSA) and Elliptic Curve Digital Signature Algorithm (ECDSA).

If the bitlength of the message hash is larger than the bitlength of the group order, then the hash is truncated as defined in Standards for Efficient Cryptography Group (SECG): SEC1 Elliptic Curve Cryptography, section 4.1.3, step 5.

ecp.h

ctx

The ECDSA context to use. This must be initialized and have a group and private key bound to it, for example via mbedtls_ecdsa_genkey() or mbedtls_ecdsa_from_keypair().

md_alg

The message digest that was used to hash the message.

hash

The message hash to be signed. This must be a readable buffer of length `hlen` Bytes.

hlen

The length of the hash `hash` in Bytes.

sig

The buffer to which to write the signature. This must be a writable buffer of length at least twice as large as the size of the curve used, plus 9. For example, 73 Bytes if a 256-bit curve is used. A buffer length of MBEDTLS_ECDSA_MAX_LEN is always safe.

sig_size

The size of the `sig` buffer in bytes.

slen

The address at which to store the actual length of the signature written. Must not be `NULL`.

f_rng

The RNG function. This must not be `NULL` if MBEDTLS_ECDSA_DETERMINISTIC is unset. Otherwise, it is used only for blinding and may be set to `NULL`, but doing so is DEPRECATED.

p_rng

The RNG context to be passed to `f_rng`. This may be `NULL` if `f_rng` is `NULL` or doesn't use a context.

`0` on success.

An `MBEDTLS_ERR_ECP_XXX`, `MBEDTLS_ERR_MPI_XXX` or `MBEDTLS_ERR_ASN1_XXX` error code on failure.

int int mbedtls_ecdsa_write_signature_restartable (mbedtls_ecdsa_context *ctx, mbedtls_md_type_t md_alg, const unsigned char *hash, size_t hlen, unsigned char *sig, size_t sig_size, size_t *slen, int(*f_rng)(void *, unsigned char *, size_t), void *p_rng, mbedtls_ecdsa_restart_ctx *rs_ctx) mbedtls_ecdsa_write_signature_restartable mbedtls_ecdsa_context * ctx mbedtls_md_type_t md_alg const unsigned char * hash size_t hlen unsigned char * sig size_t sig_size size_t * slen int(*)(void *, unsigned char *, size_t) f_rng void * p_rng mbedtls_ecdsa_restart_ctx * rs_ctx

This function computes the ECDSA signature and writes it to a buffer, in a restartable way.

`mbedtls_ecdsa_write_signature()`

This function is like `mbedtls_ecdsa_write_signature()` but it can return early and restart according to the limit set with `mbedtls_ecp_set_max_ops()` to reduce blocking.

ctx

The ECDSA context to use. This must be initialized and have a group and private key bound to it, for example via mbedtls_ecdsa_genkey() or mbedtls_ecdsa_from_keypair().

md_alg

The message digest that was used to hash the message.

hash

The message hash to be signed. This must be a readable buffer of length `hlen` Bytes.

hlen

The length of the hash `hash` in Bytes.

sig

The buffer to which to write the signature. This must be a writable buffer of length at least twice as large as the size of the curve used, plus 9. For example, 73 Bytes if a 256-bit curve is used. A buffer length of MBEDTLS_ECDSA_MAX_LEN is always safe.

sig_size

The size of the `sig` buffer in bytes.

slen

The address at which to store the actual length of the signature written. Must not be `NULL`.

f_rng

The RNG function. This must not be `NULL` if MBEDTLS_ECDSA_DETERMINISTIC is unset. Otherwise, it is unused and may be set to `NULL`.

p_rng

The RNG context to be passed to `f_rng`. This may be `NULL` if `f_rng` is `NULL` or doesn't use a context.

rs_ctx

The restart context to use. This may be `NULL` to disable restarting. If it is not `NULL`, it must point to an initialized restart context.

`0` on success.

MBEDTLS_ERR_ECP_IN_PROGRESS if maximum number of operations was reached: see `mbedtls_ecp_set_max_ops()`.

Another `MBEDTLS_ERR_ECP_XXX`, `MBEDTLS_ERR_MPI_XXX` or `MBEDTLS_ERR_ASN1_XXX` error code on failure.

int int mbedtls_ecdsa_read_signature (mbedtls_ecdsa_context *ctx, const unsigned char *hash, size_t hlen, const unsigned char *sig, size_t slen) mbedtls_ecdsa_read_signature mbedtls_ecdsa_context * ctx const unsigned char * hash size_t hlen const unsigned char * sig size_t slen

This function reads and verifies an ECDSA signature.

If the bitlength of the message hash is larger than the bitlength of the group order, then the hash is truncated as defined in Standards for Efficient Cryptography Group (SECG): SEC1 Elliptic Curve Cryptography, section 4.1.4, step 3.

ecp.h

ctx

The ECDSA context to use. This must be initialized and have a group and public key bound to it.

hash

The message hash that was signed. This must be a readable buffer of length `hlen` Bytes.

hlen

The size of the hash `hash`.

sig

The signature to read and verify. This must be a readable buffer of length `slen` Bytes.

slen

The size of `sig` in Bytes.

`0` on success.

MBEDTLS_ERR_ECP_BAD_INPUT_DATA if signature is invalid.

MBEDTLS_ERR_ECP_SIG_LEN_MISMATCH if there is a valid signature in `sig`, but its length is less than `siglen`.

An `MBEDTLS_ERR_ECP_XXX` or `MBEDTLS_ERR_MPI_XXX` error code on failure for any other reason.

int int mbedtls_ecdsa_read_signature_restartable (mbedtls_ecdsa_context *ctx, const unsigned char *hash, size_t hlen, const unsigned char *sig, size_t slen, mbedtls_ecdsa_restart_ctx *rs_ctx) mbedtls_ecdsa_read_signature_restartable mbedtls_ecdsa_context * ctx const unsigned char * hash size_t hlen const unsigned char * sig size_t slen mbedtls_ecdsa_restart_ctx * rs_ctx

This function reads and verifies an ECDSA signature, in a restartable way.

`mbedtls_ecdsa_read_signature()`

This function is like `mbedtls_ecdsa_read_signature()` but it can return early and restart according to the limit set with `mbedtls_ecp_set_max_ops()` to reduce blocking.

ctx

The ECDSA context to use. This must be initialized and have a group and public key bound to it.

hash

The message hash that was signed. This must be a readable buffer of length `hlen` Bytes.

hlen

The size of the hash `hash`.

sig

The signature to read and verify. This must be a readable buffer of length `slen` Bytes.

slen

The size of `sig` in Bytes.

rs_ctx

The restart context to use. This may be `NULL` to disable restarting. If it is not `NULL`, it must point to an initialized restart context.

`0` on success.

MBEDTLS_ERR_ECP_BAD_INPUT_DATA if signature is invalid.

MBEDTLS_ERR_ECP_SIG_LEN_MISMATCH if there is a valid signature in `sig`, but its length is less than `siglen`.

MBEDTLS_ERR_ECP_IN_PROGRESS if maximum number of operations was reached: see `mbedtls_ecp_set_max_ops()`.

Another `MBEDTLS_ERR_ECP_XXX` or `MBEDTLS_ERR_MPI_XXX` error code on failure for any other reason.

int int mbedtls_ecdsa_genkey (mbedtls_ecdsa_context *ctx, mbedtls_ecp_group_id gid, int(*f_rng)(void *, unsigned char *, size_t), void *p_rng) mbedtls_ecdsa_genkey mbedtls_ecdsa_context * ctx mbedtls_ecp_group_id gid int(*)(void *, unsigned char *, size_t) f_rng void * p_rng

This function generates an ECDSA keypair on the given curve.

ecp.h

ctx

The ECDSA context to store the keypair in. This must be initialized.

gid

The elliptic curve to use. One of the various `MBEDTLS_ECP_DP_XXX` macros depending on configuration.

f_rng

The RNG function to use. This must not be `NULL`.

p_rng

The RNG context to be passed to `f_rng`. This may be `NULL` if `f_rng` doesn't need a context argument.

`0` on success.

An `MBEDTLS_ERR_ECP_XXX` code on failure.

int int mbedtls_ecdsa_from_keypair (mbedtls_ecdsa_context *ctx, const mbedtls_ecp_keypair *key) mbedtls_ecdsa_from_keypair mbedtls_ecdsa_context * ctx const mbedtls_ecp_keypair * key

This function sets up an ECDSA context from an EC key pair.

ecp.h

ctx

The ECDSA context to setup. This must be initialized.

key

The EC key to use. This must be initialized and hold a private-public key pair or a public key. In the former case, the ECDSA context may be used for signature creation and verification after this call. In the latter case, it may be used for signature verification.

`0` on success.

An `MBEDTLS_ERR_ECP_XXX` code on failure.

void void mbedtls_ecdsa_init (mbedtls_ecdsa_context *ctx) mbedtls_ecdsa_init mbedtls_ecdsa_context * ctx

This function initializes an ECDSA context.

ctx

The ECDSA context to initialize. This must not be `NULL`.

void void mbedtls_ecdsa_free (mbedtls_ecdsa_context *ctx) mbedtls_ecdsa_free mbedtls_ecdsa_context * ctx

This function frees an ECDSA context.

ctx

The ECDSA context to free. This may be `NULL`, in which case this function does nothing. If it is not `NULL`, it must be initialized.

This file contains ECDSA definitions and functions.

The Elliptic Curve Digital Signature Algorithm (ECDSA) is defined in Standards for Efficient Cryptography Group (SECG): SEC1 Elliptic Curve Cryptography. The use of ECDSA for TLS is defined in RFC-4492: Elliptic Curve Cryptography (ECC) Cipher Suites for Transport Layer Security (TLS).

    /*
    *CopyrightTheMbedTLSContributors
    *SPDX-License-Identifier:Apache-2.0ORGPL-2.0-or-later
    */

    #ifndefMBEDTLS_ECDSA_H
    #defineMBEDTLS_ECDSA_H
    #include"mbedtls/private_access.h"

    #include"mbedtls/build_info.h"

    #include"mbedtls/ecp.h"
    #include"mbedtls/md.h"

    /*
    *Ecdsa-Sig-Value::=SEQUENCE{
    *rINTEGER,
    *sINTEGER
    *}
    *
    *Foreachofrands,thevalue(V)mayincludeanextrainitial"0"bit.
    */
    #defineMBEDTLS_ECDSA_MAX_SIG_LEN(bits)\
    (/*T,LofSEQUENCE*/((bits)>=61*8?3:2)+\
    /*T,Lofr,s*/2*(((bits)>=127*8?3:2)+\
    /*Vofr,s*/((bits)+8)/8))

    #defineMBEDTLS_ECDSA_MAX_LENMBEDTLS_ECDSA_MAX_SIG_LEN(MBEDTLS_ECP_MAX_BITS)

    #ifdef__cplusplus
    extern"C"{
    #endif

    typedefmbedtls_ecp_keypairmbedtls_ecdsa_context;

    #ifdefined(MBEDTLS_ECP_RESTARTABLE)

    typedefstructmbedtls_ecdsa_restart_vermbedtls_ecdsa_restart_ver_ctx;

    typedefstructmbedtls_ecdsa_restart_sigmbedtls_ecdsa_restart_sig_ctx;

    #ifdefined(MBEDTLS_ECDSA_DETERMINISTIC)
    typedefstructmbedtls_ecdsa_restart_detmbedtls_ecdsa_restart_det_ctx;
    #endif

    typedefstruct{
    mbedtls_ecp_restart_ctxMBEDTLS_PRIVATE(ecp);
    mbedtls_ecdsa_restart_ver_ctx*MBEDTLS_PRIVATE(ver);
    mbedtls_ecdsa_restart_sig_ctx*MBEDTLS_PRIVATE(sig);
    #ifdefined(MBEDTLS_ECDSA_DETERMINISTIC)
    mbedtls_ecdsa_restart_det_ctx*MBEDTLS_PRIVATE(det);
    #endif
    }mbedtls_ecdsa_restart_ctx;

    #else/*MBEDTLS_ECP_RESTARTABLE*/

    /*Nowwecandeclarefunctionsthattakeapointertothat*/
    typedefvoidmbedtls_ecdsa_restart_ctx;

    #endif/*MBEDTLS_ECP_RESTARTABLE*/

    intmbedtls_ecdsa_can_do(mbedtls_ecp_group_idgid);

    intmbedtls_ecdsa_sign(mbedtls_ecp_group*grp,mbedtls_mpi*r,mbedtls_mpi*s,
    constmbedtls_mpi*d,constunsignedchar*buf,size_tblen,
    int(*f_rng)(void*,unsignedchar*,size_t),void*p_rng);

    #ifdefined(MBEDTLS_ECDSA_DETERMINISTIC)
    intmbedtls_ecdsa_sign_det_ext(mbedtls_ecp_group*grp,mbedtls_mpi*r,
    mbedtls_mpi*s,constmbedtls_mpi*d,
    constunsignedchar*buf,size_tblen,
    mbedtls_md_type_tmd_alg,
    int(*f_rng_blind)(void*,unsignedchar*,size_t),
    void*p_rng_blind);
    #endif/*MBEDTLS_ECDSA_DETERMINISTIC*/

    #if!defined(MBEDTLS_ECDSA_SIGN_ALT)
    intmbedtls_ecdsa_sign_restartable(
    mbedtls_ecp_group*grp,
    mbedtls_mpi*r,mbedtls_mpi*s,
    constmbedtls_mpi*d,
    constunsignedchar*buf,size_tblen,
    int(*f_rng)(void*,unsignedchar*,size_t),
    void*p_rng,
    int(*f_rng_blind)(void*,unsignedchar*,size_t),
    void*p_rng_blind,
    mbedtls_ecdsa_restart_ctx*rs_ctx);

    #endif/*!MBEDTLS_ECDSA_SIGN_ALT*/

    #ifdefined(MBEDTLS_ECDSA_DETERMINISTIC)

    intmbedtls_ecdsa_sign_det_restartable(
    mbedtls_ecp_group*grp,
    mbedtls_mpi*r,mbedtls_mpi*s,
    constmbedtls_mpi*d,constunsignedchar*buf,size_tblen,
    mbedtls_md_type_tmd_alg,
    int(*f_rng_blind)(void*,unsignedchar*,size_t),
    void*p_rng_blind,
    mbedtls_ecdsa_restart_ctx*rs_ctx);

    #endif/*MBEDTLS_ECDSA_DETERMINISTIC*/

    intmbedtls_ecdsa_verify(mbedtls_ecp_group*grp,
    constunsignedchar*buf,size_tblen,
    constmbedtls_ecp_point*Q,constmbedtls_mpi*r,
    constmbedtls_mpi*s);

    #if!defined(MBEDTLS_ECDSA_VERIFY_ALT)
    intmbedtls_ecdsa_verify_restartable(mbedtls_ecp_group*grp,
    constunsignedchar*buf,size_tblen,
    constmbedtls_ecp_point*Q,
    constmbedtls_mpi*r,
    constmbedtls_mpi*s,
    mbedtls_ecdsa_restart_ctx*rs_ctx);

    #endif/*!MBEDTLS_ECDSA_VERIFY_ALT*/

    intmbedtls_ecdsa_write_signature(mbedtls_ecdsa_context*ctx,
    mbedtls_md_type_tmd_alg,
    constunsignedchar*hash,size_thlen,
    unsignedchar*sig,size_tsig_size,size_t*slen,
    int(*f_rng)(void*,unsignedchar*,size_t),
    void*p_rng);

    intmbedtls_ecdsa_write_signature_restartable(mbedtls_ecdsa_context*ctx,
    mbedtls_md_type_tmd_alg,
    constunsignedchar*hash,size_thlen,
    unsignedchar*sig,size_tsig_size,size_t*slen,
    int(*f_rng)(void*,unsignedchar*,size_t),
    void*p_rng,
    mbedtls_ecdsa_restart_ctx*rs_ctx);

    intmbedtls_ecdsa_read_signature(mbedtls_ecdsa_context*ctx,
    constunsignedchar*hash,size_thlen,
    constunsignedchar*sig,size_tslen);

    intmbedtls_ecdsa_read_signature_restartable(mbedtls_ecdsa_context*ctx,
    constunsignedchar*hash,size_thlen,
    constunsignedchar*sig,size_tslen,
    mbedtls_ecdsa_restart_ctx*rs_ctx);

    intmbedtls_ecdsa_genkey(mbedtls_ecdsa_context*ctx,mbedtls_ecp_group_idgid,
    int(*f_rng)(void*,unsignedchar*,size_t),void*p_rng);

    intmbedtls_ecdsa_from_keypair(mbedtls_ecdsa_context*ctx,
    constmbedtls_ecp_keypair*key);

    voidmbedtls_ecdsa_init(mbedtls_ecdsa_context*ctx);

    voidmbedtls_ecdsa_free(mbedtls_ecdsa_context*ctx);

    #ifdefined(MBEDTLS_ECP_RESTARTABLE)
    voidmbedtls_ecdsa_restart_init(mbedtls_ecdsa_restart_ctx*ctx);

    voidmbedtls_ecdsa_restart_free(mbedtls_ecdsa_restart_ctx*ctx);
    #endif/*MBEDTLS_ECP_RESTARTABLE*/

    #ifdef__cplusplus
    }
    #endif

    #endif/*ecdsa.h*/