/work/mbedtls-3.6.6/library/pkwrite.c

Source
/*
 *  Public Key layer for writing key files and structures
 *
 *  Copyright The Mbed TLS Contributors
 *  SPDX-License-Identifier: Apache-2.0 OR GPL-2.0-or-later
 */

#include "common.h"

#if defined(MBEDTLS_PK_WRITE_C)

#include "mbedtls/pk.h"
#include "mbedtls/asn1write.h"
#include "mbedtls/oid.h"
#include "mbedtls/platform_util.h"
#include "mbedtls/error.h"
#include "pk_internal.h"

#include <string.h>

#if defined(MBEDTLS_ECP_C)
#include "mbedtls/bignum.h"
#include "mbedtls/ecp.h"
#include "mbedtls/platform_util.h"
#endif
#if defined(MBEDTLS_PK_HAVE_ECC_KEYS)
#include "pk_internal.h"
#endif
#if defined(MBEDTLS_RSA_C) || defined(MBEDTLS_PK_HAVE_ECC_KEYS)
#include "pkwrite.h"
#endif
#if defined(MBEDTLS_PEM_WRITE_C)
#include "mbedtls/pem.h"
#endif
#if defined(MBEDTLS_RSA_C)
#include "rsa_internal.h"
#endif

#if defined(MBEDTLS_USE_PSA_CRYPTO)
#include "psa/crypto.h"
#include "psa_util_internal.h"
#endif
#include "mbedtls/platform.h"

/* Helpers for properly sizing buffers aimed at holding public keys or
 * key-pairs based on build symbols. */
#if defined(MBEDTLS_PK_USE_PSA_EC_DATA)
#define PK_MAX_EC_PUBLIC_KEY_SIZE       MBEDTLS_PSA_MAX_EC_PUBKEY_LENGTH
#define PK_MAX_EC_KEY_PAIR_SIZE         MBEDTLS_PSA_MAX_EC_KEY_PAIR_LENGTH
#elif defined(MBEDTLS_USE_PSA_CRYPTO)
#define PK_MAX_EC_PUBLIC_KEY_SIZE       MBEDTLS_PSA_MAX_EC_PUBKEY_LENGTH
#define PK_MAX_EC_KEY_PAIR_SIZE         MBEDTLS_PSA_MAX_EC_KEY_PAIR_LENGTH
#else
#define PK_MAX_EC_PUBLIC_KEY_SIZE       MBEDTLS_ECP_MAX_PT_LEN
#define PK_MAX_EC_KEY_PAIR_SIZE         MBEDTLS_ECP_MAX_BYTES
#endif

/******************************************************************************
 * Internal functions for RSA keys.
 ******************************************************************************/
#if defined(MBEDTLS_RSA_C)
static int pk_write_rsa_der(unsigned char **p, unsigned char *buf,
                            const mbedtls_pk_context *pk)
{
#if defined(MBEDTLS_USE_PSA_CRYPTO)
    if (mbedtls_pk_get_type(pk) == MBEDTLS_PK_OPAQUE) {
        psa_status_t status;
        size_t buf_size = (size_t) (*p - buf);
        size_t key_len = 0;

        status = psa_export_key(pk->priv_id, buf, buf_size, &key_len);
        if (status == PSA_ERROR_BUFFER_TOO_SMALL) {
            return MBEDTLS_ERR_ASN1_BUF_TOO_SMALL;
        } else if (status != PSA_SUCCESS) {
            return PSA_PK_RSA_TO_MBEDTLS_ERR(status);
        }

        /* We wrote to the beginning of the buffer while
         * we were supposed to write to its end. */
        *p -= key_len;
        memmove(*p, buf, key_len);
        mbedtls_platform_zeroize(buf, *p - buf);

        return (int) key_len;
    }
#endif /* MBEDTLS_USE_PSA_CRYPTO */
    return mbedtls_rsa_write_key(mbedtls_pk_rsa(*pk), buf, p);
}
#endif /* MBEDTLS_RSA_C */

/******************************************************************************
 * Internal functions for EC keys.
 ******************************************************************************/
#if defined(MBEDTLS_PK_HAVE_ECC_KEYS)
#if defined(MBEDTLS_PK_USE_PSA_EC_DATA)
static int pk_write_ec_pubkey(unsigned char **p, unsigned char *start,
                              const mbedtls_pk_context *pk)
{
    size_t len = 0;
    uint8_t buf[PK_MAX_EC_PUBLIC_KEY_SIZE];

    if (mbedtls_pk_get_type(pk) == MBEDTLS_PK_OPAQUE) {
        if (psa_export_public_key(pk->priv_id, buf, sizeof(buf), &len) != PSA_SUCCESS) {
            return MBEDTLS_ERR_PK_BAD_INPUT_DATA;
        }
    } else {
        len = pk->pub_raw_len;
        memcpy(buf, pk->pub_raw, len);
    }

    if (*p < start || (size_t) (*p - start) < len) {
        return MBEDTLS_ERR_ASN1_BUF_TOO_SMALL;
    }

    *p -= len;
    memcpy(*p, buf, len);

    return (int) len;
}
#else /* MBEDTLS_PK_USE_PSA_EC_DATA */
static int pk_write_ec_pubkey(unsigned char **p, unsigned char *start,
                              const mbedtls_pk_context *pk)
{
    size_t len = 0;
    unsigned char buf[PK_MAX_EC_PUBLIC_KEY_SIZE];
    mbedtls_ecp_keypair *ec = mbedtls_pk_ec(*pk);
    int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;

#if defined(MBEDTLS_USE_PSA_CRYPTO)
    if (mbedtls_pk_get_type(pk) == MBEDTLS_PK_OPAQUE) {
        if (psa_export_public_key(pk->priv_id, buf, sizeof(buf), &len) != PSA_SUCCESS) {
            return MBEDTLS_ERR_PK_BAD_INPUT_DATA;
        }
        /* Ensure there's enough space in the provided buffer before copying data into it. */
        if (len > (size_t) (*p - start)) {
            return MBEDTLS_ERR_ASN1_BUF_TOO_SMALL;
        }
        *p -= len;
        memcpy(*p, buf, len);
        return (int) len;
    } else
#endif /* MBEDTLS_USE_PSA_CRYPTO */
    {
        if ((ret = mbedtls_ecp_point_write_binary(&ec->grp, &ec->Q,
                                                  MBEDTLS_ECP_PF_UNCOMPRESSED,
                                                  &len, buf, sizeof(buf))) != 0) {
            return ret;
        }
    }

    if (*p < start || (size_t) (*p - start) < len) {
        return MBEDTLS_ERR_ASN1_BUF_TOO_SMALL;
    }

    *p -= len;
    memcpy(*p, buf, len);

    return (int) len;
}
#endif /* MBEDTLS_PK_USE_PSA_EC_DATA */

/*
 * privateKey  OCTET STRING -- always of length ceil(log2(n)/8)
 */
