coffee/mbedtls
1
0
Fork 0
mirror of https://github.com/Mbed-TLS/mbedtls.git synced 2026-07-30 16:26:33 +08:00
Code Issues Packages Projects Releases Wiki Activity

Add async hardware TLS crypto hook points

Browse Source 
Signed-off-by: Cal Abel <crabel@mac.com>
This commit is contained in:
Cal Abel 2026-07-03 17:04:40 -04:00
parent 4ac39086c0
commit 9f000bab4a
4 changed files with 204 additions and 52 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

28
library/ssl_misc.h
View File

@ -714,8 +714,8 @@ struct mbedtls_ssl_handshake_params {
uint8_t samd_ecdh_secret_done;
uint8_t samd_ecdh_secret_success;
uint8_t samd_ecdh_secret_ready;
unsigned char samd_ecdh_private_scalar[48];
unsigned char samd_ecdh_public_key[97];
unsigned char samd_ecdh_private_scalar[66];
unsigned char samd_ecdh_public_key[133];
#endif
#if defined(MBEDTLS_SSL_ECP_RESTARTABLE_ENABLED)
@ -925,6 +925,9 @@ struct mbedtls_ssl_handshake_params {
#if defined(PSA_WANT_ALG_SHA_384)
psa_hash_operation_t fin_sha384_psa;
#endif
#if defined(PSA_WANT_ALG_SHA_512)
psa_hash_operation_t fin_sha512_psa;
#endif
#if defined(MBEDTLS_SSL_PROTO_TLS1_3)
uint16_t offered_group_id; /* The NamedGroup value for the group
@ -2336,7 +2339,6 @@ static inline const void *mbedtls_ssl_get_sig_algs(
#endif /* MBEDTLS_SSL_HANDSHAKE_WITH_CERT_ENABLED */
}
#if defined(MBEDTLS_SSL_TLS1_3_KEY_EXCHANGE_MODE_EPHEMERAL_ENABLED)
static inline int mbedtls_ssl_sig_alg_is_received(const mbedtls_ssl_context *ssl,
uint16_t own_sig_alg)
{
@ -2353,6 +2355,7 @@ static inline int mbedtls_ssl_sig_alg_is_received(const mbedtls_ssl_context *ssl
return 0;
}
#if defined(MBEDTLS_SSL_TLS1_3_KEY_EXCHANGE_MODE_EPHEMERAL_ENABLED)
static inline int mbedtls_ssl_tls13_sig_alg_for_cert_verify_is_supported(
const uint16_t sig_alg)
{
@ -2481,6 +2484,25 @@ static inline int mbedtls_ssl_get_pk_sigalg_and_md_alg_from_sig_alg(
static inline int mbedtls_ssl_tls12_sig_alg_is_supported(
const uint16_t sig_alg)
{
switch (sig_alg) {
#if defined(PSA_WANT_ALG_RSA_PSS)
#if defined(PSA_WANT_ALG_SHA_256)
case MBEDTLS_TLS1_3_SIG_RSA_PSS_RSAE_SHA256:
return 1;
#endif
#if defined(PSA_WANT_ALG_SHA_384)
case MBEDTLS_TLS1_3_SIG_RSA_PSS_RSAE_SHA384:
return 1;
#endif
#if defined(PSA_WANT_ALG_SHA_512)
case MBEDTLS_TLS1_3_SIG_RSA_PSS_RSAE_SHA512:
return 1;
#endif
#endif /* PSA_WANT_ALG_RSA_PSS */
default:
break;
}
/* High byte is hash */
unsigned char hash = MBEDTLS_BYTE_1(sig_alg);
unsigned char sig = MBEDTLS_BYTE_0(sig_alg);

79
library/ssl_tls.c
View File

@ -446,6 +446,10 @@ static int ssl_calc_verify_tls_sha384(const mbedtls_ssl_context *, unsigned char
static int ssl_calc_finished_tls_sha384(mbedtls_ssl_context *, unsigned char *, int);
#endif /* PSA_WANT_ALG_SHA_384*/
#if defined(PSA_WANT_ALG_SHA_512)
static int ssl_calc_verify_tls_sha512(const mbedtls_ssl_context *, unsigned char *, size_t *);
#endif /* PSA_WANT_ALG_SHA_512 */
MBEDTLS_CHECK_RETURN_CRITICAL
static int ssl_tls12_session_load(mbedtls_ssl_session *session,
const unsigned char *buf,
@ -462,6 +466,10 @@ static int ssl_update_checksum_sha256(mbedtls_ssl_context *, const unsigned char
static int ssl_update_checksum_sha384(mbedtls_ssl_context *, const unsigned char *, size_t);
#endif /* PSA_WANT_ALG_SHA_384*/
#if defined(PSA_WANT_ALG_SHA_512)
static int ssl_update_checksum_sha512(mbedtls_ssl_context *, const unsigned char *, size_t);
#endif /* PSA_WANT_ALG_SHA_512 */
int mbedtls_ssl_tls_prf(const mbedtls_tls_prf_types prf,
const unsigned char *secret, size_t slen,
const char *label,
@ -791,6 +799,10 @@ void mbedtls_ssl_optimize_checksum(mbedtls_ssl_context *ssl,
{
((void) ciphersuite_info);
#if defined(PSA_WANT_ALG_SHA_512)
((void) ssl);
return;
#else
#if defined(PSA_WANT_ALG_SHA_384)
if (ciphersuite_info->mac == MBEDTLS_MD_SHA384) {
ssl->handshake->update_checksum = ssl_update_checksum_sha384;
@ -805,6 +817,7 @@ void mbedtls_ssl_optimize_checksum(mbedtls_ssl_context *ssl,
MBEDTLS_SSL_DEBUG_MSG(1, ("should never happen"));
return;
}
#endif
}
int mbedtls_ssl_add_hs_hdr_to_checksum(mbedtls_ssl_context *ssl,
@ -838,11 +851,12 @@ int mbedtls_ssl_add_hs_msg_to_checksum(mbedtls_ssl_context *ssl,
int mbedtls_ssl_reset_checksum(mbedtls_ssl_context *ssl)
{
#if defined(PSA_WANT_ALG_SHA_256) || \
defined(PSA_WANT_ALG_SHA_384)
defined(PSA_WANT_ALG_SHA_384) || \
defined(PSA_WANT_ALG_SHA_512)
psa_status_t status;
#else /* SHA-256 or SHA-384 */
#else /* SHA-256, SHA-384 or SHA-512 */
((void) ssl);
#endif /* SHA-256 or SHA-384 */
#endif /* SHA-256, SHA-384 or SHA-512 */
#if defined(PSA_WANT_ALG_SHA_256)
status = psa_hash_abort(&ssl->handshake->fin_sha256_psa);
if (status != PSA_SUCCESS) {
@ -862,6 +876,16 @@ int mbedtls_ssl_reset_checksum(mbedtls_ssl_context *ssl)
if (status != PSA_SUCCESS) {
return mbedtls_md_error_from_psa(status);
}
#endif
#if defined(PSA_WANT_ALG_SHA_512)
status = psa_hash_abort(&ssl->handshake->fin_sha512_psa);
if (status != PSA_SUCCESS) {
return mbedtls_md_error_from_psa(status);
}
status = psa_hash_setup(&ssl->handshake->fin_sha512_psa, PSA_ALG_SHA_512);
if (status != PSA_SUCCESS) {
return mbedtls_md_error_from_psa(status);
}
#endif
return 0;
}
@ -870,13 +894,14 @@ static int ssl_update_checksum_start(mbedtls_ssl_context *ssl,
const unsigned char *buf, size_t len)
{
#if defined(PSA_WANT_ALG_SHA_256) || \
defined(PSA_WANT_ALG_SHA_384)
defined(PSA_WANT_ALG_SHA_384) || \
defined(PSA_WANT_ALG_SHA_512)
psa_status_t status;
#else /* SHA-256 or SHA-384 */
#else /* SHA-256, SHA-384 or SHA-512 */
((void) ssl);
(void) buf;
(void) len;
#endif /* SHA-256 or SHA-384 */
#endif /* SHA-256, SHA-384 or SHA-512 */
#if defined(PSA_WANT_ALG_SHA_256)
status = psa_hash_update(&ssl->handshake->fin_sha256_psa, buf, len);
if (status != PSA_SUCCESS) {
@ -888,6 +913,12 @@ static int ssl_update_checksum_start(mbedtls_ssl_context *ssl,
if (status != PSA_SUCCESS) {
return mbedtls_md_error_from_psa(status);
}
#endif
#if defined(PSA_WANT_ALG_SHA_512)
status = psa_hash_update(&ssl->handshake->fin_sha512_psa, buf, len);
if (status != PSA_SUCCESS) {
return mbedtls_md_error_from_psa(status);
}
#endif
return 0;
}
@ -910,6 +941,15 @@ static int ssl_update_checksum_sha384(mbedtls_ssl_context *ssl,
}
#endif
#if defined(PSA_WANT_ALG_SHA_512)
static int ssl_update_checksum_sha512(mbedtls_ssl_context *ssl,
const unsigned char *buf, size_t len)
{
return mbedtls_md_error_from_psa(psa_hash_update(
&ssl->handshake->fin_sha512_psa, buf, len));
}
#endif
static void ssl_handshake_params_init(mbedtls_ssl_handshake_params *handshake)
{
memset(handshake, 0, sizeof(mbedtls_ssl_handshake_params));
@ -920,6 +960,9 @@ static void ssl_handshake_params_init(mbedtls_ssl_handshake_params *handshake)
#if defined(PSA_WANT_ALG_SHA_384)
handshake->fin_sha384_psa = psa_hash_operation_init();
#endif
#if defined(PSA_WANT_ALG_SHA_512)
handshake->fin_sha512_psa = psa_hash_operation_init();
#endif
handshake->update_checksum = ssl_update_checksum_start;
@ -4462,6 +4505,9 @@ void mbedtls_ssl_handshake_free(mbedtls_ssl_context *ssl)
#if defined(PSA_WANT_ALG_SHA_384)
psa_hash_abort(&handshake->fin_sha384_psa);
#endif
#if defined(PSA_WANT_ALG_SHA_512)
psa_hash_abort(&handshake->fin_sha512_psa);
#endif
#if defined(MBEDTLS_KEY_EXCHANGE_ECJPAKE_ENABLED)
psa_pake_abort(&handshake->psa_pake_ctx);
@ -5913,6 +5959,12 @@ int mbedtls_ssl_get_handshake_transcript(mbedtls_ssl_context *ssl,
*olen = 0;
switch (md) {
#if defined(PSA_WANT_ALG_SHA_512)
case MBEDTLS_MD_SHA512:
hash_operation_to_clone = &ssl->handshake->fin_sha512_psa;
break;
#endif
#if defined(PSA_WANT_ALG_SHA_384)
case MBEDTLS_MD_SHA384:
hash_operation_to_clone = &ssl->handshake->fin_sha384_psa;
@ -6542,6 +6594,11 @@ int mbedtls_ssl_derive_keys(mbedtls_ssl_context *ssl)
int mbedtls_ssl_set_calc_verify_md(mbedtls_ssl_context *ssl, int md)
{
switch (md) {
#if defined(PSA_WANT_ALG_SHA_512)
case MBEDTLS_SSL_HASH_SHA512:
ssl->handshake->calc_verify = ssl_calc_verify_tls_sha512;
break;
#endif
#if defined(PSA_WANT_ALG_SHA_384)
case MBEDTLS_SSL_HASH_SHA384:
ssl->handshake->calc_verify = ssl_calc_verify_tls_sha384;
@ -6613,6 +6670,16 @@ int ssl_calc_verify_tls_sha384(const mbedtls_ssl_context *ssl,
}
#endif /* PSA_WANT_ALG_SHA_384 */
#if defined(PSA_WANT_ALG_SHA_512)
int ssl_calc_verify_tls_sha512(const mbedtls_ssl_context *ssl,
unsigned char *hash,
size_t *hlen)
{
return ssl_calc_verify_tls_psa(ssl, &ssl->handshake->fin_sha512_psa, 64,
hash, hlen);
}
#endif /* PSA_WANT_ALG_SHA_512 */
#if defined(MBEDTLS_SSL_SRV_C) && defined(MBEDTLS_SSL_RENEGOTIATION)
MBEDTLS_CHECK_RETURN_CRITICAL
static int ssl_write_hello_request(mbedtls_ssl_context *ssl);

143
library/ssl_tls12_client.c
View File

@ -61,6 +61,11 @@ int samd_mbedtls_ecdh_p384_public_key_start(
uint8_t public_key[97],
samd_mbedtls_async_callback_t callback,
void *context);
int samd_mbedtls_ecdh_p521_public_key_start(
const uint8_t private_scalar[66],
uint8_t public_key[133],
samd_mbedtls_async_callback_t callback,
void *context);
int samd_mbedtls_ecdh_p256_start(
const uint8_t private_scalar[32],
const uint8_t peer_public_key[65],
@ -73,6 +78,12 @@ int samd_mbedtls_ecdh_p384_start(
uint8_t shared_secret[48],
samd_mbedtls_async_callback_t callback,
void *context);
int samd_mbedtls_ecdh_p521_start(
const uint8_t private_scalar[66],
const uint8_t peer_public_key[133],
uint8_t shared_secret[66],
samd_mbedtls_async_callback_t callback,
void *context);
static void samd_mbedtls_ssl_random_callback(int success, void *context)
{
@ -177,7 +188,7 @@ static int samd_mbedtls_ssl_ecdh_public_key_fill(mbedtls_ssl_context *ssl)
handshake->samd_ecdh_public_done = 0;
handshake->samd_ecdh_public_success = 0;
handshake->samd_ecdh_public_ready = 0;
coordinate_len = handshake->xxdh_psa_bits / 8u;
coordinate_len = (handshake->xxdh_psa_bits + 7u) / 8u;
if ((coordinate_len == 32 ?
samd_mbedtls_ecdh_p256_public_key_start(
@ -191,6 +202,12 @@ static int samd_mbedtls_ssl_ecdh_public_key_fill(mbedtls_ssl_context *ssl)
handshake->samd_ecdh_public_key,
samd_mbedtls_ssl_ecdh_public_key_callback,
handshake) :
coordinate_len == 66 ?
samd_mbedtls_ecdh_p521_public_key_start(
handshake->samd_ecdh_private_scalar,
handshake->samd_ecdh_public_key,
samd_mbedtls_ssl_ecdh_public_key_callback,
handshake) :
0) == 0) {
handshake->samd_ecdh_public_pending = 0;
return MBEDTLS_ERR_SSL_HW_ACCEL_FAILED;
@ -238,7 +255,7 @@ static int samd_mbedtls_ssl_ecdh_secret_fill(mbedtls_ssl_context *ssl)
}
handshake->samd_ecdh_secret_success = 0;
handshake->samd_ecdh_secret_ready = 1;
ssl->handshake->pmslen = handshake->xxdh_psa_bits / 8u;
ssl->handshake->pmslen = (handshake->xxdh_psa_bits + 7u) / 8u;
return 0;
}
@ -246,7 +263,7 @@ static int samd_mbedtls_ssl_ecdh_secret_fill(mbedtls_ssl_context *ssl)
handshake->samd_ecdh_secret_done = 0;
handshake->samd_ecdh_secret_success = 0;
handshake->samd_ecdh_secret_ready = 0;
coordinate_len = handshake->xxdh_psa_bits / 8u;
coordinate_len = (handshake->xxdh_psa_bits + 7u) / 8u;
if ((coordinate_len == 32 ?
samd_mbedtls_ecdh_p256_start(
@ -262,6 +279,13 @@ static int samd_mbedtls_ssl_ecdh_secret_fill(mbedtls_ssl_context *ssl)
ssl->handshake->premaster,
samd_mbedtls_ssl_ecdh_secret_callback,
handshake) :
coordinate_len == 66 ?
samd_mbedtls_ecdh_p521_start(
handshake->samd_ecdh_private_scalar,
handshake->xxdh_psa_peerkey,
ssl->handshake->premaster,
samd_mbedtls_ssl_ecdh_secret_callback,
handshake) :
0) == 0) {
handshake->samd_ecdh_secret_pending = 0;
return MBEDTLS_ERR_SSL_HW_ACCEL_FAILED;
@ -2311,13 +2335,14 @@ start_processing:
}
#endif
#if defined(MBEDTLS_X509_RSASSA_PSS_SUPPORT)
if (pk_alg == MBEDTLS_PK_SIGALG_RSA_PSS) {
#if defined(MBEDTLS_X509_RSASSA_PSS_SUPPORT) || defined(MBEDTLS_ASYNC_HARDWARE_RSA)
if (pk_alg == MBEDTLS_PK_SIGALG_RSA_PSS ||
pk_alg == MBEDTLS_PK_SIGALG_RSA_PKCS1V15) {
ret = mbedtls_pk_verify_ext((mbedtls_pk_sigalg_t) pk_alg, peer_pk,
md_alg, hash, hashlen,
p, sig_len);
} else
#endif /* MBEDTLS_X509_RSASSA_PSS_SUPPORT */
#endif /* MBEDTLS_X509_RSASSA_PSS_SUPPORT || MBEDTLS_ASYNC_HARDWARE_RSA */
ret = mbedtls_pk_verify_restartable(peer_pk,
md_alg, hash, hashlen, p, sig_len, rs_ctx);
@ -2389,8 +2414,8 @@ static int ssl_parse_certificate_request(mbedtls_ssl_context *ssl)
const mbedtls_ssl_ciphersuite_t *ciphersuite_info =
ssl->handshake->ciphersuite_info;
size_t sig_alg_len;
#if defined(MBEDTLS_DEBUG_C)
unsigned char *sig_alg;
#if defined(MBEDTLS_DEBUG_C)
unsigned char *dn;
#endif
@ -2506,8 +2531,8 @@ static int ssl_parse_certificate_request(mbedtls_ssl_context *ssl)
return MBEDTLS_ERR_SSL_DECODE_ERROR;
}
#if defined(MBEDTLS_DEBUG_C)
sig_alg = buf + mbedtls_ssl_hs_hdr_len(ssl) + 3 + n;
#if defined(MBEDTLS_DEBUG_C)
for (size_t i = 0; i < sig_alg_len; i += 2) {
MBEDTLS_SSL_DEBUG_MSG(3,
("Supported Signature Algorithm found: %02x %02x",
@ -2515,6 +2540,12 @@ static int ssl_parse_certificate_request(mbedtls_ssl_context *ssl)
}
#endif
if ((ret = mbedtls_ssl_parse_sig_alg_ext(
ssl, sig_alg - 2, sig_alg + sig_alg_len)) != 0) {
MBEDTLS_SSL_DEBUG_RET(1, "mbedtls_ssl_parse_sig_alg_ext", ret);
return ret;
}
n += 2 + sig_alg_len;
/* certificate_authorities */
@ -2665,11 +2696,12 @@ static int ssl_write_client_key_exchange(mbedtls_ssl_context *ssl)
size_t samd_coordinate_len;
size_t samd_public_key_len;
if (handshake->xxdh_psa_bits !=
256u && handshake->xxdh_psa_bits != 384u) {
if (handshake->xxdh_psa_bits != 256u &&
handshake->xxdh_psa_bits != 384u &&
handshake->xxdh_psa_bits != 521u) {
return MBEDTLS_ERR_SSL_HW_ACCEL_FAILED;
}
samd_coordinate_len = handshake->xxdh_psa_bits / 8u;
samd_coordinate_len = (handshake->xxdh_psa_bits + 7u) / 8u;
samd_public_key_len = samd_coordinate_len * 2u + 1u;
if (handshake->samd_ecdh_private_ready == 0) {
@ -3065,9 +3097,11 @@ static int ssl_write_certificate_verify(mbedtls_ssl_context *ssl)
const mbedtls_ssl_ciphersuite_t *ciphersuite_info =
ssl->handshake->ciphersuite_info;
size_t n = 0, offset = 0;
unsigned char hash[48];
unsigned char hash[64];
unsigned char *hash_start = hash;
mbedtls_md_type_t md_alg = MBEDTLS_MD_NONE;
mbedtls_pk_sigalg_t pk_alg = MBEDTLS_PK_SIGALG_NONE;
uint16_t selected_sig_alg = MBEDTLS_TLS_SIG_NONE;
size_t hashlen;
void *rs_ctx = NULL;
#if defined(MBEDTLS_SSL_VARIABLE_BUFFER_LENGTH)
@ -3125,30 +3159,43 @@ sign:
return ret;
}
/*
* digitally-signed struct {
* opaque handshake_messages[handshake_messages_length];
* };
*
* Taking shortcut here. We assume that the server always allows the
* PRF Hash function and has sent it in the allowed signature
* algorithms list received in the Certificate Request message.
*
* Until we encounter a server that does not, we will take this
* shortcut.
*
* Reason: Otherwise we should have running hashes for SHA512 and
* SHA224 in order to satisfy 'weird' needs from the server
* side.
*/
if (ssl->handshake->ciphersuite_info->mac == MBEDTLS_MD_SHA384) {
md_alg = MBEDTLS_MD_SHA384;
ssl->out_msg[4] = MBEDTLS_SSL_HASH_SHA384;
} else {
md_alg = MBEDTLS_MD_SHA256;
ssl->out_msg[4] = MBEDTLS_SSL_HASH_SHA256;
const uint16_t *received_sig_alg = ssl->handshake->received_sig_algs;
for (; *received_sig_alg != MBEDTLS_TLS_SIG_NONE; received_sig_alg++) {
psa_algorithm_t psa_hash_alg = PSA_ALG_NONE;
psa_algorithm_t psa_sig_alg = PSA_ALG_NONE;
mbedtls_pk_sigalg_t candidate_pk_alg = MBEDTLS_PK_SIGALG_NONE;
mbedtls_md_type_t candidate_md_alg = MBEDTLS_MD_NONE;
if (mbedtls_ssl_get_pk_sigalg_and_md_alg_from_sig_alg(
*received_sig_alg, &candidate_pk_alg, &candidate_md_alg) != 0) {
continue;
}
psa_hash_alg = mbedtls_md_psa_alg_from_type(candidate_md_alg);
psa_sig_alg = mbedtls_psa_alg_from_pk_sigalg(candidate_pk_alg,
psa_hash_alg);
if (!mbedtls_pk_can_do_psa(mbedtls_ssl_own_key(ssl), psa_sig_alg,
PSA_KEY_USAGE_SIGN_HASH)) {
continue;
}
if (mbedtls_ssl_set_calc_verify_md(
ssl, mbedtls_ssl_hash_from_md_alg(candidate_md_alg)) != 0) {
continue;
}
selected_sig_alg = *received_sig_alg;
pk_alg = candidate_pk_alg;
md_alg = candidate_md_alg;
break;
}
ssl->out_msg[5] = mbedtls_ssl_sig_from_pk(mbedtls_ssl_own_key(ssl));
if (selected_sig_alg == MBEDTLS_TLS_SIG_NONE) {
MBEDTLS_SSL_DEBUG_MSG(1, ("no suitable client signature algorithm"));
return MBEDTLS_ERR_SSL_HANDSHAKE_FAILURE;
}
MBEDTLS_PUT_UINT16_BE(selected_sig_alg, ssl->out_msg, 4);
/* Info from md_alg will be used instead */
hashlen = 0;
@ -3160,14 +3207,24 @@ sign:
}
#endif
if ((ret = mbedtls_pk_sign_restartable(mbedtls_ssl_own_key(ssl),
md_alg, hash_start, hashlen,
ssl->out_msg + 6 + offset,
out_buf_len - 6 - offset,
&n,
rs_ctx)) != 0) {
MBEDTLS_SSL_DEBUG_RET(1, "mbedtls_pk_sign_restartable", ret);
#if defined(MBEDTLS_SSL_ECP_RESTARTABLE_ENABLED)
if (pk_alg == MBEDTLS_PK_SIGALG_RSA_PSS ||
pk_alg == MBEDTLS_PK_SIGALG_RSA_PKCS1V15) {
ret = mbedtls_pk_sign_ext(pk_alg, mbedtls_ssl_own_key(ssl),
md_alg, hash_start, hashlen,
ssl->out_msg + 6 + offset,
out_buf_len - 6 - offset, &n);
} else {
ret = mbedtls_pk_sign_restartable(mbedtls_ssl_own_key(ssl),
md_alg, hash_start, hashlen,
ssl->out_msg + 6 + offset,
out_buf_len - 6 - offset,
&n,
rs_ctx);
}
if (ret != 0) {
MBEDTLS_SSL_DEBUG_RET(1, "mbedtls_pk_sign", ret);
#if defined(MBEDTLS_SSL_ECP_RESTARTABLE_ENABLED) || \
defined(MBEDTLS_ASYNC_HARDWARE_ECDSA) || defined(MBEDTLS_ASYNC_HARDWARE_RSA)
if (ret == MBEDTLS_ERR_ECP_IN_PROGRESS) {
ret = MBEDTLS_ERR_SSL_CRYPTO_IN_PROGRESS;
}

6
library/ssl_tls13_generic.c
View File

@ -974,6 +974,12 @@ static int ssl_tls13_write_certificate_verify_body(mbedtls_ssl_context *ssl,
if ((ret = mbedtls_pk_sign_ext((mbedtls_pk_sigalg_t) pk_type, own_key,
md_alg, verify_hash, verify_hash_len,
p + 4, (size_t) (end - (p + 4)), &signature_len)) != 0) {
#if defined(MBEDTLS_SSL_ECP_RESTARTABLE_ENABLED) || \
defined(MBEDTLS_ASYNC_HARDWARE_ECDSA) || defined(MBEDTLS_ASYNC_HARDWARE_RSA)
if (ret == MBEDTLS_ERR_ECP_IN_PROGRESS) {
return MBEDTLS_ERR_SSL_CRYPTO_IN_PROGRESS;
}
#endif
MBEDTLS_SSL_DEBUG_MSG(2, ("CertificateVerify signature failed with %s",
mbedtls_ssl_sig_alg_to_str(*sig_alg)));
MBEDTLS_SSL_DEBUG_RET(2, "mbedtls_pk_sign_ext", ret);