From 9f4e752ef3f8ff33d882e9134a583992d349e634 Mon Sep 17 00:00:00 2001 From: Ron Eldor Date: Wed, 24 Oct 2018 14:21:59 +0300 Subject: [PATCH] Modify HW accelerator drivers to new error code Have the HW accelearation drivers return the platform module errors about feature unsupported, and hw acceleration failure, because the moduel specific errors will be removed. --- .../FEATURE_CRYPTOCELL310/cc_internal.c | 5 +-- .../FEATURE_CRYPTOCELL310/cc_internal.h | 2 +- .../FEATURE_CRYPTOCELL310/ccm_alt.c | 6 ++-- .../FEATURE_CRYPTOCELL310/ecdh_alt.c | 4 +-- .../FEATURE_CRYPTOCELL310/ecdsa_alt.c | 6 ++-- .../FEATURE_CRYPTOCELL310/sha1_alt.c | 8 ++--- .../FEATURE_CRYPTOCELL310/sha256_alt.c | 8 ++--- .../TARGET_M480/ecp/ecp_internal_alt.c | 4 +-- features/mbedtls/targets/TARGET_STM/aes_alt.c | 3 +- features/mbedtls/targets/TARGET_STM/md5_alt.c | 26 +++++++------- .../mbedtls/targets/TARGET_STM/sha1_alt.c | 26 +++++++------- .../mbedtls/targets/TARGET_STM/sha256_alt.c | 34 +++++++++---------- .../targets/TARGET_Silicon_Labs/aes_aes.c | 5 +-- .../targets/TARGET_Silicon_Labs/crypto_ecp.c | 2 +- 14 files changed, 71 insertions(+), 68 deletions(-) diff --git a/features/cryptocell/FEATURE_CRYPTOCELL310/cc_internal.c b/features/cryptocell/FEATURE_CRYPTOCELL310/cc_internal.c index acad6d5482..5415975c0b 100644 --- a/features/cryptocell/FEATURE_CRYPTOCELL310/cc_internal.c +++ b/features/cryptocell/FEATURE_CRYPTOCELL310/cc_internal.c @@ -24,6 +24,7 @@ #include "cc_internal.h" #include "crys_ecpki_error.h" #include "crys_ec_mont_edw_error.h" +#include "mbedtls/platform.h" CRYS_ECPKI_DomainID_t convert_mbedtls_grp_id_to_crys_domain_id( mbedtls_ecp_group_id grp_id ) { @@ -135,7 +136,7 @@ int convert_CrysError_to_mbedtls_err( CRYSError_t Crys_err ) case CRYS_ECMONT_IS_NOT_SUPPORTED: case CRYS_ECEDW_IS_NOT_SUPPORTED: - return ( MBEDTLS_ERR_ECP_FEATURE_UNAVAILABLE ); + return ( MBEDTLS_ERR_PLATFORM_FEATURE_UNSUPPORTED ); case CRYS_ECEDW_RND_GEN_VECTOR_FUNC_ERROR: return ( MBEDTLS_ERR_ECP_RANDOM_FAILED ); @@ -146,7 +147,7 @@ int convert_CrysError_to_mbedtls_err( CRYSError_t Crys_err ) return ( MBEDTLS_ERR_ECP_INVALID_KEY ); default: - return ( MBEDTLS_ERR_ECP_HW_ACCEL_FAILED ); + return ( MBEDTLS_ERR_PLATFORM_HW_ACCEL_FAILED ); } diff --git a/features/cryptocell/FEATURE_CRYPTOCELL310/cc_internal.h b/features/cryptocell/FEATURE_CRYPTOCELL310/cc_internal.h index d61802e254..66efc0f722 100644 --- a/features/cryptocell/FEATURE_CRYPTOCELL310/cc_internal.h +++ b/features/cryptocell/FEATURE_CRYPTOCELL310/cc_internal.h @@ -122,7 +122,7 @@ uint32_t convert_mbedtls_to_cc_rand( void* mbedtls_rand, uint16_t outSizeBytes, * * * \return \c The corresponding Mbed TLS error, - * MBEDTLS_ERR_ECP_HW_ACCEL_FAILED as default, if none found + * MBEDTLS_ERR_PLATFORM_HW_ACCEL_FAILED as default, if none found */ int convert_CrysError_to_mbedtls_err( CRYSError_t Crys_err ); diff --git a/features/cryptocell/FEATURE_CRYPTOCELL310/ccm_alt.c b/features/cryptocell/FEATURE_CRYPTOCELL310/ccm_alt.c index 4ba4be03bb..1a43214a19 100644 --- a/features/cryptocell/FEATURE_CRYPTOCELL310/ccm_alt.c +++ b/features/cryptocell/FEATURE_CRYPTOCELL310/ccm_alt.c @@ -51,7 +51,7 @@ int mbedtls_ccm_setkey( mbedtls_ccm_context *ctx, if( cipher != MBEDTLS_CIPHER_ID_AES || keybits != 128 ) { - return ( MBEDTLS_ERR_AES_FEATURE_UNAVAILABLE ); + return ( MBEDTLS_ERR_PLATFORM_FEATURE_UNSUPPORTED ); } memcpy( ctx->cipher_key , key, keybits / 8 ); @@ -93,7 +93,7 @@ int mbedtls_ccm_encrypt_and_tag( mbedtls_ccm_context *ctx, size_t length, CrysRet = CRYS_AESCCM( SASI_AES_ENCRYPT, ctx->cipher_key, ctx->keySize_ID,(uint8_t*)iv, iv_len, (uint8_t*)add, add_len, (uint8_t*)input, length, output, tag_len, tag ); if( CrysRet != CRYS_OK ) - return ( MBEDTLS_ERR_CCM_HW_ACCEL_FAILED ); + return ( MBEDTLS_ERR_PLATFORM_HW_ACCEL_FAILED ); return ( 0 ); @@ -130,7 +130,7 @@ int mbedtls_ccm_auth_decrypt( mbedtls_ccm_context *ctx, size_t length, CrysRet = CRYS_AESCCM( SASI_AES_DECRYPT, ctx->cipher_key, ctx->keySize_ID,(uint8_t*)iv, iv_len, (uint8_t*)add, add_len, (uint8_t*)input, length, output, tag_len, (uint8_t*)tag ); if ( CrysRet != CRYS_OK ) - return ( MBEDTLS_ERR_CCM_HW_ACCEL_FAILED ); + return ( MBEDTLS_ERR_PLATFORM_HW_ACCEL_FAILED ); return ( 0 ); diff --git a/features/cryptocell/FEATURE_CRYPTOCELL310/ecdh_alt.c b/features/cryptocell/FEATURE_CRYPTOCELL310/ecdh_alt.c index 9c99347e4e..b6df3f2246 100644 --- a/features/cryptocell/FEATURE_CRYPTOCELL310/ecdh_alt.c +++ b/features/cryptocell/FEATURE_CRYPTOCELL310/ecdh_alt.c @@ -118,7 +118,7 @@ int mbedtls_ecdh_gen_public( mbedtls_ecp_group *grp, mbedtls_mpi *d, mbedtls_ecp MBEDTLS_MPI_CHK( mbedtls_mpi_lset( &Q->Z, 1 ) ); } else - ret = MBEDTLS_ERR_ECP_FEATURE_UNAVAILABLE; + ret = MBEDTLS_ERR_PLATFORM_FEATURE_UNSUPPORTED; cleanup: @@ -231,7 +231,7 @@ int mbedtls_ecdh_compute_shared( mbedtls_ecp_group *grp, mbedtls_mpi *z, } else { - ret = MBEDTLS_ERR_ECP_FEATURE_UNAVAILABLE; + ret = MBEDTLS_ERR_PLATFORM_FEATURE_UNSUPPORTED; goto cleanup; } diff --git a/features/cryptocell/FEATURE_CRYPTOCELL310/ecdsa_alt.c b/features/cryptocell/FEATURE_CRYPTOCELL310/ecdsa_alt.c index 995a5706a3..fb7e87121b 100644 --- a/features/cryptocell/FEATURE_CRYPTOCELL310/ecdsa_alt.c +++ b/features/cryptocell/FEATURE_CRYPTOCELL310/ecdsa_alt.c @@ -132,7 +132,7 @@ int mbedtls_ecdsa_sign( mbedtls_ecp_group *grp, mbedtls_mpi *r, mbedtls_mpi *s, } else { - ret = MBEDTLS_ERR_ECP_FEATURE_UNAVAILABLE; + ret = MBEDTLS_ERR_PLATFORM_FEATURE_UNSUPPORTED; goto cleanup; } @@ -226,7 +226,7 @@ int mbedtls_ecdsa_verify( mbedtls_ecp_group *grp, } } else - ret = MBEDTLS_ERR_ECP_FEATURE_UNAVAILABLE; + ret = MBEDTLS_ERR_PLATFORM_FEATURE_UNSUPPORTED; cleanup: @@ -313,7 +313,7 @@ int mbedtls_ecdsa_genkey( mbedtls_ecdsa_context *ctx, mbedtls_ecp_group_id gid, } } else - ret = MBEDTLS_ERR_ECP_FEATURE_UNAVAILABLE; + ret = MBEDTLS_ERR_PLATFORM_FEATURE_UNSUPPORTED; cleanup: diff --git a/features/cryptocell/FEATURE_CRYPTOCELL310/sha1_alt.c b/features/cryptocell/FEATURE_CRYPTOCELL310/sha1_alt.c index 10818ed18f..c721fb7b9f 100644 --- a/features/cryptocell/FEATURE_CRYPTOCELL310/sha1_alt.c +++ b/features/cryptocell/FEATURE_CRYPTOCELL310/sha1_alt.c @@ -47,7 +47,7 @@ void mbedtls_sha1_clone( mbedtls_sha1_context *dst, int mbedtls_sha1_starts_ret( mbedtls_sha1_context *ctx ) { if( CRYS_HASH_Init( &ctx->crys_hash_ctx, CRYS_HASH_SHA1_mode ) != CRYS_OK ) - return ( MBEDTLS_ERR_SHA1_HW_ACCEL_FAILED ); + return ( MBEDTLS_ERR_PLATFORM_HW_ACCEL_FAILED ); return ( 0 ); } @@ -57,7 +57,7 @@ int mbedtls_sha1_update_ret( mbedtls_sha1_context *ctx, size_t ilen ) { if( CRYS_HASH_Update( &ctx->crys_hash_ctx, (uint8_t*)input, ilen ) != CRYS_OK ) - return ( MBEDTLS_ERR_SHA1_HW_ACCEL_FAILED ); + return ( MBEDTLS_ERR_PLATFORM_HW_ACCEL_FAILED ); return ( 0 ); } @@ -73,14 +73,14 @@ int mbedtls_sha1_finish_ret( mbedtls_sha1_context *ctx, return ( 0 ); } else - return ( MBEDTLS_ERR_SHA1_HW_ACCEL_FAILED ); + return ( MBEDTLS_ERR_PLATFORM_HW_ACCEL_FAILED ); } int mbedtls_internal_sha1_process( mbedtls_sha1_context *ctx, const unsigned char data[64] ) { if( CRYS_HASH_Update( &ctx->crys_hash_ctx, (uint8_t*)data, 64 ) != CRYS_OK ) - return ( MBEDTLS_ERR_SHA1_HW_ACCEL_FAILED ); + return ( MBEDTLS_ERR_PLATFORM_HW_ACCEL_FAILED ); return ( 0 ); } #endif //MBEDTLS_SHA1_ALT diff --git a/features/cryptocell/FEATURE_CRYPTOCELL310/sha256_alt.c b/features/cryptocell/FEATURE_CRYPTOCELL310/sha256_alt.c index f7912996a6..b2a7942512 100644 --- a/features/cryptocell/FEATURE_CRYPTOCELL310/sha256_alt.c +++ b/features/cryptocell/FEATURE_CRYPTOCELL310/sha256_alt.c @@ -47,7 +47,7 @@ int mbedtls_sha256_starts_ret( mbedtls_sha256_context *ctx, int is224 ) { if(CRYS_HASH_Init( &ctx->crys_hash_ctx, is224 ? CRYS_HASH_SHA224_mode : CRYS_HASH_SHA256_mode ) != CRYS_OK ) - return ( MBEDTLS_ERR_SHA256_HW_ACCEL_FAILED ); + return ( MBEDTLS_ERR_PLATFORM_HW_ACCEL_FAILED ); return ( 0 ); } @@ -55,7 +55,7 @@ int mbedtls_internal_sha256_process( mbedtls_sha256_context *ctx, const unsigned char data[64] ) { if( CRYS_HASH_Update( &ctx->crys_hash_ctx, (uint8_t*)data, 64 ) != CRYS_OK ) - return ( MBEDTLS_ERR_SHA256_HW_ACCEL_FAILED ); + return ( MBEDTLS_ERR_PLATFORM_HW_ACCEL_FAILED ); return ( 0 ); } @@ -64,7 +64,7 @@ int mbedtls_sha256_update_ret( mbedtls_sha256_context *ctx, size_t ilen ) { if( CRYS_HASH_Update( &ctx->crys_hash_ctx, (uint8_t*)input, ilen ) != CRYS_OK ) - return ( MBEDTLS_ERR_SHA256_HW_ACCEL_FAILED ); + return ( MBEDTLS_ERR_PLATFORM_HW_ACCEL_FAILED ); return ( 0 ); } @@ -80,7 +80,7 @@ int mbedtls_sha256_finish_ret( mbedtls_sha256_context *ctx, return ( 0 ); } else - return ( MBEDTLS_ERR_SHA256_HW_ACCEL_FAILED ); + return ( MBEDTLS_ERR_PLATFORM_HW_ACCEL_FAILED ); } #endif //MBEDTLS_SHA256_ALT diff --git a/features/mbedtls/targets/TARGET_NUVOTON/TARGET_M480/ecp/ecp_internal_alt.c b/features/mbedtls/targets/TARGET_NUVOTON/TARGET_M480/ecp/ecp_internal_alt.c index f61453a78b..be73b1f1d8 100644 --- a/features/mbedtls/targets/TARGET_NUVOTON/TARGET_M480/ecp/ecp_internal_alt.c +++ b/features/mbedtls/targets/TARGET_NUVOTON/TARGET_M480/ecp/ecp_internal_alt.c @@ -484,7 +484,7 @@ NU_STATIC int internal_run_eccop(const mbedtls_ecp_group *grp, /* Check supported maximum key bits */ if (grp->pbits > NU_ECC_MAXKEYBITS) { - return MBEDTLS_ERR_ECP_FEATURE_UNAVAILABLE; + return MBEDTLS_ERR_PLATFORM_FEATURE_UNSUPPORTED; } int ret; @@ -675,7 +675,7 @@ NU_STATIC int internal_run_modop(mbedtls_mpi *r, /* Check supported maximum key bits */ if (pbits > NU_ECC_MAXKEYBITS) { - return MBEDTLS_ERR_ECP_FEATURE_UNAVAILABLE; + return MBEDTLS_ERR_PLATFORM_FEATURE_UNSUPPORTED; } /* Check MODOP operations are legal */ diff --git a/features/mbedtls/targets/TARGET_STM/aes_alt.c b/features/mbedtls/targets/TARGET_STM/aes_alt.c index 414fb2efee..dae8721634 100644 --- a/features/mbedtls/targets/TARGET_STM/aes_alt.c +++ b/features/mbedtls/targets/TARGET_STM/aes_alt.c @@ -24,6 +24,7 @@ #if defined(MBEDTLS_AES_ALT) #if defined(TARGET_STM32L486xG) || defined (TARGET_STM32L443xC) +#include "mbedtls/platform.h" //the following defines are provided to maintain compatibility between STM32 families #define __HAL_RCC_CRYP_CLK_ENABLE __HAL_RCC_AES_CLK_ENABLE #define __HAL_RCC_CRYP_FORCE_RESET __HAL_RCC_AES_FORCE_RESET @@ -40,7 +41,7 @@ static int aes_set_key(mbedtls_aes_context *ctx, const unsigned char *key, unsig break; case 192: #if defined (TARGET_STM32L486xG) || defined (TARGET_STM32L443xC) - return (MBEDTLS_ERR_AES_INVALID_KEY_LENGTH); + return (MBEDTLS_ERR_PLATFORM_FEATURE_UNSUPPORTED); #else ctx->hcryp_aes.Init.KeySize = CRYP_KEYSIZE_192B; memcpy(ctx->aes_key, key, 24); diff --git a/features/mbedtls/targets/TARGET_STM/md5_alt.c b/features/mbedtls/targets/TARGET_STM/md5_alt.c index 1498ce70f6..49d9087999 100644 --- a/features/mbedtls/targets/TARGET_STM/md5_alt.c +++ b/features/mbedtls/targets/TARGET_STM/md5_alt.c @@ -99,7 +99,7 @@ int mbedtls_md5_starts_ret(mbedtls_md5_context *ctx) { /* HASH IP initialization */ if (HAL_HASH_DeInit(&ctx->hhash_md5) != 0) { - return MBEDTLS_ERR_MD5_HW_ACCEL_FAILED; + return MBEDTLS_ERR_PLATFORM_HW_ACCEL_FAILED; } /* HASH Configuration */ @@ -107,11 +107,11 @@ int mbedtls_md5_starts_ret(mbedtls_md5_context *ctx) /* clear CR ALGO value */ HASH->CR &= ~HASH_CR_ALGO_Msk; if (HAL_HASH_Init(&ctx->hhash_md5) != 0) { - return MBEDTLS_ERR_MD5_HW_ACCEL_FAILED; + return MBEDTLS_ERR_PLATFORM_HW_ACCEL_FAILED; } if (st_md5_save_hw_context(ctx) != 1) { // Return HASH_BUSY timeout error here - return MBEDTLS_ERR_MD5_HW_ACCEL_FAILED; + return MBEDTLS_ERR_PLATFORM_HW_ACCEL_FAILED; } return 0; @@ -121,14 +121,14 @@ int mbedtls_internal_md5_process(mbedtls_md5_context *ctx, const unsigned char d { if (st_md5_restore_hw_context(ctx) != 1) { // Return HASH_BUSY timeout error here - return MBEDTLS_ERR_MD5_HW_ACCEL_FAILED; + return MBEDTLS_ERR_PLATFORM_HW_ACCEL_FAILED; } if (HAL_HASH_MD5_Accumulate(&ctx->hhash_md5, (uint8_t *)data, ST_MD5_BLOCK_SIZE) != 0) { - return MBEDTLS_ERR_MD5_HW_ACCEL_FAILED; + return MBEDTLS_ERR_PLATFORM_HW_ACCEL_FAILED; } if (st_md5_save_hw_context(ctx) != 1) { // Return HASH_BUSY timeout error here - return MBEDTLS_ERR_MD5_HW_ACCEL_FAILED; + return MBEDTLS_ERR_PLATFORM_HW_ACCEL_FAILED; } return 0; } @@ -141,7 +141,7 @@ int mbedtls_md5_update_ret(mbedtls_md5_context *ctx, const unsigned char *input, if (currentlen != 0) { if (st_md5_restore_hw_context(ctx) != 1) { // Return HASH_BUSY timeout error here - return MBEDTLS_ERR_MD5_HW_ACCEL_FAILED; + return MBEDTLS_ERR_PLATFORM_HW_ACCEL_FAILED; } // store mechanism to accumulate ST_MD5_BLOCK_SIZE bytes (512 bits) in the HW @@ -161,7 +161,7 @@ int mbedtls_md5_update_ret(mbedtls_md5_context *ctx, const unsigned char *input, size_t iter = currentlen / ST_MD5_BLOCK_SIZE; if (iter != 0) { if (HAL_HASH_MD5_Accumulate(&ctx->hhash_md5, (uint8_t *)(input + ST_MD5_BLOCK_SIZE - ctx->sbuf_len), (iter * ST_MD5_BLOCK_SIZE)) != 0) { - return MBEDTLS_ERR_MD5_HW_ACCEL_FAILED; + return MBEDTLS_ERR_PLATFORM_HW_ACCEL_FAILED; } } // sbuf is completely accumulated, now copy up to 63 remaining bytes @@ -173,7 +173,7 @@ int mbedtls_md5_update_ret(mbedtls_md5_context *ctx, const unsigned char *input, if (st_md5_save_hw_context(ctx) != 1) { // Return HASH_BUSY timeout error here - return MBEDTLS_ERR_MD5_HW_ACCEL_FAILED; + return MBEDTLS_ERR_PLATFORM_HW_ACCEL_FAILED; } } return 0; @@ -183,12 +183,12 @@ int mbedtls_md5_finish_ret(mbedtls_md5_context *ctx, unsigned char output[16]) { if (st_md5_restore_hw_context(ctx) != 1) { // Return HASH_BUSY timeout error here - return MBEDTLS_ERR_MD5_HW_ACCEL_FAILED; + return MBEDTLS_ERR_PLATFORM_HW_ACCEL_FAILED; } /* Last accumulation for extra bytes in sbuf_len */ /* This sets HW flags in case mbedtls_md5_update has not been called yet */ if (HAL_HASH_MD5_Accumulate(&ctx->hhash_md5, ctx->sbuf, ctx->sbuf_len) != 0) { - return MBEDTLS_ERR_MD5_HW_ACCEL_FAILED; + return MBEDTLS_ERR_PLATFORM_HW_ACCEL_FAILED; } mbedtls_zeroize(ctx->sbuf, ST_MD5_BLOCK_SIZE); @@ -196,11 +196,11 @@ int mbedtls_md5_finish_ret(mbedtls_md5_context *ctx, unsigned char output[16]) __HAL_HASH_START_DIGEST(); if (HAL_HASH_MD5_Finish(&ctx->hhash_md5, output, 10)) { - return MBEDTLS_ERR_MD5_HW_ACCEL_FAILED; + return MBEDTLS_ERR_PLATFORM_HW_ACCEL_FAILED; } if (st_md5_save_hw_context(ctx) != 1) { // Return HASH_BUSY timeout error here - return MBEDTLS_ERR_MD5_HW_ACCEL_FAILED; + return MBEDTLS_ERR_PLATFORM_HW_ACCEL_FAILED; } return 0; } diff --git a/features/mbedtls/targets/TARGET_STM/sha1_alt.c b/features/mbedtls/targets/TARGET_STM/sha1_alt.c index 00fd001c35..3e5368112c 100644 --- a/features/mbedtls/targets/TARGET_STM/sha1_alt.c +++ b/features/mbedtls/targets/TARGET_STM/sha1_alt.c @@ -97,7 +97,7 @@ int mbedtls_sha1_starts_ret(mbedtls_sha1_context *ctx) { /* Deinitializes the HASH peripheral */ if (HAL_HASH_DeInit(&ctx->hhash_sha1) == HAL_ERROR) { - return MBEDTLS_ERR_SHA1_HW_ACCEL_FAILED; + return MBEDTLS_ERR_PLATFORM_HW_ACCEL_FAILED; } /* HASH Configuration */ @@ -105,11 +105,11 @@ int mbedtls_sha1_starts_ret(mbedtls_sha1_context *ctx) /* clear CR ALGO value */ HASH->CR &= ~HASH_CR_ALGO_Msk; if (HAL_HASH_Init(&ctx->hhash_sha1) == HAL_ERROR) { - return MBEDTLS_ERR_SHA1_HW_ACCEL_FAILED; + return MBEDTLS_ERR_PLATFORM_HW_ACCEL_FAILED; } if (st_sha1_save_hw_context(ctx) != 1) { // return HASH_BUSY timeout Error here - return MBEDTLS_ERR_SHA1_HW_ACCEL_FAILED; + return MBEDTLS_ERR_PLATFORM_HW_ACCEL_FAILED; } return 0; } @@ -118,15 +118,15 @@ int mbedtls_internal_sha1_process(mbedtls_sha1_context *ctx, const unsigned char { if (st_sha1_restore_hw_context(ctx) != 1) { // return HASH_BUSY timeout Error here - return MBEDTLS_ERR_SHA1_HW_ACCEL_FAILED; + return MBEDTLS_ERR_PLATFORM_HW_ACCEL_FAILED; } if (HAL_HASH_SHA1_Accumulate(&ctx->hhash_sha1, (uint8_t *) data, ST_SHA1_BLOCK_SIZE) != 0) { - return MBEDTLS_ERR_SHA1_HW_ACCEL_FAILED; + return MBEDTLS_ERR_PLATFORM_HW_ACCEL_FAILED; } if (st_sha1_save_hw_context(ctx) != 1) { // return HASH_BUSY timeout Error here - return MBEDTLS_ERR_SHA1_HW_ACCEL_FAILED; + return MBEDTLS_ERR_PLATFORM_HW_ACCEL_FAILED; } return 0; } @@ -137,7 +137,7 @@ int mbedtls_sha1_update_ret(mbedtls_sha1_context *ctx, const unsigned char *inpu size_t currentlen = ilen; if (st_sha1_restore_hw_context(ctx) != 1) { // return HASH_BUSY timeout Error here - return MBEDTLS_ERR_SHA1_HW_ACCEL_FAILED; + return MBEDTLS_ERR_PLATFORM_HW_ACCEL_FAILED; } // store mechanism to accumulate ST_SHA1_BLOCK_SIZE bytes (512 bits) in the HW @@ -163,7 +163,7 @@ int mbedtls_sha1_update_ret(mbedtls_sha1_context *ctx, const unsigned char *inpu // Process every input as long as it is %64 bytes, ie 512 bits size_t iter = currentlen / ST_SHA1_BLOCK_SIZE; if (HAL_HASH_SHA1_Accumulate(&ctx->hhash_sha1, (uint8_t *)(input + ST_SHA1_BLOCK_SIZE - ctx->sbuf_len), (iter * ST_SHA1_BLOCK_SIZE)) != 0) { - return MBEDTLS_ERR_SHA1_HW_ACCEL_FAILED; + return MBEDTLS_ERR_PLATFORM_HW_ACCEL_FAILED; } // sbuf is completely accumulated, now copy up to 63 remaining bytes ctx->sbuf_len = currentlen % ST_SHA1_BLOCK_SIZE; @@ -173,7 +173,7 @@ int mbedtls_sha1_update_ret(mbedtls_sha1_context *ctx, const unsigned char *inpu } if (st_sha1_save_hw_context(ctx) != 1) { // return HASH_BUSY timeout Error here - return MBEDTLS_ERR_SHA1_HW_ACCEL_FAILED; + return MBEDTLS_ERR_PLATFORM_HW_ACCEL_FAILED; } return 0; } @@ -182,24 +182,24 @@ int mbedtls_sha1_finish_ret(mbedtls_sha1_context *ctx, unsigned char output[20]) { if (st_sha1_restore_hw_context(ctx) != 1) { // return HASH_BUSY timeout Error here - return MBEDTLS_ERR_SHA1_HW_ACCEL_FAILED; + return MBEDTLS_ERR_PLATFORM_HW_ACCEL_FAILED; } /* Last accumulation for extra bytes in sbuf_len */ /* This allows the HW flags to be in place in case mbedtls_sha256_update has not been called yet */ if (HAL_HASH_SHA1_Accumulate(&ctx->hhash_sha1, ctx->sbuf, ctx->sbuf_len) != 0) { - return MBEDTLS_ERR_SHA1_HW_ACCEL_FAILED; + return MBEDTLS_ERR_PLATFORM_HW_ACCEL_FAILED; } mbedtls_zeroize(ctx->sbuf, ST_SHA1_BLOCK_SIZE); ctx->sbuf_len = 0; __HAL_HASH_START_DIGEST(); if (HAL_HASH_SHA1_Finish(&ctx->hhash_sha1, output, 10) != 0) { - return MBEDTLS_ERR_SHA1_HW_ACCEL_FAILED; + return MBEDTLS_ERR_PLATFORM_HW_ACCEL_FAILED; } if (st_sha1_save_hw_context(ctx) != 1) { // return HASH_BUSY timeout Error here - return MBEDTLS_ERR_SHA1_HW_ACCEL_FAILED; + return MBEDTLS_ERR_PLATFORM_HW_ACCEL_FAILED; } return 0; } diff --git a/features/mbedtls/targets/TARGET_STM/sha256_alt.c b/features/mbedtls/targets/TARGET_STM/sha256_alt.c index 7f37aa7a94..6915ffa917 100644 --- a/features/mbedtls/targets/TARGET_STM/sha256_alt.c +++ b/features/mbedtls/targets/TARGET_STM/sha256_alt.c @@ -97,7 +97,7 @@ int mbedtls_sha256_starts_ret(mbedtls_sha256_context *ctx, int is224) { /* HASH IP initialization */ if (HAL_HASH_DeInit(&ctx->hhash_sha256) == HAL_ERROR) { - return MBEDTLS_ERR_SHA256_HW_ACCEL_FAILED; + return MBEDTLS_ERR_PLATFORM_HW_ACCEL_FAILED; } ctx->is224 = is224; @@ -107,11 +107,11 @@ int mbedtls_sha256_starts_ret(mbedtls_sha256_context *ctx, int is224) HASH->CR &= ~HASH_CR_ALGO_Msk; if (HAL_HASH_Init(&ctx->hhash_sha256) == HAL_ERROR) { // error found to be returned - return MBEDTLS_ERR_SHA256_HW_ACCEL_FAILED; + return MBEDTLS_ERR_PLATFORM_HW_ACCEL_FAILED; } if (st_sha256_save_hw_context(ctx) != 1) { // return HASH_BUSY timeout Error here - return MBEDTLS_ERR_SHA256_HW_ACCEL_FAILED; + return MBEDTLS_ERR_PLATFORM_HW_ACCEL_FAILED; } return 0; } @@ -120,21 +120,21 @@ int mbedtls_internal_sha256_process(mbedtls_sha256_context *ctx, const unsigned { if (st_sha256_restore_hw_context(ctx) != 1) { // Return HASH_BUSY timeout error here - return MBEDTLS_ERR_SHA256_HW_ACCEL_FAILED; + return MBEDTLS_ERR_PLATFORM_HW_ACCEL_FAILED; } if (ctx->is224 == 0) { if (HAL_HASHEx_SHA256_Accumulate(&ctx->hhash_sha256, (uint8_t *) data, ST_SHA256_BLOCK_SIZE) != 0) { - return MBEDTLS_ERR_SHA256_HW_ACCEL_FAILED; + return MBEDTLS_ERR_PLATFORM_HW_ACCEL_FAILED; } } else { if (HAL_HASHEx_SHA224_Accumulate(&ctx->hhash_sha256, (uint8_t *) data, ST_SHA256_BLOCK_SIZE) != 0) { - return MBEDTLS_ERR_SHA256_HW_ACCEL_FAILED; + return MBEDTLS_ERR_PLATFORM_HW_ACCEL_FAILED; } } if (st_sha256_save_hw_context(ctx) != 1) { // Return HASH_BUSY timeout error here - return MBEDTLS_ERR_SHA256_HW_ACCEL_FAILED; + return MBEDTLS_ERR_PLATFORM_HW_ACCEL_FAILED; } return 0; } @@ -145,7 +145,7 @@ int mbedtls_sha256_update_ret(mbedtls_sha256_context *ctx, const unsigned char * size_t currentlen = ilen; if (st_sha256_restore_hw_context(ctx) != 1) { // Return HASH_BUSY timeout error here - return MBEDTLS_ERR_SHA256_HW_ACCEL_FAILED; + return MBEDTLS_ERR_PLATFORM_HW_ACCEL_FAILED; } // store mechanism to accumulate ST_SHA256_BLOCK_SIZE bytes (512 bits) in the HW @@ -177,11 +177,11 @@ int mbedtls_sha256_update_ret(mbedtls_sha256_context *ctx, const unsigned char * if (iter != 0) { if (ctx->is224 == 0) { if (HAL_HASHEx_SHA256_Accumulate(&ctx->hhash_sha256, (uint8_t *)(input + ST_SHA256_BLOCK_SIZE - ctx->sbuf_len), (iter * ST_SHA256_BLOCK_SIZE)) != 0) { - return MBEDTLS_ERR_SHA256_HW_ACCEL_FAILED; + return MBEDTLS_ERR_PLATFORM_HW_ACCEL_FAILED; } } else { if (HAL_HASHEx_SHA224_Accumulate(&ctx->hhash_sha256, (uint8_t *)(input + ST_SHA256_BLOCK_SIZE - ctx->sbuf_len), (iter * ST_SHA256_BLOCK_SIZE)) != 0) { - return MBEDTLS_ERR_SHA256_HW_ACCEL_FAILED; + return MBEDTLS_ERR_PLATFORM_HW_ACCEL_FAILED; } } } @@ -193,7 +193,7 @@ int mbedtls_sha256_update_ret(mbedtls_sha256_context *ctx, const unsigned char * } if (st_sha256_save_hw_context(ctx) != 1) { // Return HASH_BUSY timeout error here - return MBEDTLS_ERR_SHA256_HW_ACCEL_FAILED; + return MBEDTLS_ERR_PLATFORM_HW_ACCEL_FAILED; } return 0; } @@ -202,17 +202,17 @@ int mbedtls_sha256_finish_ret(mbedtls_sha256_context *ctx, unsigned char output[ { if (st_sha256_restore_hw_context(ctx) != 1) { // Return HASH_BUSY timeout error here - return MBEDTLS_ERR_SHA256_HW_ACCEL_FAILED; + return MBEDTLS_ERR_PLATFORM_HW_ACCEL_FAILED; } /* Last accumulation for extra bytes in sbuf_len */ /* This allows the HW flags to be in place in case mbedtls_sha256_update has not been called yet */ if (ctx->is224 == 0) { if (HAL_HASHEx_SHA256_Accumulate(&ctx->hhash_sha256, ctx->sbuf, ctx->sbuf_len) != 0) { - return MBEDTLS_ERR_SHA256_HW_ACCEL_FAILED; + return MBEDTLS_ERR_PLATFORM_HW_ACCEL_FAILED; } } else { if (HAL_HASHEx_SHA224_Accumulate(&ctx->hhash_sha256, ctx->sbuf, ctx->sbuf_len) != 0) { - return MBEDTLS_ERR_SHA256_HW_ACCEL_FAILED; + return MBEDTLS_ERR_PLATFORM_HW_ACCEL_FAILED; } } @@ -222,16 +222,16 @@ int mbedtls_sha256_finish_ret(mbedtls_sha256_context *ctx, unsigned char output[ if (ctx->is224 == 0) { if (HAL_HASHEx_SHA256_Finish(&ctx->hhash_sha256, output, 10) != 0) { - return MBEDTLS_ERR_SHA256_HW_ACCEL_FAILED; + return MBEDTLS_ERR_PLATFORM_HW_ACCEL_FAILED; } } else { if (HAL_HASHEx_SHA224_Finish(&ctx->hhash_sha256, output, 10) != 0) { - return MBEDTLS_ERR_SHA256_HW_ACCEL_FAILED; + return MBEDTLS_ERR_PLATFORM_HW_ACCEL_FAILED; } } if (st_sha256_save_hw_context(ctx) != 1) { // Return HASH_BUSY timeout error here - return MBEDTLS_ERR_SHA256_HW_ACCEL_FAILED; + return MBEDTLS_ERR_PLATFORM_HW_ACCEL_FAILED; } return 0; } diff --git a/features/mbedtls/targets/TARGET_Silicon_Labs/aes_aes.c b/features/mbedtls/targets/TARGET_Silicon_Labs/aes_aes.c index 822c7e6f46..7b0942fe8e 100644 --- a/features/mbedtls/targets/TARGET_Silicon_Labs/aes_aes.c +++ b/features/mbedtls/targets/TARGET_Silicon_Labs/aes_aes.c @@ -28,6 +28,7 @@ #include "em_cmu.h" #include "em_bus.h" #include +#include "mbedtls/platform.h" #if defined(MBEDTLS_THREADING_C) #include "mbedtls/threading.h" @@ -98,7 +99,7 @@ int mbedtls_aes_setkey_enc( mbedtls_aes_context *ctx, if ( ( 128 != keybits ) && ( 256 != keybits ) ) { /* Unsupported key size */ - return( MBEDTLS_ERR_AES_INVALID_KEY_LENGTH ); + return( MBEDTLS_ERR_PLATFORM_FEATURE_UNSUPPORTED ); } ctx->keybits = keybits; @@ -116,7 +117,7 @@ int mbedtls_aes_setkey_dec( mbedtls_aes_context *ctx, { if ( ( 128 != keybits ) && ( 256 != keybits ) ) /* Unsupported key size */ - return( MBEDTLS_ERR_AES_INVALID_KEY_LENGTH ); + return( MBEDTLS_ERR_PLATFORM_FEATURE_UNSUPPORTED ); ctx->keybits = keybits; switch (keybits) diff --git a/features/mbedtls/targets/TARGET_Silicon_Labs/crypto_ecp.c b/features/mbedtls/targets/TARGET_Silicon_Labs/crypto_ecp.c index 48fe271e8f..953cf9c415 100644 --- a/features/mbedtls/targets/TARGET_Silicon_Labs/crypto_ecp.c +++ b/features/mbedtls/targets/TARGET_Silicon_Labs/crypto_ecp.c @@ -427,7 +427,7 @@ static int crypto_device_init( CRYPTO_TypeDef *device, const mbedtls_ecp_group * #endif /* MBEDTLS_ECP_DP_SECP256R1_ENABLED */ default: - ret = MBEDTLS_ERR_ECP_FEATURE_UNAVAILABLE; + ret = MBEDTLS_ERR_PLATFORM_FEATURE_UNSUPPORTED; break; }