#if defined(MBEDTLS_PK_USE_PSA_EC_DATA)
static int pk_write_ec_private(unsigned char **p, unsigned char *start,
                               const mbedtls_pk_context *pk)
{
    size_t byte_length;
    int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
    unsigned char tmp[PK_MAX_EC_KEY_PAIR_SIZE];
    psa_status_t status;

    if (mbedtls_pk_get_type(pk) == MBEDTLS_PK_OPAQUE) {
        status = psa_export_key(pk->priv_id, tmp, sizeof(tmp), &byte_length);
        if (status != PSA_SUCCESS) {
            ret = PSA_PK_ECDSA_TO_MBEDTLS_ERR(status);
            return ret;
        }
    } else {
        status = psa_export_key(pk->priv_id, tmp, sizeof(tmp), &byte_length);
        if (status != PSA_SUCCESS) {
            ret = PSA_PK_ECDSA_TO_MBEDTLS_ERR(status);
            goto exit;
        }
    }

    ret = mbedtls_asn1_write_octet_string(p, start, tmp, byte_length);
exit:
    mbedtls_platform_zeroize(tmp, sizeof(tmp));
    return ret;
}
#else /* MBEDTLS_PK_USE_PSA_EC_DATA */
static int pk_write_ec_private(unsigned char **p, unsigned char *start,
                               const mbedtls_pk_context *pk)
{
    size_t byte_length;
    int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
    unsigned char tmp[PK_MAX_EC_KEY_PAIR_SIZE];

#if defined(MBEDTLS_USE_PSA_CRYPTO)
    psa_status_t status;
    if (mbedtls_pk_get_type(pk) == MBEDTLS_PK_OPAQUE) {
        status = psa_export_key(pk->priv_id, tmp, sizeof(tmp), &byte_length);
        if (status != PSA_SUCCESS) {
            ret = PSA_PK_ECDSA_TO_MBEDTLS_ERR(status);
            return ret;
        }
    } else
#endif /* MBEDTLS_USE_PSA_CRYPTO */
    {
        mbedtls_ecp_keypair *ec = mbedtls_pk_ec_rw(*pk);
        byte_length = (ec->grp.pbits + 7) / 8;

        ret = mbedtls_ecp_write_key_ext(ec, &byte_length, tmp, sizeof(tmp));
        if (ret != 0) {
            goto exit;
        }
    }
    ret = mbedtls_asn1_write_octet_string(p, start, tmp, byte_length);
exit:
    mbedtls_platform_zeroize(tmp, sizeof(tmp));
    return ret;
}
#endif /* MBEDTLS_PK_USE_PSA_EC_DATA */

/*
 * ECParameters ::= CHOICE {
 *   namedCurve         OBJECT IDENTIFIER
 * }
 */
static int pk_write_ec_param(unsigned char **p, unsigned char *start,
                             mbedtls_ecp_group_id grp_id)
{
    int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
    size_t len = 0;
    const char *oid;
    size_t oid_len;

    if ((ret = mbedtls_oid_get_oid_by_ec_grp(grp_id, &oid, &oid_len)) != 0) {
        return ret;
    }

    MBEDTLS_ASN1_CHK_ADD(len, mbedtls_asn1_write_oid(p, start, oid, oid_len));

    return (int) len;
}

#if defined(MBEDTLS_PK_HAVE_RFC8410_CURVES)
/*
 * RFC8410 section 7
 *
 * OneAsymmetricKey ::= SEQUENCE {
 *    version Version,
 *    privateKeyAlgorithm PrivateKeyAlgorithmIdentifier,
 *    privateKey PrivateKey,
 *    attributes [0] IMPLICIT Attributes OPTIONAL,
 *    ...,
 *    [[2: publicKey [1] IMPLICIT PublicKey OPTIONAL ]],
 *    ...
 * }
 * ...
 * CurvePrivateKey ::= OCTET STRING
 */
static int pk_write_ec_rfc8410_der(unsigned char **p, unsigned char *buf,
                                   const mbedtls_pk_context *pk)
{
    int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
    size_t len = 0;
    size_t oid_len = 0;
    const char *oid;
    mbedtls_ecp_group_id grp_id;

    /* privateKey */
    MBEDTLS_ASN1_CHK_ADD(len, pk_write_ec_private(p, buf, pk));
    MBEDTLS_ASN1_CHK_ADD(len, mbedtls_asn1_write_len(p, buf, len));
    MBEDTLS_ASN1_CHK_ADD(len, mbedtls_asn1_write_tag(p, buf, MBEDTLS_ASN1_OCTET_STRING));

    grp_id = mbedtls_pk_get_ec_group_id(pk);
    /* privateKeyAlgorithm */
    if ((ret = mbedtls_oid_get_oid_by_ec_grp_algid(grp_id, &oid, &oid_len)) != 0) {
        return ret;
    }
    MBEDTLS_ASN1_CHK_ADD(len,
                         mbedtls_asn1_write_algorithm_identifier_ext(p, buf, oid, oid_len, 0, 0));

    /* version */
    MBEDTLS_ASN1_CHK_ADD(len, mbedtls_asn1_write_int(p, buf, 0));

    MBEDTLS_ASN1_CHK_ADD(len, mbedtls_asn1_write_len(p, buf, len));
    MBEDTLS_ASN1_CHK_ADD(len, mbedtls_asn1_write_tag(p, buf, MBEDTLS_ASN1_CONSTRUCTED |
                                                     MBEDTLS_ASN1_SEQUENCE));

    return (int) len;
}
#endif /* MBEDTLS_PK_HAVE_RFC8410_CURVES */

/*
 * RFC 5915, or SEC1 Appendix C.4
 *
 * ECPrivateKey ::= SEQUENCE {
 *      version        INTEGER { ecPrivkeyVer1(1) } (ecPrivkeyVer1),
 *      privateKey     OCTET STRING,
 *      parameters [0] ECParameters {{ NamedCurve }} OPTIONAL,
 *      publicKey  [1] BIT STRING OPTIONAL
 *    }
 */
static int pk_write_ec_der(unsigned char **p, unsigned char *buf,
                           const mbedtls_pk_context *pk)
{
    size_t len = 0;
    int ret;
    size_t pub_len = 0, par_len = 0;
    mbedtls_ecp_group_id grp_id;

    /* publicKey */
    MBEDTLS_ASN1_CHK_ADD(pub_len, pk_write_ec_pubkey(p, buf, pk));

    if (*p - buf < 1) {
        return MBEDTLS_ERR_ASN1_BUF_TOO_SMALL;
    }
    (*p)--;
    **p = 0;
    pub_len += 1;

    MBEDTLS_ASN1_CHK_ADD(pub_len, mbedtls_asn1_write_len(p, buf, pub_len));
    MBEDTLS_ASN1_CHK_ADD(pub_len, mbedtls_asn1_write_tag(p, buf, MBEDTLS_ASN1_BIT_STRING));

    MBEDTLS_ASN1_CHK_ADD(pub_len, mbedtls_asn1_write_len(p, buf, pub_len));
    MBEDTLS_ASN1_CHK_ADD(pub_len, mbedtls_asn1_write_tag(p, buf,
                                                         MBEDTLS_ASN1_CONTEXT_SPECIFIC |
                                                         MBEDTLS_ASN1_CONSTRUCTED | 1));
    len += pub_len;

    /* parameters */
    grp_id = mbedtls_pk_get_ec_group_id(pk);
    MBEDTLS_ASN1_CHK_ADD(par_len, pk_write_ec_param(p, buf, grp_id));
    MBEDTLS_ASN1_CHK_ADD(par_len, mbedtls_asn1_write_len(p, buf, par_len));
    MBEDTLS_ASN1_CHK_ADD(par_len, mbedtls_asn1_write_tag(p, buf,
                                                         MBEDTLS_ASN1_CONTEXT_SPECIFIC |
                                                         MBEDTLS_ASN1_CONSTRUCTED | 0));
    len += par_len;

    /* privateKey */
    MBEDTLS_ASN1_CHK_ADD(len, pk_write_ec_private(p, buf, pk));

    /* version */
    MBEDTLS_ASN1_CHK_ADD(len, mbedtls_asn1_write_int(p, buf, 1));

    MBEDTLS_ASN1_CHK_ADD(len, mbedtls_asn1_write_len(p, buf, len));
    MBEDTLS_ASN1_CHK_ADD(len, mbedtls_asn1_write_tag(p, buf, MBEDTLS_ASN1_CONSTRUCTED |
                                                     MBEDTLS_ASN1_SEQUENCE));

    return (int) len;
}
#endif /* MBEDTLS_PK_HAVE_ECC_KEYS */

/******************************************************************************
 * Internal functions for Opaque keys.
 ******************************************************************************/
#if defined(MBEDTLS_USE_PSA_CRYPTO)
static int pk_write_opaque_pubkey(unsigned char **p, unsigned char *start,
                                  const mbedtls_pk_context *pk)
{
    size_t buffer_size;
    size_t len = 0;

    if (*p < start) {
        return MBEDTLS_ERR_PK_BAD_INPUT_DATA;
    }

    buffer_size = (size_t) (*p - start);
    if (psa_export_public_key(pk->priv_id, start, buffer_size,
                              &len) != PSA_SUCCESS) {
        return MBEDTLS_ERR_PK_BAD_INPUT_DATA;
    }

    *p -= len;
    memmove(*p, start, len);

    return (int) len;
}
#endif /* MBEDTLS_USE_PSA_CRYPTO */

/******************************************************************************
 * Generic helpers
 ******************************************************************************/

/* Extend the public mbedtls_pk_get_type() by getting key type also in case of
 * opaque keys. */
static mbedtls_pk_type_t pk_get_type_ext(const mbedtls_pk_context *pk)
{
    mbedtls_pk_type_t pk_type = mbedtls_pk_get_type(pk);

#if defined(MBEDTLS_USE_PSA_CRYPTO)
    if (pk_type == MBEDTLS_PK_OPAQUE) {
        psa_key_attributes_t opaque_attrs = PSA_KEY_ATTRIBUTES_INIT;
        psa_key_type_t opaque_key_type;

        if (psa_get_key_attributes(pk->priv_id, &opaque_attrs) != PSA_SUCCESS) {
            return MBEDTLS_PK_NONE;
        }
        opaque_key_type = psa_get_key_type(&opaque_attrs);
        psa_reset_key_attributes(&opaque_attrs);

        if (PSA_KEY_TYPE_IS_ECC(opaque_key_type)) {
            return MBEDTLS_PK_ECKEY;
        } else if (PSA_KEY_TYPE_IS_RSA(opaque_key_type)) {
            return MBEDTLS_PK_RSA;
        } else {
            return MBEDTLS_PK_NONE;
        }
    } else
#endif
    return pk_type;
}

/******************************************************************************
 * Public functions for writing private/public DER keys.
 ******************************************************************************/
int mbedtls_pk_write_pubkey(unsigned char **p, unsigned char *start,
                            const mbedtls_pk_context *key)
{
    int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
    size_t len = 0;

#if defined(MBEDTLS_RSA_C)
    if (mbedtls_pk_get_type(key) == MBEDTLS_PK_RSA) {
        MBEDTLS_ASN1_CHK_ADD(len, mbedtls_rsa_write_pubkey(mbedtls_pk_rsa(*key), start, p));
    } else
#endif
#if defined(MBEDTLS_PK_HAVE_ECC_KEYS)
    if (mbedtls_pk_get_type(key) == MBEDTLS_PK_ECKEY) {
        MBEDTLS_ASN1_CHK_ADD(len, pk_write_ec_pubkey(p, start, key));
    } else
#endif
#if defined(MBEDTLS_USE_PSA_CRYPTO)
    if (mbedtls_pk_get_type(key) == MBEDTLS_PK_OPAQUE) {
        MBEDTLS_ASN1_CHK_ADD(len, pk_write_opaque_pubkey(p, start, key));
    } else
#endif /* MBEDTLS_USE_PSA_CRYPTO */
    return MBEDTLS_ERR_PK_FEATURE_UNAVAILABLE;

    return (int) len;
}

int mbedtls_pk_write_pubkey_der(const mbedtls_pk_context *key, unsigned char *buf, size_t size)
{
    int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
    unsigned char *c;
    int has_par = 1;
    size_t len = 0, par_len = 0, oid_len = 0;
    mbedtls_pk_type_t pk_type;
    const char *oid = NULL;

    if (size == 0) {
        return MBEDTLS_ERR_ASN1_BUF_TOO_SMALL;
    }

    c = buf + size;

    MBEDTLS_ASN1_CHK_ADD(len, mbedtls_pk_write_pubkey(&c, buf, key));

    if (c - buf < 1) {
        return MBEDTLS_ERR_ASN1_BUF_TOO_SMALL;
    }

    /*
     *  SubjectPublicKeyInfo  ::=  SEQUENCE  {
     *       algorithm            AlgorithmIdentifier,
     *       subjectPublicKey     BIT STRING }
     */
    *--c = 0;
    len += 1;

    MBEDTLS_ASN1_CHK_ADD(len, mbedtls_asn1_write_len(&c, buf, len));
    MBEDTLS_ASN1_CHK_ADD(len, mbedtls_asn1_write_tag(&c, buf, MBEDTLS_ASN1_BIT_STRING));

    pk_type = pk_get_type_ext(key);

#if defined(MBEDTLS_PK_HAVE_ECC_KEYS)
    if (pk_get_type_ext(key) == MBEDTLS_PK_ECKEY) {
        mbedtls_ecp_group_id ec_grp_id = mbedtls_pk_get_ec_group_id(key);
        if (MBEDTLS_PK_IS_RFC8410_GROUP_ID(ec_grp_id)) {
            ret = mbedtls_oid_get_oid_by_ec_grp_algid(ec_grp_id, &oid, &oid_len);
            if (ret != 0) {
                return ret;
            }
            has_par = 0;
        } else {
            MBEDTLS_ASN1_CHK_ADD(par_len, pk_write_ec_param(&c, buf, ec_grp_id));
        }
    }
#endif /* MBEDTLS_PK_HAVE_ECC_KEYS */

    /* At this point oid_len is not null only for EC Montgomery keys. */
    if (oid_len == 0) {
        ret = mbedtls_oid_get_oid_by_pk_alg(pk_type, &oid, &oid_len);
        if (ret != 0) {
            return ret;
        }
    }

    MBEDTLS_ASN1_CHK_ADD(len, mbedtls_asn1_write_algorithm_identifier_ext(&c, buf, oid, oid_len,
                                                                          par_len, has_par));

    MBEDTLS_ASN1_CHK_ADD(len, mbedtls_asn1_write_len(&c, buf, len));
    MBEDTLS_ASN1_CHK_ADD(len, mbedtls_asn1_write_tag(&c, buf, MBEDTLS_ASN1_CONSTRUCTED |
                                                     MBEDTLS_ASN1_SEQUENCE));

    return (int) len;
}

int mbedtls_pk_write_key_der(const mbedtls_pk_context *key, unsigned char *buf, size_t size)
{
    unsigned char *c;

    if (size == 0) {
        return MBEDTLS_ERR_ASN1_BUF_TOO_SMALL;
    }

    c = buf + size;

#if defined(MBEDTLS_RSA_C)
    if (pk_get_type_ext(key) == MBEDTLS_PK_RSA) {
        return pk_write_rsa_der(&c, buf, key);
    } else
#endif /* MBEDTLS_RSA_C */
#if defined(MBEDTLS_PK_HAVE_ECC_KEYS)
    if (pk_get_type_ext(key) == MBEDTLS_PK_ECKEY) {
#if defined(MBEDTLS_PK_HAVE_RFC8410_CURVES)
        if (mbedtls_pk_is_rfc8410(key)) {
            return pk_write_ec_rfc8410_der(&c, buf, key);
        }
#endif /* MBEDTLS_PK_HAVE_RFC8410_CURVES */
        return pk_write_ec_der(&c, buf, key);
    } else
#endif /* MBEDTLS_PK_HAVE_ECC_KEYS */
    return MBEDTLS_ERR_PK_FEATURE_UNAVAILABLE;
}

/******************************************************************************
 * Public functions for wrinting private/public PEM keys.
 ******************************************************************************/
#if defined(MBEDTLS_PEM_WRITE_C)

#define PUB_DER_MAX_BYTES                                                   \
    (MBEDTLS_PK_RSA_PUB_DER_MAX_BYTES > MBEDTLS_PK_ECP_PUB_DER_MAX_BYTES ? \
     MBEDTLS_PK_RSA_PUB_DER_MAX_BYTES : MBEDTLS_PK_ECP_PUB_DER_MAX_BYTES)
#define PRV_DER_MAX_BYTES                                                   \
    (MBEDTLS_PK_RSA_PRV_DER_MAX_BYTES > MBEDTLS_PK_ECP_PRV_DER_MAX_BYTES ? \
     MBEDTLS_PK_RSA_PRV_DER_MAX_BYTES : MBEDTLS_PK_ECP_PRV_DER_MAX_BYTES)

int mbedtls_pk_write_pubkey_pem(const mbedtls_pk_context *key, unsigned char *buf, size_t size)
{
    int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
    unsigned char *output_buf = NULL;
    output_buf = mbedtls_calloc(1, PUB_DER_MAX_BYTES);
    if (output_buf == NULL) {
        return MBEDTLS_ERR_PK_ALLOC_FAILED;
    }
    size_t olen = 0;

    if ((ret = mbedtls_pk_write_pubkey_der(key, output_buf,
                                           PUB_DER_MAX_BYTES)) < 0) {
        goto cleanup;
    }

    if ((ret = mbedtls_pem_write_buffer(PEM_BEGIN_PUBLIC_KEY "\n", PEM_END_PUBLIC_KEY "\n",
                                        output_buf + PUB_DER_MAX_BYTES - ret,
                                        ret, buf, size, &olen)) != 0) {
        goto cleanup;
    }

    ret = 0;
cleanup:
    mbedtls_free(output_buf);
    return ret;
}

int mbedtls_pk_write_key_pem(const mbedtls_pk_context *key, unsigned char *buf, size_t size)
{
    int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
    unsigned char *output_buf = NULL;
    output_buf = mbedtls_calloc(1, PRV_DER_MAX_BYTES);
    if (output_buf == NULL) {
        return MBEDTLS_ERR_PK_ALLOC_FAILED;
    }
    const char *begin, *end;
    size_t olen = 0;

    if ((ret = mbedtls_pk_write_key_der(key, output_buf, PRV_DER_MAX_BYTES)) < 0) {
        goto cleanup;
    }

#if defined(MBEDTLS_RSA_C)
    if (pk_get_type_ext(key) == MBEDTLS_PK_RSA) {
        begin = PEM_BEGIN_PRIVATE_KEY_RSA "\n";
        end = PEM_END_PRIVATE_KEY_RSA "\n";
    } else
#endif
#if defined(MBEDTLS_PK_HAVE_ECC_KEYS)
    if (pk_get_type_ext(key) == MBEDTLS_PK_ECKEY) {
        if (mbedtls_pk_is_rfc8410(key)) {
            begin = PEM_BEGIN_PRIVATE_KEY_PKCS8 "\n";
            end = PEM_END_PRIVATE_KEY_PKCS8 "\n";
        } else {
            begin = PEM_BEGIN_PRIVATE_KEY_EC "\n";
            end = PEM_END_PRIVATE_KEY_EC "\n";
        }
    } else
#endif /* MBEDTLS_PK_HAVE_ECC_KEYS */
    {
        ret = MBEDTLS_ERR_PK_FEATURE_UNAVAILABLE;
        goto cleanup;
    }

    if ((ret = mbedtls_pem_write_buffer(begin, end,
                                        output_buf + PRV_DER_MAX_BYTES - ret,
                                        ret, buf, size, &olen)) != 0) {
        goto cleanup;
    }

    ret = 0;
cleanup:
    mbedtls_zeroize_and_free(output_buf, PRV_DER_MAX_BYTES);
    return ret;
}
#endif /* MBEDTLS_PEM_WRITE_C */

#endif /* MBEDTLS_PK_WRITE_C */

Coverage Report

Created: 2026-10-17 06:10

Line	Count	Source
1		/*
2		* Public Key layer for writing key files and structures
3		*
4		* Copyright The Mbed TLS Contributors
5		* SPDX-License-Identifier: Apache-2.0 OR GPL-2.0-or-later
6		*/
7
8		#include "common.h"
9
10		#if defined(MBEDTLS_PK_WRITE_C)
11
12		#include "mbedtls/pk.h"
13		#include "mbedtls/asn1write.h"
14		#include "mbedtls/oid.h"
15		#include "mbedtls/platform_util.h"
16		#include "mbedtls/error.h"
17		#include "pk_internal.h"
18
19		#include <string.h>
20
21		#if defined(MBEDTLS_ECP_C)
22		#include "mbedtls/bignum.h"
23		#include "mbedtls/ecp.h"
24		#include "mbedtls/platform_util.h"
25		#endif
26		#if defined(MBEDTLS_PK_HAVE_ECC_KEYS)
27		#include "pk_internal.h"
28		#endif
29		#if defined(MBEDTLS_RSA_C) \|\| defined(MBEDTLS_PK_HAVE_ECC_KEYS)
30		#include "pkwrite.h"
31		#endif
32		#if defined(MBEDTLS_PEM_WRITE_C)
33		#include "mbedtls/pem.h"
34		#endif
35		#if defined(MBEDTLS_RSA_C)
36		#include "rsa_internal.h"
37		#endif
38
39		#if defined(MBEDTLS_USE_PSA_CRYPTO)
40		#include "psa/crypto.h"
41		#include "psa_util_internal.h"
42		#endif
43		#include "mbedtls/platform.h"
44
45		/* Helpers for properly sizing buffers aimed at holding public keys or
46		* key-pairs based on build symbols. */
47		#if defined(MBEDTLS_PK_USE_PSA_EC_DATA)
48		#define PK_MAX_EC_PUBLIC_KEY_SIZE MBEDTLS_PSA_MAX_EC_PUBKEY_LENGTH
49		#define PK_MAX_EC_KEY_PAIR_SIZE MBEDTLS_PSA_MAX_EC_KEY_PAIR_LENGTH
50		#elif defined(MBEDTLS_USE_PSA_CRYPTO)
51		#define PK_MAX_EC_PUBLIC_KEY_SIZE MBEDTLS_PSA_MAX_EC_PUBKEY_LENGTH
52		#define PK_MAX_EC_KEY_PAIR_SIZE MBEDTLS_PSA_MAX_EC_KEY_PAIR_LENGTH
53		#else
54		#define PK_MAX_EC_PUBLIC_KEY_SIZE MBEDTLS_ECP_MAX_PT_LEN
55		#define PK_MAX_EC_KEY_PAIR_SIZE MBEDTLS_ECP_MAX_BYTES
56		#endif
57
58		/******************************************************************************
59		* Internal functions for RSA keys.
60		******************************************************************************/
61		#if defined(MBEDTLS_RSA_C)
62		static int pk_write_rsa_der(unsigned char *p, unsigned char buf,
63		const mbedtls_pk_context *pk)
64	0	{
65		#if defined(MBEDTLS_USE_PSA_CRYPTO)
66		if (mbedtls_pk_get_type(pk) == MBEDTLS_PK_OPAQUE) {
67		psa_status_t status;
68		size_t buf_size = (size_t) (*p - buf);
69		size_t key_len = 0;
70
71		status = psa_export_key(pk->priv_id, buf, buf_size, &key_len);
72		if (status == PSA_ERROR_BUFFER_TOO_SMALL) {
73		return MBEDTLS_ERR_ASN1_BUF_TOO_SMALL;
74		} else if (status != PSA_SUCCESS) {
75		return PSA_PK_RSA_TO_MBEDTLS_ERR(status);
76		}
77
78		/* We wrote to the beginning of the buffer while
79		* we were supposed to write to its end. */
80		*p -= key_len;
81		memmove(*p, buf, key_len);
82		mbedtls_platform_zeroize(buf, *p - buf);
83
84		return (int) key_len;
85		}
86		#endif /* MBEDTLS_USE_PSA_CRYPTO */
87	0	return mbedtls_rsa_write_key(mbedtls_pk_rsa(*pk), buf, p);
88	0	}
89		#endif /* MBEDTLS_RSA_C */
90
91		/******************************************************************************
92		* Internal functions for EC keys.
93		******************************************************************************/
94		#if defined(MBEDTLS_PK_HAVE_ECC_KEYS)
95		#if defined(MBEDTLS_PK_USE_PSA_EC_DATA)
96		static int pk_write_ec_pubkey(unsigned char *p, unsigned char start,
97		const mbedtls_pk_context *pk)
98		{
99		size_t len = 0;
100		uint8_t buf[PK_MAX_EC_PUBLIC_KEY_SIZE];
101
102		if (mbedtls_pk_get_type(pk) == MBEDTLS_PK_OPAQUE) {
103		if (psa_export_public_key(pk->priv_id, buf, sizeof(buf), &len) != PSA_SUCCESS) {
104		return MBEDTLS_ERR_PK_BAD_INPUT_DATA;
105		}
106		} else {
107		len = pk->pub_raw_len;
108		memcpy(buf, pk->pub_raw, len);
109		}
110
111		if (p < start \|\| (size_t) (p - start) < len) {
112		return MBEDTLS_ERR_ASN1_BUF_TOO_SMALL;
113		}
114
115		*p -= len;
116		memcpy(*p, buf, len);
117
118		return (int) len;
119		}
120		#else /* MBEDTLS_PK_USE_PSA_EC_DATA */
121		static int pk_write_ec_pubkey(unsigned char *p, unsigned char start,
122		const mbedtls_pk_context *pk)
123	0	{
124	0	size_t len = 0;
125	0	unsigned char buf[PK_MAX_EC_PUBLIC_KEY_SIZE];
126	0	mbedtls_ecp_keypair ec = mbedtls_pk_ec(pk);
127	0	int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
128
129		#if defined(MBEDTLS_USE_PSA_CRYPTO)
130		if (mbedtls_pk_get_type(pk) == MBEDTLS_PK_OPAQUE) {
131		if (psa_export_public_key(pk->priv_id, buf, sizeof(buf), &len) != PSA_SUCCESS) {
132		return MBEDTLS_ERR_PK_BAD_INPUT_DATA;
133		}
134		/* Ensure there's enough space in the provided buffer before copying data into it. */
135		if (len > (size_t) (*p - start)) {
136		return MBEDTLS_ERR_ASN1_BUF_TOO_SMALL;
137		}
138		*p -= len;
139		memcpy(*p, buf, len);
140		return (int) len;
141		} else
142		#endif /* MBEDTLS_USE_PSA_CRYPTO */
143	0	{
144	0	if ((ret = mbedtls_ecp_point_write_binary(&ec->grp, &ec->Q,
145	0	MBEDTLS_ECP_PF_UNCOMPRESSED,
146	0	&len, buf, sizeof(buf))) != 0) {
147	0	return ret;
148	0	}
149	0	}
150
151	0	if (p < start \|\| (size_t) (p - start) < len) {
152	0	return MBEDTLS_ERR_ASN1_BUF_TOO_SMALL;
153	0	}
154
155	0	*p -= len;
156	0	memcpy(*p, buf, len);
157
158	0	return (int) len;
159	0	}
160		#endif /* MBEDTLS_PK_USE_PSA_EC_DATA */
161
162		/*
163		* privateKey OCTET STRING -- always of length ceil(log2(n)/8)
164		*/
165		#if defined(MBEDTLS_PK_USE_PSA_EC_DATA)
166		static int pk_write_ec_private(unsigned char *p, unsigned char start,
167		const mbedtls_pk_context *pk)
168		{
169		size_t byte_length;
170		int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
171		unsigned char tmp[PK_MAX_EC_KEY_PAIR_SIZE];
172		psa_status_t status;
173
174		if (mbedtls_pk_get_type(pk) == MBEDTLS_PK_OPAQUE) {
175		status = psa_export_key(pk->priv_id, tmp, sizeof(tmp), &byte_length);
176		if (status != PSA_SUCCESS) {
177		ret = PSA_PK_ECDSA_TO_MBEDTLS_ERR(status);
178		return ret;
179		}
180		} else {
181		status = psa_export_key(pk->priv_id, tmp, sizeof(tmp), &byte_length);
182		if (status != PSA_SUCCESS) {
183		ret = PSA_PK_ECDSA_TO_MBEDTLS_ERR(status);
184		goto exit;
185		}
186		}
187
188		ret = mbedtls_asn1_write_octet_string(p, start, tmp, byte_length);
189		exit:
190		mbedtls_platform_zeroize(tmp, sizeof(tmp));
191		return ret;
192		}
193		#else /* MBEDTLS_PK_USE_PSA_EC_DATA */
194		static int pk_write_ec_private(unsigned char *p, unsigned char start,
195		const mbedtls_pk_context *pk)
196	0	{
197	0	size_t byte_length;
198	0	int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
199	0	unsigned char tmp[PK_MAX_EC_KEY_PAIR_SIZE];
200
201		#if defined(MBEDTLS_USE_PSA_CRYPTO)
202		psa_status_t status;
203		if (mbedtls_pk_get_type(pk) == MBEDTLS_PK_OPAQUE) {
204		status = psa_export_key(pk->priv_id, tmp, sizeof(tmp), &byte_length);
205		if (status != PSA_SUCCESS) {
206		ret = PSA_PK_ECDSA_TO_MBEDTLS_ERR(status);
207		return ret;
208		}
209		} else
210		#endif /* MBEDTLS_USE_PSA_CRYPTO */
211	0	{
212	0	mbedtls_ecp_keypair ec = mbedtls_pk_ec_rw(pk);
213	0	byte_length = (ec->grp.pbits + 7) / 8;
214
215	0	ret = mbedtls_ecp_write_key_ext(ec, &byte_length, tmp, sizeof(tmp));
216	0	if (ret != 0) {
217	0	goto exit;
218	0	}
219	0	}
220	0	ret = mbedtls_asn1_write_octet_string(p, start, tmp, byte_length);
221	0	exit:
222	0	mbedtls_platform_zeroize(tmp, sizeof(tmp));
223	0	return ret;
224	0	}
225		#endif /* MBEDTLS_PK_USE_PSA_EC_DATA */
226
227		/*
228		* ECParameters ::= CHOICE {
229		* namedCurve OBJECT IDENTIFIER
230		* }
231		*/
232		static int pk_write_ec_param(unsigned char *p, unsigned char start,
233		mbedtls_ecp_group_id grp_id)
234	0	{
235	0	int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
236	0	size_t len = 0;
237	0	const char *oid;
238	0	size_t oid_len;
239
240	0	if ((ret = mbedtls_oid_get_oid_by_ec_grp(grp_id, &oid, &oid_len)) != 0) {
241	0	return ret;
242	0	}
243
244	0	MBEDTLS_ASN1_CHK_ADD(len, mbedtls_asn1_write_oid(p, start, oid, oid_len));
245
246	0	return (int) len;
247	0	}
248
249		#if defined(MBEDTLS_PK_HAVE_RFC8410_CURVES)
250		/*
251		* RFC8410 section 7
252		*
253		* OneAsymmetricKey ::= SEQUENCE {
254		* version Version,
255		* privateKeyAlgorithm PrivateKeyAlgorithmIdentifier,
256		* privateKey PrivateKey,
257		* attributes [0] IMPLICIT Attributes OPTIONAL,
258		* ...,
259		* [[2: publicKey [1] IMPLICIT PublicKey OPTIONAL ]],
260		* ...
261		* }
262		* ...
263		* CurvePrivateKey ::= OCTET STRING
264		*/
265		static int pk_write_ec_rfc8410_der(unsigned char *p, unsigned char buf,
266		const mbedtls_pk_context *pk)
267	0	{
268	0	int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
269	0	size_t len = 0;
270	0	size_t oid_len = 0;
271	0	const char *oid;
272	0	mbedtls_ecp_group_id grp_id;
273
274		/* privateKey */
275	0	MBEDTLS_ASN1_CHK_ADD(len, pk_write_ec_private(p, buf, pk));
276	0	MBEDTLS_ASN1_CHK_ADD(len, mbedtls_asn1_write_len(p, buf, len));
277	0	MBEDTLS_ASN1_CHK_ADD(len, mbedtls_asn1_write_tag(p, buf, MBEDTLS_ASN1_OCTET_STRING));
278
279	0	grp_id = mbedtls_pk_get_ec_group_id(pk);
280		/* privateKeyAlgorithm */
281	0	if ((ret = mbedtls_oid_get_oid_by_ec_grp_algid(grp_id, &oid, &oid_len)) != 0) {
282	0	return ret;
283	0	}
284	0	MBEDTLS_ASN1_CHK_ADD(len,
285	0	mbedtls_asn1_write_algorithm_identifier_ext(p, buf, oid, oid_len, 0, 0));
286
287		/* version */
288	0	MBEDTLS_ASN1_CHK_ADD(len, mbedtls_asn1_write_int(p, buf, 0));
289
290	0	MBEDTLS_ASN1_CHK_ADD(len, mbedtls_asn1_write_len(p, buf, len));
291	0	MBEDTLS_ASN1_CHK_ADD(len, mbedtls_asn1_write_tag(p, buf, MBEDTLS_ASN1_CONSTRUCTED \|
292	0	MBEDTLS_ASN1_SEQUENCE));
293
294	0	return (int) len;
295	0	}
296		#endif /* MBEDTLS_PK_HAVE_RFC8410_CURVES */
297
298		/*
299		* RFC 5915, or SEC1 Appendix C.4
300		*
301		* ECPrivateKey ::= SEQUENCE {
302		* version INTEGER { ecPrivkeyVer1(1) } (ecPrivkeyVer1),
303		* privateKey OCTET STRING,
304		* parameters [0] ECParameters {{ NamedCurve }} OPTIONAL,
305		* publicKey [1] BIT STRING OPTIONAL
306		* }
307		*/
308		static int pk_write_ec_der(unsigned char *p, unsigned char buf,
309		const mbedtls_pk_context *pk)
310	0	{
311	0	size_t len = 0;
312	0	int ret;
313	0	size_t pub_len = 0, par_len = 0;
314	0	mbedtls_ecp_group_id grp_id;
315
316		/* publicKey */
317	0	MBEDTLS_ASN1_CHK_ADD(pub_len, pk_write_ec_pubkey(p, buf, pk));
318
319	0	if (*p - buf < 1) {
320	0	return MBEDTLS_ERR_ASN1_BUF_TOO_SMALL;
321	0	}
322	0	(*p)--;
323	0	**p = 0;
324	0	pub_len += 1;
325
326	0	MBEDTLS_ASN1_CHK_ADD(pub_len, mbedtls_asn1_write_len(p, buf, pub_len));
327	0	MBEDTLS_ASN1_CHK_ADD(pub_len, mbedtls_asn1_write_tag(p, buf, MBEDTLS_ASN1_BIT_STRING));
328
329	0	MBEDTLS_ASN1_CHK_ADD(pub_len, mbedtls_asn1_write_len(p, buf, pub_len));
330	0	MBEDTLS_ASN1_CHK_ADD(pub_len, mbedtls_asn1_write_tag(p, buf,
331	0	MBEDTLS_ASN1_CONTEXT_SPECIFIC \|
332	0	MBEDTLS_ASN1_CONSTRUCTED \| 1));
333	0	len += pub_len;
334
335		/* parameters */
336	0	grp_id = mbedtls_pk_get_ec_group_id(pk);
337	0	MBEDTLS_ASN1_CHK_ADD(par_len, pk_write_ec_param(p, buf, grp_id));
338	0	MBEDTLS_ASN1_CHK_ADD(par_len, mbedtls_asn1_write_len(p, buf, par_len));
339	0	MBEDTLS_ASN1_CHK_ADD(par_len, mbedtls_asn1_write_tag(p, buf,
340	0	MBEDTLS_ASN1_CONTEXT_SPECIFIC \|
341	0	MBEDTLS_ASN1_CONSTRUCTED \| 0));
342	0	len += par_len;
343
344		/* privateKey */
345	0	MBEDTLS_ASN1_CHK_ADD(len, pk_write_ec_private(p, buf, pk));
346
347		/* version */
348	0	MBEDTLS_ASN1_CHK_ADD(len, mbedtls_asn1_write_int(p, buf, 1));
349
350	0	MBEDTLS_ASN1_CHK_ADD(len, mbedtls_asn1_write_len(p, buf, len));
351	0	MBEDTLS_ASN1_CHK_ADD(len, mbedtls_asn1_write_tag(p, buf, MBEDTLS_ASN1_CONSTRUCTED \|
352	0	MBEDTLS_ASN1_SEQUENCE));
353
354	0	return (int) len;
355	0	}
356		#endif /* MBEDTLS_PK_HAVE_ECC_KEYS */
357
358		/******************************************************************************
359		* Internal functions for Opaque keys.
360		******************************************************************************/
361		#if defined(MBEDTLS_USE_PSA_CRYPTO)
362		static int pk_write_opaque_pubkey(unsigned char *p, unsigned char start,
363		const mbedtls_pk_context *pk)
364		{
365		size_t buffer_size;
366		size_t len = 0;
367
368		if (*p < start) {
369		return MBEDTLS_ERR_PK_BAD_INPUT_DATA;
370		}
371
372		buffer_size = (size_t) (*p - start);
373		if (psa_export_public_key(pk->priv_id, start, buffer_size,
374		&len) != PSA_SUCCESS) {
375		return MBEDTLS_ERR_PK_BAD_INPUT_DATA;
376		}
377
378		*p -= len;
379		memmove(*p, start, len);
380
381		return (int) len;
382		}
383		#endif /* MBEDTLS_USE_PSA_CRYPTO */
384
385		/******************************************************************************
386		* Generic helpers
387		******************************************************************************/
388
389		/* Extend the public mbedtls_pk_get_type() by getting key type also in case of
390		* opaque keys. */
391		static mbedtls_pk_type_t pk_get_type_ext(const mbedtls_pk_context *pk)
392	0	{
393	0	mbedtls_pk_type_t pk_type = mbedtls_pk_get_type(pk);
394
395		#if defined(MBEDTLS_USE_PSA_CRYPTO)
396		if (pk_type == MBEDTLS_PK_OPAQUE) {
397		psa_key_attributes_t opaque_attrs = PSA_KEY_ATTRIBUTES_INIT;
398		psa_key_type_t opaque_key_type;
399
400		if (psa_get_key_attributes(pk->priv_id, &opaque_attrs) != PSA_SUCCESS) {
401		return MBEDTLS_PK_NONE;
402		}
403		opaque_key_type = psa_get_key_type(&opaque_attrs);
404		psa_reset_key_attributes(&opaque_attrs);
405
406		if (PSA_KEY_TYPE_IS_ECC(opaque_key_type)) {
407		return MBEDTLS_PK_ECKEY;
408		} else if (PSA_KEY_TYPE_IS_RSA(opaque_key_type)) {
409		return MBEDTLS_PK_RSA;
410		} else {
411		return MBEDTLS_PK_NONE;
412		}
413		} else
414		#endif
415	0	return pk_type;
416	0	}
417
418		/******************************************************************************
419		* Public functions for writing private/public DER keys.
420		******************************************************************************/
421		int mbedtls_pk_write_pubkey(unsigned char *p, unsigned char start,
422		const mbedtls_pk_context *key)
423	0	{
424	0	int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
425	0	size_t len = 0;
426
427	0	#if defined(MBEDTLS_RSA_C)
428	0	if (mbedtls_pk_get_type(key) == MBEDTLS_PK_RSA) {
429	0	MBEDTLS_ASN1_CHK_ADD(len, mbedtls_rsa_write_pubkey(mbedtls_pk_rsa(*key), start, p));
430	0	} else
431	0	#endif
432	0	#if defined(MBEDTLS_PK_HAVE_ECC_KEYS)
433	0	if (mbedtls_pk_get_type(key) == MBEDTLS_PK_ECKEY) {
434	0	MBEDTLS_ASN1_CHK_ADD(len, pk_write_ec_pubkey(p, start, key));
435	0	} else
436	0	#endif
437		#if defined(MBEDTLS_USE_PSA_CRYPTO)
438		if (mbedtls_pk_get_type(key) == MBEDTLS_PK_OPAQUE) {
439		MBEDTLS_ASN1_CHK_ADD(len, pk_write_opaque_pubkey(p, start, key));
440		} else
441		#endif /* MBEDTLS_USE_PSA_CRYPTO */
442	0	return MBEDTLS_ERR_PK_FEATURE_UNAVAILABLE;
443
444	0	return (int) len;
445	0	}
446
447		int mbedtls_pk_write_pubkey_der(const mbedtls_pk_context key, unsigned char buf, size_t size)
448	0	{
449	0	int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
450	0	unsigned char *c;
451	0	int has_par = 1;
452	0	size_t len = 0, par_len = 0, oid_len = 0;
453	0	mbedtls_pk_type_t pk_type;
454	0	const char *oid = NULL;
455
456	0	if (size == 0) {
457	0	return MBEDTLS_ERR_ASN1_BUF_TOO_SMALL;
458	0	}
459
460	0	c = buf + size;
461
462	0	MBEDTLS_ASN1_CHK_ADD(len, mbedtls_pk_write_pubkey(&c, buf, key));
463
464	0	if (c - buf < 1) {
465	0	return MBEDTLS_ERR_ASN1_BUF_TOO_SMALL;
466	0	}
467
468		/*
469		* SubjectPublicKeyInfo ::= SEQUENCE {
470		* algorithm AlgorithmIdentifier,
471		* subjectPublicKey BIT STRING }
472		*/
473	0	*--c = 0;
474	0	len += 1;
475
476	0	MBEDTLS_ASN1_CHK_ADD(len, mbedtls_asn1_write_len(&c, buf, len));
477	0	MBEDTLS_ASN1_CHK_ADD(len, mbedtls_asn1_write_tag(&c, buf, MBEDTLS_ASN1_BIT_STRING));
478
479	0	pk_type = pk_get_type_ext(key);
480
481	0	#if defined(MBEDTLS_PK_HAVE_ECC_KEYS)
482	0	if (pk_get_type_ext(key) == MBEDTLS_PK_ECKEY) {
483	0	mbedtls_ecp_group_id ec_grp_id = mbedtls_pk_get_ec_group_id(key);
484	0	if (MBEDTLS_PK_IS_RFC8410_GROUP_ID(ec_grp_id)) {
485	0	ret = mbedtls_oid_get_oid_by_ec_grp_algid(ec_grp_id, &oid, &oid_len);
486	0	if (ret != 0) {
487	0	return ret;
488	0	}
489	0	has_par = 0;
490	0	} else {
491	0	MBEDTLS_ASN1_CHK_ADD(par_len, pk_write_ec_param(&c, buf, ec_grp_id));
492	0	}
493	0	}
494	0	#endif /* MBEDTLS_PK_HAVE_ECC_KEYS */
495
496		/* At this point oid_len is not null only for EC Montgomery keys. */
497	0	if (oid_len == 0) {
498	0	ret = mbedtls_oid_get_oid_by_pk_alg(pk_type, &oid, &oid_len);
499	0	if (ret != 0) {
500	0	return ret;
501	0	}
502	0	}
503
504	0	MBEDTLS_ASN1_CHK_ADD(len, mbedtls_asn1_write_algorithm_identifier_ext(&c, buf, oid, oid_len,
505	0	par_len, has_par));
506
507	0	MBEDTLS_ASN1_CHK_ADD(len, mbedtls_asn1_write_len(&c, buf, len));
508	0	MBEDTLS_ASN1_CHK_ADD(len, mbedtls_asn1_write_tag(&c, buf, MBEDTLS_ASN1_CONSTRUCTED \|
509	0	MBEDTLS_ASN1_SEQUENCE));
510
511	0	return (int) len;
512	0	}
513
514		int mbedtls_pk_write_key_der(const mbedtls_pk_context key, unsigned char buf, size_t size)
515	0	{
516	0	unsigned char *c;
517
518	0	if (size == 0) {
519	0	return MBEDTLS_ERR_ASN1_BUF_TOO_SMALL;
520	0	}
521
522	0	c = buf + size;
523
524	0	#if defined(MBEDTLS_RSA_C)
525	0	if (pk_get_type_ext(key) == MBEDTLS_PK_RSA) {
526	0	return pk_write_rsa_der(&c, buf, key);
527	0	} else
528	0	#endif /* MBEDTLS_RSA_C */
529	0	#if defined(MBEDTLS_PK_HAVE_ECC_KEYS)
530	0	if (pk_get_type_ext(key) == MBEDTLS_PK_ECKEY) {
531	0	#if defined(MBEDTLS_PK_HAVE_RFC8410_CURVES)
532	0	if (mbedtls_pk_is_rfc8410(key)) {
533	0	return pk_write_ec_rfc8410_der(&c, buf, key);
534	0	}
535	0	#endif /* MBEDTLS_PK_HAVE_RFC8410_CURVES */
536	0	return pk_write_ec_der(&c, buf, key);
537	0	} else
538	0	#endif /* MBEDTLS_PK_HAVE_ECC_KEYS */
539	0	return MBEDTLS_ERR_PK_FEATURE_UNAVAILABLE;
540	0	}
541
542		/******************************************************************************
543		* Public functions for wrinting private/public PEM keys.
544		******************************************************************************/
545		#if defined(MBEDTLS_PEM_WRITE_C)
546
547		#define PUB_DER_MAX_BYTES \
548	0	(MBEDTLS_PK_RSA_PUB_DER_MAX_BYTES > MBEDTLS_PK_ECP_PUB_DER_MAX_BYTES ? \
549	0	MBEDTLS_PK_RSA_PUB_DER_MAX_BYTES : MBEDTLS_PK_ECP_PUB_DER_MAX_BYTES)
550		#define PRV_DER_MAX_BYTES \
551	0	(MBEDTLS_PK_RSA_PRV_DER_MAX_BYTES > MBEDTLS_PK_ECP_PRV_DER_MAX_BYTES ? \
552	0	MBEDTLS_PK_RSA_PRV_DER_MAX_BYTES : MBEDTLS_PK_ECP_PRV_DER_MAX_BYTES)
553
554		int mbedtls_pk_write_pubkey_pem(const mbedtls_pk_context key, unsigned char buf, size_t size)
555	0	{
556	0	int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
557	0	unsigned char *output_buf = NULL;
558	0	output_buf = mbedtls_calloc(1, PUB_DER_MAX_BYTES);
559	0	if (output_buf == NULL) {
560	0	return MBEDTLS_ERR_PK_ALLOC_FAILED;
561	0	}
562	0	size_t olen = 0;
563
564	0	if ((ret = mbedtls_pk_write_pubkey_der(key, output_buf,
565	0	PUB_DER_MAX_BYTES)) < 0) {
566	0	goto cleanup;
567	0	}
568
569	0	if ((ret = mbedtls_pem_write_buffer(PEM_BEGIN_PUBLIC_KEY "\n", PEM_END_PUBLIC_KEY "\n",
570	0	output_buf + PUB_DER_MAX_BYTES - ret,
571	0	ret, buf, size, &olen)) != 0) {
572	0	goto cleanup;
573	0	}
574
575	0	ret = 0;
576	0	cleanup:
577	0	mbedtls_free(output_buf);
578	0	return ret;
579	0	}
580
581		int mbedtls_pk_write_key_pem(const mbedtls_pk_context key, unsigned char buf, size_t size)
582	0	{
583	0	int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
584	0	unsigned char *output_buf = NULL;
585	0	output_buf = mbedtls_calloc(1, PRV_DER_MAX_BYTES);
586	0	if (output_buf == NULL) {
587	0	return MBEDTLS_ERR_PK_ALLOC_FAILED;
588	0	}
589	0	const char begin, end;
590	0	size_t olen = 0;
591
592	0	if ((ret = mbedtls_pk_write_key_der(key, output_buf, PRV_DER_MAX_BYTES)) < 0) {
593	0	goto cleanup;
594	0	}
595
596	0	#if defined(MBEDTLS_RSA_C)
597	0	if (pk_get_type_ext(key) == MBEDTLS_PK_RSA) {
598	0	begin = PEM_BEGIN_PRIVATE_KEY_RSA "\n";
599	0	end = PEM_END_PRIVATE_KEY_RSA "\n";
600	0	} else
601	0	#endif
602	0	#if defined(MBEDTLS_PK_HAVE_ECC_KEYS)
603	0	if (pk_get_type_ext(key) == MBEDTLS_PK_ECKEY) {
604	0	if (mbedtls_pk_is_rfc8410(key)) {
605	0	begin = PEM_BEGIN_PRIVATE_KEY_PKCS8 "\n";
606	0	end = PEM_END_PRIVATE_KEY_PKCS8 "\n";
607	0	} else {
608	0	begin = PEM_BEGIN_PRIVATE_KEY_EC "\n";
609	0	end = PEM_END_PRIVATE_KEY_EC "\n";
610	0	}
611	0	} else
612	0	#endif /* MBEDTLS_PK_HAVE_ECC_KEYS */
613	0	{
614	0	ret = MBEDTLS_ERR_PK_FEATURE_UNAVAILABLE;
615	0	goto cleanup;
616	0	}
617
618	0	if ((ret = mbedtls_pem_write_buffer(begin, end,
619	0	output_buf + PRV_DER_MAX_BYTES - ret,
620	0	ret, buf, size, &olen)) != 0) {
621	0	goto cleanup;
622	0	}
623
624	0	ret = 0;
625	0	cleanup:
626	0	mbedtls_zeroize_and_free(output_buf, PRV_DER_MAX_BYTES);
627	0	return ret;
628	0	}
629		#endif /* MBEDTLS_PEM_WRITE_C */
630
631		#endif /* MBEDTLS_PK_WRITE_C */