Mirrors/esp-idf
1
0
Fork 0
mirror of https://github.com/espressif/esp-idf.git synced 2026-10-01 18:50:34 +03:00
Code Issues Packages Projects Releases Wiki Activity

feat(mbedtls): adds mbedtls alt drivers with PSA

Browse Source
This commit is contained in:
Ashish Sharma
2025-12-19 07:28:33 +08:00
parent 1d33cc26bd
commit c47caf4f0a
39 changed files with 1031 additions and 374 deletions
Download Patch File Download Diff File Expand all files Collapse all files
components/esp-tls/esp-tls-crypto/esp_tls_crypto.c
+9 -13
View File
@@ -12,9 +12,9 @@ __attribute__((unused)) static const char *TAG = "esp_crypto";
#ifdef CONFIG_ESP_TLS_USING_MBEDTLS
/* Need this for mbedtls_sha1_* APIs */
#define MBEDTLS_DECLARE_PRIVATE_IDENTIFIERS
#include "mbedtls/sha1.h"
#include "mbedtls/base64.h"
#include "mbedtls/error.h"
#include "psa/crypto.h"
#define _esp_crypto_sha1 esp_crypto_sha1_mbedtls
#define _esp_crypto_base64_encode esp_crypto_bas64_encode_mbedtls
#elif CONFIG_ESP_TLS_USING_WOLFSSL
@@ -30,29 +30,25 @@ static int esp_crypto_sha1_mbedtls( const unsigned char *input,
unsigned char output[20])
{
#if CONFIG_MBEDTLS_SHA1_C || CONFIG_MBEDTLS_HARDWARE_SHA
int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
mbedtls_sha1_context ctx;
psa_hash_operation_t ctx = PSA_HASH_OPERATION_INIT;
mbedtls_sha1_init(&ctx);
if ((ret = mbedtls_sha1_starts(&ctx)) != 0) {
psa_status_t status = psa_hash_setup(&ctx, PSA_ALG_SHA_1);
if (status != PSA_SUCCESS) {
goto exit;
}
if ((ret = mbedtls_sha1_update(&ctx, input, ilen)) != 0) {
if ((status = psa_hash_update(&ctx, input, ilen)) != PSA_SUCCESS) {
goto exit;
}
if ((ret = mbedtls_sha1_finish(&ctx, output)) != 0) {
size_t hash_len;
if ((status = psa_hash_finish(&ctx, output, 20, &hash_len)) != PSA_SUCCESS) {
goto exit;
}
exit:
mbedtls_sha1_free(&ctx);
if (ret != 0) {
ESP_LOGE(TAG, "Error in calculating sha1 sum , Returned 0x%02X", ret);
}
return ret;
psa_hash_abort(&ctx);
return status == PSA_SUCCESS ? 0 : -1;
#else
ESP_LOGE(TAG, "Please enable CONFIG_MBEDTLS_SHA1_C or CONFIG_MBEDTLS_HARDWARE_SHA to support SHA1 operations");
return MBEDTLS_ERR_PLATFORM_FEATURE_UNSUPPORTED;
components/hal/test_apps/crypto/main/aes/test_aes.c
+1 -2
View File
@@ -426,11 +426,10 @@ TEST_GROUP_RUNNER(aes)
#endif /* CONFIG_CRYPTO_TESTAPP_USE_AES_INTERRUPT */
#if CONFIG_SOC_AES_SUPPORT_GCM
RUN_TEST_CASE(aes, gcm_aes_dma_test);
#endif /* CONFIG_SOC_AES_SUPPORT_GCM */
#if CONFIG_CRYPTO_TESTAPP_USE_AES_INTERRUPT
RUN_TEST_CASE(aes, gcm_aes_long_dma_test);
#endif /* CONFIG_CRYPTO_TESTAPP_USE_AES_INTERRUPT */
#endif /* SOC_GCM_SUPPORTED */
#endif /* CONFIG_SOC_AES_SUPPORT_GCM */
#endif /* SOC_AES_SUPPORT_DMA */
}
components/mbedtls/CMakeLists.txt
+47 -44
View File
@@ -192,7 +192,7 @@ foreach(target ${mbedtls_targets})
endif()
if(CONFIG_MBEDTLS_COMPILER_OPTIMIZATION_SIZE)
target_compile_options(${target} PRIVATE "-Os")
elseif(CONFIG_MBEDTLS_COMPILER_OPTIMIZATION_SPEED)
elseif(CONFIG_MBEDTLS_COMPILER_OPTIMIZATION_PERF)
target_compile_options(${target} PRIVATE "-O2")
endif()
endforeach()
@@ -366,58 +366,61 @@ endif()
if(CONFIG_MBEDTLS_HARDWARE_GCM OR CONFIG_MBEDTLS_HARDWARE_AES)
target_compile_definitions(tfpsacrypto PRIVATE ESP_AES_DRIVER_ENABLED)
target_include_directories(tfpsacrypto PRIVATE "${COMPONENT_DIR}/port/include/aes")
target_sources(tfpsacrypto PRIVATE
"${COMPONENT_DIR}/port/psa_driver/esp_aes/psa_crypto_driver_esp_aes.c"
"${COMPONENT_DIR}/port/psa_driver/esp_aes/psa_crypto_driver_esp_cmac.c"
)
if(CONFIG_MBEDTLS_HARDWARE_SHA)
target_sources(tfpsacrypto PRIVATE
"${COMPONENT_DIR}/port/psa_driver/esp_aes/psa_crypto_driver_esp_aes.c"
"${COMPONENT_DIR}/port/psa_driver/esp_aes/psa_crypto_driver_esp_cmac.c"
)
endif()
if(CONFIG_SOC_AES_SUPPORT_GCM)
target_sources(tfpsacrypto PRIVATE "$ENV{IDF_PATH}/components/mbedtls/port/aes/esp_aes_gcm.c"
"${COMPONENT_DIR}/port/psa_driver/esp_aes/psa_crypto_driver_esp_aes_gcm.c")
endif()
endif()
# if(CONFIG_MBEDTLS_HARDWARE_ECC)
# target_sources(mbedcrypto PRIVATE "${COMPONENT_DIR}/port/ecc/esp_ecc.c"
# "${COMPONENT_DIR}/port/ecc/ecc_alt.c")
# endif()
if(CONFIG_MBEDTLS_HARDWARE_ECC)
target_sources(builtin PRIVATE "${COMPONENT_DIR}/port/ecc/esp_ecc.c"
"${COMPONENT_DIR}/port/ecc/ecc_alt.c")
include_directories("${COMPONENT_DIR}/tf-psa-crypto/drivers/builtin/include/mbedtls")
endif()
# if(CONFIG_MBEDTLS_HARDWARE_ECDSA_SIGN OR
# CONFIG_MBEDTLS_HARDWARE_ECDSA_VERIFY OR CONFIG_MBEDTLS_TEE_SEC_STG_ECDSA_SIGN)
# target_sources(mbedcrypto PRIVATE "${COMPONENT_DIR}/port/ecdsa/ecdsa_alt.c")
if(CONFIG_MBEDTLS_HARDWARE_ECDSA_SIGN OR
CONFIG_MBEDTLS_HARDWARE_ECDSA_VERIFY OR CONFIG_MBEDTLS_TEE_SEC_STG_ECDSA_SIGN)
target_sources(builtin PRIVATE "${COMPONENT_DIR}/port/ecdsa/ecdsa_alt.c")
# set(WRAP_FUNCTIONS_SIGN
# mbedtls_ecdsa_sign
# mbedtls_ecdsa_sign_restartable
# mbedtls_ecdsa_write_signature
# mbedtls_ecdsa_write_signature_restartable)
set(WRAP_FUNCTIONS_SIGN
mbedtls_ecdsa_sign
mbedtls_ecdsa_sign_restartable
mbedtls_ecdsa_write_signature
mbedtls_ecdsa_write_signature_restartable)
# set(WRAP_FUNCTIONS_VERIFY
# mbedtls_ecdsa_verify
# mbedtls_ecdsa_verify_restartable
# mbedtls_ecdsa_read_signature
# mbedtls_ecdsa_read_signature_restartable)
set(WRAP_FUNCTIONS_VERIFY
mbedtls_ecdsa_verify
mbedtls_ecdsa_verify_restartable
mbedtls_ecdsa_read_signature
mbedtls_ecdsa_read_signature_restartable)
# if(CONFIG_MBEDTLS_HARDWARE_ECDSA_SIGN OR CONFIG_MBEDTLS_TEE_SEC_STG_ECDSA_SIGN)
# foreach(wrap ${WRAP_FUNCTIONS_SIGN})
# target_link_libraries(${COMPONENT_LIB} INTERFACE "-Wl,--wrap=${wrap}")
# endforeach()
if(CONFIG_MBEDTLS_HARDWARE_ECDSA_SIGN OR CONFIG_MBEDTLS_TEE_SEC_STG_ECDSA_SIGN)
foreach(wrap ${WRAP_FUNCTIONS_SIGN})
target_link_libraries(${COMPONENT_LIB} INTERFACE "-Wl,--wrap=${wrap}")
endforeach()
# if(CONFIG_SOC_ECDSA_SUPPORT_DETERMINISTIC_MODE)
# target_link_libraries(${COMPONENT_LIB} INTERFACE "-Wl,--wrap=mbedtls_ecdsa_sign_det_ext")
# target_link_libraries(${COMPONENT_LIB} INTERFACE "-Wl,--wrap=mbedtls_ecdsa_sign_det_restartable")
# endif()
# endif()
if(CONFIG_SOC_ECDSA_SUPPORT_DETERMINISTIC_MODE)
target_link_libraries(${COMPONENT_LIB} INTERFACE "-Wl,--wrap=mbedtls_ecdsa_sign_det_ext")
target_link_libraries(${COMPONENT_LIB} INTERFACE "-Wl,--wrap=mbedtls_ecdsa_sign_det_restartable")
endif()
endif()
# if(CONFIG_MBEDTLS_HARDWARE_ECDSA_VERIFY)
# foreach(wrap ${WRAP_FUNCTIONS_VERIFY})
# target_link_libraries(${COMPONENT_LIB} INTERFACE "-Wl,--wrap=${wrap}")
# endforeach()
# endif()
if(CONFIG_MBEDTLS_HARDWARE_ECDSA_VERIFY)
foreach(wrap ${WRAP_FUNCTIONS_VERIFY})
target_link_libraries(${COMPONENT_LIB} INTERFACE "-Wl,--wrap=${wrap}")
endforeach()
endif()
# if(CONFIG_MBEDTLS_TEE_SEC_STG_ECDSA_SIGN)
# target_link_libraries(mbedcrypto PRIVATE idf::tee_sec_storage)
# endif()
# endif()
if(CONFIG_MBEDTLS_TEE_SEC_STG_ECDSA_SIGN)
target_link_libraries(builtin PRIVATE idf::tee_sec_storage)
endif()
endif()
# if(CONFIG_MBEDTLS_ROM_MD5)
# target_sources(mbedcrypto PRIVATE "${COMPONENT_DIR}/port/md/esp_md.c")
@@ -444,7 +447,7 @@ endif()
if(CONFIG_MBEDTLS_COMPILER_OPTIMIZATION_SIZE)
message(STATUS "Linkage type is ${linkage_type}")
target_compile_options(${COMPONENT_LIB} ${compiler_linkage_type} "-Os")
elseif(CONFIG_MBEDTLS_COMPILER_OPTIMIZATION_SPEED)
elseif(CONFIG_MBEDTLS_COMPILER_OPTIMIZATION_PERF)
target_compile_options(${COMPONENT_LIB} ${compiler_linkage_type} "-O2")
endif()
@@ -472,9 +475,9 @@ if(CONFIG_PM_ENABLE)
target_link_libraries(tfpsacrypto PRIVATE idf::esp_pm)
endif()
# if(CONFIG_MBEDTLS_HARDWARE_ECDSA_SIGN OR CONFIG_MBEDTLS_HARDWARE_ECDSA_VERIFY)
# target_link_libraries(mbedcrypto PRIVATE idf::efuse)
# endif()
if(CONFIG_MBEDTLS_HARDWARE_ECDSA_SIGN OR CONFIG_MBEDTLS_HARDWARE_ECDSA_VERIFY)
target_link_libraries(builtin PRIVATE idf::efuse)
endif()
target_link_libraries(${COMPONENT_LIB} ${linkage_type} ${mbedtls_targets})
components/mbedtls/Kconfig
+3 -3
View File
@@ -1487,7 +1487,7 @@ menu "mbedTLS"
config MBEDTLS_HARDWARE_SHA
bool "Enable hardware SHA acceleration"
default n
default y
depends on !SPIRAM_CACHE_WORKAROUND_STRATEGY_DUPLDST && SOC_SHA_SUPPORTED
help
Enable hardware accelerated SHA1, SHA256, SHA384 & SHA512 in mbedTLS.
@@ -1503,7 +1503,7 @@ menu "mbedTLS"
config MBEDTLS_HARDWARE_MPI
bool "Enable hardware MPI (bignum) acceleration"
default n
default y
depends on !SPIRAM_CACHE_WORKAROUND_STRATEGY_DUPLDST && SOC_MPI_SUPPORTED && MBEDTLS_BIGNUM_C
help
Enable hardware accelerated multiple precision integer operations.
@@ -1547,7 +1547,7 @@ menu "mbedTLS"
config MBEDTLS_HARDWARE_AES
bool "Enable hardware AES acceleration"
default n
default y
depends on !SPIRAM_CACHE_WORKAROUND_STRATEGY_DUPLDST && SOC_AES_SUPPORTED
help
Enable hardware accelerated AES encryption & decryption.
components/mbedtls/esp_crt_bundle/esp_crt_bundle.c
+1 -1
View File
@@ -66,7 +66,7 @@ extern const uint8_t x509_crt_imported_bundle_bin_end[] asm("_binary_x509_crt_
typedef const uint8_t* bundle_t;
typedef const uint8_t* cert_t;
static bundle_t s_crt_bundle;
static bundle_t s_crt_bundle = NULL;
// Read a 16-bit value stored in little-endian format from the given address
static uint16_t get16_le(const uint8_t* ptr)
components/mbedtls/port/aes/esp_aes_gcm.c
+9 -9
View File
@@ -6,7 +6,7 @@
*
* SPDX-License-Identifier: Apache-2.0
*
* SPDX-FileContributor: 2016-2024 Espressif Systems (Shanghai) CO LTD
* SPDX-FileContributor: 2016-2025 Espressif Systems (Shanghai) CO LTD
*/
/*
* The AES block cipher was designed by Vincent Rijmen and Joan Daemen.
@@ -260,7 +260,7 @@ int esp_aes_gcm_setkey( esp_gcm_context *ctx,
* cipher is selected, as we support hardware acceleration only for a
* GCM operation using AES cipher.
*/
#if defined(MBEDTLS_GCM_NON_AES_CIPHER_SOFT_FALLBACK)
#if defined(MBEDTLS_GCM_NON_AES_CIPHER_SOFT_FALLBACK) && 0
if (ctx->ctx_soft != NULL) {
mbedtls_gcm_free_soft(ctx->ctx_soft);
free(ctx->ctx_soft);
@@ -358,7 +358,7 @@ void esp_aes_gcm_free( esp_gcm_context *ctx)
if (ctx == NULL) {
return;
}
#if defined(MBEDTLS_GCM_NON_AES_CIPHER_SOFT_FALLBACK)
#if defined(MBEDTLS_GCM_NON_AES_CIPHER_SOFT_FALLBACK) && 0
if (ctx->ctx_soft != NULL) {
mbedtls_gcm_free_soft(ctx->ctx_soft);
free(ctx->ctx_soft);
@@ -380,7 +380,7 @@ int esp_aes_gcm_starts( esp_gcm_context *ctx,
return MBEDTLS_ERR_GCM_BAD_INPUT;
}
#if defined(MBEDTLS_GCM_NON_AES_CIPHER_SOFT_FALLBACK)
#if defined(MBEDTLS_GCM_NON_AES_CIPHER_SOFT_FALLBACK) && 0
if (ctx->ctx_soft != NULL) {
return mbedtls_gcm_starts_soft(ctx->ctx_soft, mode, iv, iv_len);
}
@@ -452,7 +452,7 @@ int esp_aes_gcm_update_ad( esp_gcm_context *ctx,
return MBEDTLS_ERR_GCM_BAD_INPUT;
}
#if defined(MBEDTLS_GCM_NON_AES_CIPHER_SOFT_FALLBACK)
#if defined(MBEDTLS_GCM_NON_AES_CIPHER_SOFT_FALLBACK) && 0
if (ctx->ctx_soft != NULL) {
return mbedtls_gcm_update_ad_soft(ctx->ctx_soft, aad, aad_len);
}
@@ -493,7 +493,7 @@ int esp_aes_gcm_update( esp_gcm_context *ctx,
return MBEDTLS_ERR_GCM_BAD_INPUT;
}
#if defined(MBEDTLS_GCM_NON_AES_CIPHER_SOFT_FALLBACK)
#if defined(MBEDTLS_GCM_NON_AES_CIPHER_SOFT_FALLBACK) && 0
if (ctx->ctx_soft != NULL) {
return mbedtls_gcm_update_soft(ctx->ctx_soft, input, input_length, output, output_size, output_length);
}
@@ -565,7 +565,7 @@ int esp_aes_gcm_finish( esp_gcm_context *ctx,
size_t *output_length,
unsigned char *tag, size_t tag_len )
{
#if defined(MBEDTLS_GCM_NON_AES_CIPHER_SOFT_FALLBACK)
#if defined(MBEDTLS_GCM_NON_AES_CIPHER_SOFT_FALLBACK) && 0
if (ctx->ctx_soft != NULL) {
return mbedtls_gcm_finish_soft(ctx->ctx_soft, output, output_size, output_length, tag, tag_len);
}
@@ -666,7 +666,7 @@ int esp_aes_gcm_crypt_and_tag( esp_gcm_context *ctx,
return MBEDTLS_ERR_GCM_BAD_INPUT;
}
#if defined(MBEDTLS_GCM_NON_AES_CIPHER_SOFT_FALLBACK)
#if defined(MBEDTLS_GCM_NON_AES_CIPHER_SOFT_FALLBACK) && 0
if (ctx->ctx_soft != NULL) {
return mbedtls_gcm_crypt_and_tag_soft(ctx->ctx_soft, mode, length, iv, iv_len, aad, aad_len, input, output, tag_len, tag);
}
@@ -761,7 +761,7 @@ int esp_aes_gcm_auth_decrypt( esp_gcm_context *ctx,
const unsigned char *input,
unsigned char *output )
{
#if defined(MBEDTLS_GCM_NON_AES_CIPHER_SOFT_FALLBACK)
#if defined(MBEDTLS_GCM_NON_AES_CIPHER_SOFT_FALLBACK) && 0
if (ctx->ctx_soft != NULL) {
return mbedtls_gcm_auth_decrypt_soft(ctx->ctx_soft, length, iv, iv_len, aad, aad_len, tag, tag_len, input, output);
}
components/mbedtls/port/ecc/ecc_alt.c
+2
View File
@@ -9,8 +9,10 @@
#include "ecc_impl.h"
#include "hal/ecc_ll.h"
#define MBEDTLS_DECLARE_PRIVATE_IDENTIFIERS
#include "mbedtls/ecp.h"
#include "mbedtls/platform_util.h"
#include "mbedtls/bignum.h"
#if defined(MBEDTLS_ECP_MUL_ALT) || defined(MBEDTLS_ECP_MUL_ALT_SOFT_FALLBACK)
components/mbedtls/port/ecdsa/ecdsa_alt.c
+12 -8
View File
@@ -9,17 +9,20 @@
#include "esp_log.h"
#include "hal/ecdsa_types.h"
#include "ecdsa/ecdsa_alt.h"
#include "soc/soc_caps.h"
#include "esp_crypto_lock.h"
#include "esp_crypto_periph_clk.h"
#include "mbedtls/error.h"
#define MBEDTLS_DECLARE_PRIVATE_IDENTIFIERS
// #include "mbedtls/error.h"
#include "mbedtls/ecdsa.h"
#include "mbedtls/asn1.h"
#include "mbedtls/asn1write.h"
#include "mbedtls/platform_util.h"
#include "mbedtls/bignum.h"
#include "ecdsa/ecdsa_alt.h"
#if CONFIG_MBEDTLS_TEE_SEC_STG_ECDSA_SIGN
#include "esp_tee_sec_storage.h"
#endif
@@ -906,7 +909,7 @@ static int ecdsa_signature_to_asn1(const mbedtls_mpi *r, const mbedtls_mpi *s,
unsigned char *sig, size_t sig_size,
size_t *slen)
{
int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
int ret = -1;
unsigned char buf[MBEDTLS_ECDSA_MAX_LEN] = { 0 };
// Setting the pointer p to the end of the buffer as the functions used afterwards write in backwards manner in the given buffer.
unsigned char *p = buf + sizeof(buf);
@@ -944,7 +947,7 @@ int __wrap_mbedtls_ecdsa_write_signature_restartable(mbedtls_ecdsa_context *ctx,
return __real_mbedtls_ecdsa_write_signature_restartable(ctx, md_alg, hash, hlen, sig, sig_size, slen, f_rng, p_rng, rs_ctx);
}
int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
int ret = -1;
mbedtls_mpi r, s;
mbedtls_mpi_init(&r);
@@ -1155,7 +1158,7 @@ int __wrap_mbedtls_ecdsa_read_signature_restartable(mbedtls_ecdsa_context *ctx,
const unsigned char *sig, size_t slen,
mbedtls_ecdsa_restart_ctx *rs_ctx)
{
int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
int ret = -1;
unsigned char *p = (unsigned char *) sig;
const unsigned char *end = sig + slen;
size_t len;
@@ -1170,8 +1173,9 @@ int __wrap_mbedtls_ecdsa_read_signature_restartable(mbedtls_ecdsa_context *ctx,
}
if (p + len != end) {
ret = MBEDTLS_ERROR_ADD(MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
MBEDTLS_ERR_ASN1_LENGTH_MISMATCH);
// ret = MBEDTLS_ERROR_ADD(MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
// MBEDTLS_ERR_ASN1_LENGTH_MISMATCH);
ret = MBEDTLS_ERR_ECP_BAD_INPUT_DATA + MBEDTLS_ERR_ASN1_LENGTH_MISMATCH;
goto cleanup;
}
@@ -1190,7 +1194,7 @@ int __wrap_mbedtls_ecdsa_read_signature_restartable(mbedtls_ecdsa_context *ctx,
* Return 0 if the buffer just contains the signature, and a specific
* error code if the valid signature is followed by more data. */
if (p != end) {
ret = MBEDTLS_ERR_ECP_SIG_LEN_MISMATCH;
ret = -1;
}
cleanup:
components/mbedtls/port/psa_driver/esp_aes/psa_crypto_driver_esp_aes.c
+9 -5
View File
@@ -175,8 +175,6 @@ psa_status_t esp_crypto_aes_update(
size_t expected_output_size;
*output_length = 0;
esp_aes_context *ctx = (esp_aes_context *) esp_aes_driver_ctx->esp_aes_ctx;
if (!PSA_ALG_IS_STREAM_CIPHER(esp_aes_driver_ctx->aes_alg)) {
/* Take the unprocessed partial block left over from previous
* update calls, if any, plus the input to this call. Remove
@@ -212,8 +210,9 @@ psa_status_t esp_crypto_aes_update(
}
switch (esp_aes_driver_ctx->aes_alg) {
#if CONFIG_MBEDTLS_CIPHER_MODE_CTR
case PSA_ALG_CTR:
ret = esp_aes_crypt_ctr(ctx,
ret = esp_aes_crypt_ctr(esp_aes_driver_ctx->esp_aes_ctx,
input_length,
&esp_aes_driver_ctx->unprocessed_len,
esp_aes_driver_ctx->iv,
@@ -222,8 +221,10 @@ psa_status_t esp_crypto_aes_update(
output);
*output_length = input_length;
break;
#endif /* CONFIG_MBEDTLS_CIPHER_MODE_CTR */
#if CONFIG_MBEDTLS_CIPHER_MODE_CFB
case PSA_ALG_CFB:
ret = esp_aes_crypt_cfb128(ctx,
ret = esp_aes_crypt_cfb128(esp_aes_driver_ctx->esp_aes_ctx,
esp_aes_driver_ctx->mode,
input_length,
&esp_aes_driver_ctx->unprocessed_len,
@@ -232,8 +233,10 @@ psa_status_t esp_crypto_aes_update(
output);
*output_length = input_length;
break;
#endif /* CONFIG_MBEDTLS_CIPHER_MODE_CFB */
#if CONFIG_MBEDTLS_CIPHER_MODE_OFB
case PSA_ALG_OFB:
ret = esp_aes_crypt_ofb(ctx,
ret = esp_aes_crypt_ofb(esp_aes_driver_ctx->esp_aes_ctx,
input_length,
&esp_aes_driver_ctx->unprocessed_len,
esp_aes_driver_ctx->iv,
@@ -241,6 +244,7 @@ psa_status_t esp_crypto_aes_update(
output);
*output_length = input_length;
break;
#endif /* CONFIG_MBEDTLS_CIPHER_MODE_OFB */
case PSA_ALG_CBC_NO_PADDING:
case PSA_ALG_CBC_PKCS7:
ret = esp_crypto_aes_cbc_update(esp_aes_driver_ctx,
components/mbedtls/port/psa_driver/esp_sha/core/psa_crypto_driver_esp_sha1.c
+20 -28
View File
@@ -24,37 +24,11 @@ static const unsigned char sha1_padding[64] = {
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
};
static int esp_sha1_starts(esp_sha1_context *ctx) {
psa_status_t esp_sha1_starts(esp_sha1_context *ctx) {
memset(ctx, 0, sizeof(esp_sha1_context));
return ESP_OK;
return PSA_SUCCESS;
}
// int mbedtls_internal_sha1_process(mbedtls_sha1_context *ctx, const unsigned char data[64])
// {
// esp_sha_acquire_hardware();
// esp_sha_set_mode(ctx->mode);
// esp_internal_sha_update_state(ctx);
// #if SOC_SHA_SUPPORT_DMA
// if (sha_operation_mode(64) == SHA_DMA_MODE) {
// int ret = esp_sha_dma(SHA1, data, 64, NULL, 0, ctx->first_block);
// if (ret != 0) {
// esp_sha_release_hardware();
// return ret;
// }
// } else
// #endif /* SOC_SHA_SUPPORT_DMA */
// {
// esp_sha_block(ctx->mode, data, ctx->first_block);
// }
// esp_sha_read_digest_state(ctx->mode, ctx->state);
// esp_sha_release_hardware();
// return 0;
// }
static void esp_internal_sha1_block_process(esp_sha1_context *ctx, const uint8_t *data)
{
esp_sha_block(SHA1, data, ctx->first_block);
@@ -241,3 +215,21 @@ psa_status_t esp_sha1_driver_finish(
*hash_length = PSA_HASH_LENGTH(PSA_ALG_SHA_1);
return PSA_SUCCESS;
}
psa_status_t esp_sha1_driver_abort(esp_sha1_context *ctx)
{
if (!ctx) {
return PSA_ERROR_INVALID_ARGUMENT;
}
memset(ctx, 0, sizeof(esp_sha1_context));
return PSA_SUCCESS;
}
psa_status_t esp_sha1_driver_clone(const esp_sha1_context *source_ctx, esp_sha1_context *target_ctx)
{
if (source_ctx == NULL || target_ctx == NULL) {
return PSA_ERROR_INVALID_ARGUMENT;
}
memcpy(target_ctx, source_ctx, sizeof(esp_sha1_context));
return PSA_SUCCESS;
}
components/mbedtls/port/psa_driver/esp_sha/core/psa_crypto_driver_esp_sha256.c
+20 -2
View File
@@ -24,10 +24,10 @@ static const unsigned char sha256_padding[64] = {
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
};
static int esp_sha256_starts(esp_sha256_context *ctx, int mode) {
psa_status_t esp_sha256_starts(esp_sha256_context *ctx, int mode) {
memset(ctx, 0, sizeof(esp_sha256_context));
ctx->mode = mode; /* SHA2_224 or SHA2_256 */
return ESP_OK;
return PSA_SUCCESS;
}
static void esp_internal_sha256_block_process(esp_sha256_context *ctx, const uint8_t *data)
@@ -253,3 +253,21 @@ psa_status_t esp_sha256_driver_finish(
return PSA_SUCCESS;
}
psa_status_t esp_sha256_driver_abort(esp_sha256_context *ctx)
{
if (!ctx) {
return PSA_ERROR_INVALID_ARGUMENT;
}
memset(ctx, 0, sizeof(esp_sha256_context));
return PSA_SUCCESS;
}
psa_status_t esp_sha256_driver_clone(const esp_sha256_context *source_ctx, esp_sha256_context *target_ctx)
{
if (source_ctx == NULL || target_ctx == NULL) {
return PSA_ERROR_INVALID_ARGUMENT;
}
memcpy(target_ctx, source_ctx, sizeof(esp_sha256_context));
return PSA_SUCCESS;
}
components/mbedtls/port/psa_driver/esp_sha/core/psa_crypto_driver_esp_sha512.c
+20 -3
View File
@@ -45,10 +45,10 @@ static const unsigned char sha512_padding[128] = {
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
};
static int esp_sha512_starts(esp_sha512_context *ctx, int mode) {
psa_status_t esp_sha512_starts(esp_sha512_context *ctx, int mode) {
memset(ctx, 0, sizeof(esp_sha512_context));
ctx->mode = mode;
return ESP_OK;
return PSA_SUCCESS;
}
static int esp_internal_sha_update_state(esp_sha512_context *ctx)
@@ -203,7 +203,6 @@ psa_status_t esp_sha512_driver_compute(
size_t hash_size,
size_t *hash_length)
{
printf("SHA512 Driver Compute\n");
if (!hash || !hash_length) {
return PSA_ERROR_INVALID_ARGUMENT;
}
@@ -281,4 +280,22 @@ psa_status_t esp_sha512_driver_finish(
return PSA_SUCCESS;
}
psa_status_t esp_sha512_driver_abort(esp_sha512_context *ctx)
{
if (!ctx) {
return PSA_ERROR_INVALID_ARGUMENT;
}
memset(ctx, 0, sizeof(esp_sha512_context));
return PSA_SUCCESS;
}
psa_status_t esp_sha512_driver_clone(const esp_sha512_context *source_ctx, esp_sha512_context *target_ctx)
{
if (source_ctx == NULL || target_ctx == NULL) {
return PSA_ERROR_INVALID_ARGUMENT;
}
memcpy(target_ctx, source_ctx, sizeof(esp_sha512_context));
return PSA_SUCCESS;
}
#endif // SOC_SHA_SUPPORT_SHA512
components/mbedtls/port/psa_driver/esp_sha/include/psa_crypto_driver_esp_sha1.h
+6
View File
@@ -25,6 +25,8 @@ psa_status_t esp_sha1_driver_compute(
size_t hash_size,
size_t *hash_length);
psa_status_t esp_sha1_starts(esp_sha1_context *ctx);
psa_status_t esp_sha1_driver_update(
esp_sha1_context *ctx,
const uint8_t *input,
@@ -35,4 +37,8 @@ psa_status_t esp_sha1_driver_finish(
uint8_t *hash,
size_t hash_size,
size_t *hash_length);
psa_status_t esp_sha1_driver_abort(esp_sha1_context *ctx);
psa_status_t esp_sha1_driver_clone(const esp_sha1_context *source_ctx, esp_sha1_context *target_ctx);
#endif /* ESP_SHA_DRIVER_ENABLED */
components/mbedtls/port/psa_driver/esp_sha/include/psa_crypto_driver_esp_sha256.h
+6
View File
@@ -17,6 +17,8 @@
typedef uint32_t psa_algorithm_t;
typedef int32_t psa_status_t;
psa_status_t esp_sha256_starts(esp_sha256_context *ctx, int is224);
psa_status_t esp_sha256_driver_compute(
esp_sha256_context *ctx,
psa_algorithm_t alg,
@@ -37,4 +39,8 @@ psa_status_t esp_sha256_driver_finish(
size_t hash_size,
size_t *hash_length,
esp_sha_operation_type_t sha_type);
psa_status_t esp_sha256_driver_abort(esp_sha256_context *ctx);
psa_status_t esp_sha256_driver_clone(const esp_sha256_context *source_ctx, esp_sha256_context *target_ctx);
#endif /* ESP_SHA_DRIVER_ENABLED */
components/mbedtls/port/psa_driver/esp_sha/include/psa_crypto_driver_esp_sha512.h
+6
View File
@@ -26,6 +26,8 @@ psa_status_t esp_sha512_driver_compute(
size_t hash_size,
size_t *hash_length);
psa_status_t esp_sha512_starts(esp_sha512_context *ctx, int mode);
psa_status_t esp_sha512_driver_update(
esp_sha512_context *ctx,
const uint8_t *input,
@@ -37,4 +39,8 @@ psa_status_t esp_sha512_driver_finish(
size_t hash_size,
size_t *hash_length,
esp_sha_operation_type_t sha_type);
psa_status_t esp_sha512_driver_abort(esp_sha512_context *ctx);
psa_status_t esp_sha512_driver_clone(const esp_sha512_context *source_ctx, esp_sha512_context *target_ctx);
#endif /* ESP_SHA_DRIVER_ENABLED */
components/mbedtls/port/psa_driver/esp_sha/parallel_engine/psa_crypto_driver_esp_sha1.c
+228 -22
View File
@@ -14,6 +14,26 @@
#include "sha/sha_parallel_engine.h"
#include "esp_err.h"
#ifndef GET_UINT32_BE
#define GET_UINT32_BE(n,b,i) \
{ \
(n) = ( (uint32_t) (b)[(i) ] << 24 ) \
| ( (uint32_t) (b)[(i) + 1] << 16 ) \
| ( (uint32_t) (b)[(i) + 2] << 8 ) \
| ( (uint32_t) (b)[(i) + 3] ); \
}
#endif
#ifndef PUT_UINT32_BE
#define PUT_UINT32_BE(n,b,i) \
{ \
(b)[(i) ] = (unsigned char) ( (n) >> 24 ); \
(b)[(i) + 1] = (unsigned char) ( (n) >> 16 ); \
(b)[(i) + 2] = (unsigned char) ( (n) >> 8 ); \
(b)[(i) + 3] = (unsigned char) ( (n) ); \
}
#endif
static const unsigned char sha1_padding[64] = {
0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
@@ -21,7 +41,8 @@ static const unsigned char sha1_padding[64] = {
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
};
static int esp_sha1_starts(esp_sha1_context *ctx) {
psa_status_t esp_sha1_starts(esp_sha1_context *ctx)
{
memset(ctx, 0, sizeof(esp_sha1_context));
ctx->total[0] = 0;
ctx->total[1] = 0;
@@ -31,40 +52,191 @@ static int esp_sha1_starts(esp_sha1_context *ctx) {
ctx->state[2] = 0x98BADCFE;
ctx->state[3] = 0x10325476;
ctx->state[4] = 0xC3D2E1F0;
// esp_sha_unlock_engine(SHA1);
if (ctx->operation_mode == ESP_SHA_MODE_HARDWARE) {
esp_sha_unlock_engine(SHA1);
}
ctx->sha_state = ESP_SHA1_STATE_INIT;
return ESP_OK;
}
// static void esp_internal_sha_update_state(esp_sha1_context *ctx)
// {
// if (ctx->sha_state == ESP_SHA1_STATE_INIT) {
// ctx->first_block = true;
// ctx->sha_state = ESP_SHA1_STATE_IN_PROCESS;
// } else if (ctx->sha_state == ESP_SHA1_STATE_IN_PROCESS) {
// ctx->first_block = false;
// // esp_sha_write_digest_state(SHA1, ctx->state);
// }
// }
static void esp_sha1_software_process( esp_sha1_context *ctx, const unsigned char data[64] )
{
uint32_t temp, W[16], A, B, C, D, E;
GET_UINT32_BE( W[ 0], data, 0 );
GET_UINT32_BE( W[ 1], data, 4 );
GET_UINT32_BE( W[ 2], data, 8 );
GET_UINT32_BE( W[ 3], data, 12 );
GET_UINT32_BE( W[ 4], data, 16 );
GET_UINT32_BE( W[ 5], data, 20 );
GET_UINT32_BE( W[ 6], data, 24 );
GET_UINT32_BE( W[ 7], data, 28 );
GET_UINT32_BE( W[ 8], data, 32 );
GET_UINT32_BE( W[ 9], data, 36 );
GET_UINT32_BE( W[10], data, 40 );
GET_UINT32_BE( W[11], data, 44 );
GET_UINT32_BE( W[12], data, 48 );
GET_UINT32_BE( W[13], data, 52 );
GET_UINT32_BE( W[14], data, 56 );
GET_UINT32_BE( W[15], data, 60 );
#define S(x,n) ((x << n) | ((x & 0xFFFFFFFF) >> (32 - n)))
#define R(t) \
( \
temp = W[( t - 3 ) & 0x0F] ^ W[( t - 8 ) & 0x0F] ^ \
W[( t - 14 ) & 0x0F] ^ W[ t & 0x0F], \
( W[t & 0x0F] = S(temp,1) ) \
)
#define P(a,b,c,d,e,x) \
{ \
e += S(a,5) + F(b,c,d) + K + x; b = S(b,30); \
}
A = ctx->state[0];
B = ctx->state[1];
C = ctx->state[2];
D = ctx->state[3];
E = ctx->state[4];
#define F(x,y,z) (z ^ (x & (y ^ z)))
#define K 0x5A827999
P( A, B, C, D, E, W[0] );
P( E, A, B, C, D, W[1] );
P( D, E, A, B, C, W[2] );
P( C, D, E, A, B, W[3] );
P( B, C, D, E, A, W[4] );
P( A, B, C, D, E, W[5] );
P( E, A, B, C, D, W[6] );
P( D, E, A, B, C, W[7] );
P( C, D, E, A, B, W[8] );
P( B, C, D, E, A, W[9] );
P( A, B, C, D, E, W[10] );
P( E, A, B, C, D, W[11] );
P( D, E, A, B, C, W[12] );
P( C, D, E, A, B, W[13] );
P( B, C, D, E, A, W[14] );
P( A, B, C, D, E, W[15] );
P( E, A, B, C, D, R(16) );
P( D, E, A, B, C, R(17) );
P( C, D, E, A, B, R(18) );
P( B, C, D, E, A, R(19) );
#undef K
#undef F
#define F(x,y,z) (x ^ y ^ z)
#define K 0x6ED9EBA1
P( A, B, C, D, E, R(20) );
P( E, A, B, C, D, R(21) );
P( D, E, A, B, C, R(22) );
P( C, D, E, A, B, R(23) );
P( B, C, D, E, A, R(24) );
P( A, B, C, D, E, R(25) );
P( E, A, B, C, D, R(26) );
P( D, E, A, B, C, R(27) );
P( C, D, E, A, B, R(28) );
P( B, C, D, E, A, R(29) );
P( A, B, C, D, E, R(30) );
P( E, A, B, C, D, R(31) );
P( D, E, A, B, C, R(32) );
P( C, D, E, A, B, R(33) );
P( B, C, D, E, A, R(34) );
P( A, B, C, D, E, R(35) );
P( E, A, B, C, D, R(36) );
P( D, E, A, B, C, R(37) );
P( C, D, E, A, B, R(38) );
P( B, C, D, E, A, R(39) );
#undef K
#undef F
#define F(x,y,z) ((x & y) | (z & (x | y)))
#define K 0x8F1BBCDC
P( A, B, C, D, E, R(40) );
P( E, A, B, C, D, R(41) );
P( D, E, A, B, C, R(42) );
P( C, D, E, A, B, R(43) );
P( B, C, D, E, A, R(44) );
P( A, B, C, D, E, R(45) );
P( E, A, B, C, D, R(46) );
P( D, E, A, B, C, R(47) );
P( C, D, E, A, B, R(48) );
P( B, C, D, E, A, R(49) );
P( A, B, C, D, E, R(50) );
P( E, A, B, C, D, R(51) );
P( D, E, A, B, C, R(52) );
P( C, D, E, A, B, R(53) );
P( B, C, D, E, A, R(54) );
P( A, B, C, D, E, R(55) );
P( E, A, B, C, D, R(56) );
P( D, E, A, B, C, R(57) );
P( C, D, E, A, B, R(58) );
P( B, C, D, E, A, R(59) );
#undef K
#undef F
#define F(x,y,z) (x ^ y ^ z)
#define K 0xCA62C1D6
P( A, B, C, D, E, R(60) );
P( E, A, B, C, D, R(61) );
P( D, E, A, B, C, R(62) );
P( C, D, E, A, B, R(63) );
P( B, C, D, E, A, R(64) );
P( A, B, C, D, E, R(65) );
P( E, A, B, C, D, R(66) );
P( D, E, A, B, C, R(67) );
P( C, D, E, A, B, R(68) );
P( B, C, D, E, A, R(69) );
P( A, B, C, D, E, R(70) );
P( E, A, B, C, D, R(71) );
P( D, E, A, B, C, R(72) );
P( C, D, E, A, B, R(73) );
P( B, C, D, E, A, R(74) );
P( A, B, C, D, E, R(75) );
P( E, A, B, C, D, R(76) );
P( D, E, A, B, C, R(77) );
P( C, D, E, A, B, R(78) );
P( B, C, D, E, A, R(79) );
#undef K
#undef F
ctx->state[0] += A;
ctx->state[1] += B;
ctx->state[2] += C;
ctx->state[3] += D;
ctx->state[4] += E;
}
static int esp_internal_sha1_parallel_engine_process( esp_sha1_context *ctx, const unsigned char data[64], bool read_digest )
{
if (ctx->sha_state == ESP_SHA1_STATE_INIT) {
if (esp_sha_try_lock_engine(SHA1)) {
printf("Got the SHA1 engine lock\n");
ctx->first_block = true;
ctx->sha_state = ESP_SHA1_STATE_IN_PROCESS;
ctx->operation_mode = ESP_SHA_MODE_HARDWARE;
} else {
printf("Failed to lock SHA1 engine\n");
return -1;
ctx->operation_mode = ESP_SHA_MODE_SOFTWARE;
}
} else if (ctx->sha_state == ESP_SHA1_STATE_IN_PROCESS) {
// printf("SHA1 in process\n");
ctx->first_block = false;
}
esp_sha_block(SHA1, data, ctx->first_block);
if (read_digest) {
esp_sha_read_digest_state(SHA1, ctx->state);
if (ctx->operation_mode == ESP_SHA_MODE_HARDWARE) {
esp_sha_block(SHA1, data, ctx->first_block);
if (read_digest) {
esp_sha_read_digest_state(SHA1, ctx->state);
}
} else {
// Software mode processing can be added here if needed
esp_sha1_software_process(ctx, data);
}
return 0;
@@ -162,7 +334,9 @@ static int esp_sha1_finish(esp_sha1_context *ctx, uint8_t *output)
if (ctx->sha_state == ESP_SHA1_STATE_IN_PROCESS) {
// If there is no more input data, and state is in hardware, read it out to ctx->state
// This ensures that ctx->state always has the latest digest state
esp_sha_read_digest_state(SHA1, ctx->state);
if (ctx->operation_mode == ESP_SHA_MODE_HARDWARE) {
esp_sha_read_digest_state(SHA1, ctx->state);
}
}
PUT_UINT32_BE( ctx->state[0], output, 0 );
@@ -172,8 +346,11 @@ static int esp_sha1_finish(esp_sha1_context *ctx, uint8_t *output)
PUT_UINT32_BE( ctx->state[4], output, 16 );
out:
esp_sha_unlock_engine(SHA1);
if (ctx->operation_mode == ESP_SHA_MODE_HARDWARE) {
esp_sha_unlock_engine(SHA1);
ctx->operation_mode = ESP_SHA_MODE_SOFTWARE;
}
memset(ctx, 0, sizeof(esp_sha1_context));
return ret;
}
@@ -226,3 +403,32 @@ psa_status_t esp_sha1_driver_compute(
*hash_length = PSA_HASH_LENGTH(PSA_ALG_SHA_1);
return PSA_SUCCESS;
}
psa_status_t esp_sha1_driver_abort(esp_sha1_context *ctx)
{
if (!ctx) {
return PSA_ERROR_INVALID_ARGUMENT;
}
// Also unlock the hardware engine if it was in use
if (ctx->operation_mode == ESP_SHA_MODE_HARDWARE) {
esp_sha_unlock_engine(SHA1);
ctx->operation_mode = ESP_SHA_MODE_SOFTWARE;
}
memset(ctx, 0, sizeof(esp_sha1_context));
return PSA_SUCCESS;
}
psa_status_t esp_sha1_driver_clone(const esp_sha1_context *source_ctx, esp_sha1_context *target_ctx)
{
if (source_ctx == NULL || target_ctx == NULL) {
return PSA_ERROR_INVALID_ARGUMENT;
}
memcpy(target_ctx, source_ctx, sizeof(esp_sha1_context));
// If the source context is in hardware mode, we need to read the digest state
// from the hardware engine to ensure the target context has the correct state
if (source_ctx->operation_mode == ESP_SHA_MODE_HARDWARE) {
esp_sha_read_digest_state(SHA1, target_ctx->state);
target_ctx->operation_mode = ESP_SHA_MODE_SOFTWARE; // Cloned context operates in software mode
}
return PSA_SUCCESS;
}
components/mbedtls/port/psa_driver/esp_sha/parallel_engine/psa_crypto_driver_esp_sha256.c
+200 -36
View File
@@ -14,6 +14,29 @@
#include "sha/sha_parallel_engine.h"
#include "esp_err.h"
/*
* 32-bit integer manipulation macros (big endian)
*/
#ifndef GET_UINT32_BE
#define GET_UINT32_BE(n,b,i) \
do { \
(n) = ( (uint32_t) (b)[(i) ] << 24 ) \
| ( (uint32_t) (b)[(i) + 1] << 16 ) \
| ( (uint32_t) (b)[(i) + 2] << 8 ) \
| ( (uint32_t) (b)[(i) + 3] ); \
} while( 0 )
#endif
#ifndef PUT_UINT32_BE
#define PUT_UINT32_BE(n,b,i) \
do { \
(b)[(i) ] = (unsigned char) ( (n) >> 24 ); \
(b)[(i) + 1] = (unsigned char) ( (n) >> 16 ); \
(b)[(i) + 2] = (unsigned char) ( (n) >> 8 ); \
(b)[(i) + 3] = (unsigned char) ( (n) ); \
} while( 0 )
#endif
static const unsigned char sha256_padding[64] = {
0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
@@ -21,24 +44,150 @@ static const unsigned char sha256_padding[64] = {
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
};
static int esp_internal_sha256_parallel_engine_process( esp_sha256_context *ctx, const unsigned char data[64], bool read_digest )
psa_status_t esp_sha256_starts(esp_sha256_context *ctx, int is224)
{
memset(ctx, 0, sizeof(esp_sha256_context));
ctx->total[0] = 0;
ctx->total[1] = 0;
ctx->state[0] = 0x6A09E667;
ctx->state[1] = 0xBB67AE85;
ctx->state[2] = 0x3C6EF372;
ctx->state[3] = 0xA54FF53A;
ctx->state[4] = 0x510E527F;
ctx->state[5] = 0x9B05688C;
ctx->state[6] = 0x1F83D9AB;
ctx->state[7] = 0x5BE0CD19;
// if (ctx->operation_mode == ESP_SHA_MODE_HARDWARE) {
// esp_sha_unlock_engine(SHA2_256);
// }
ctx->sha_state = ESP_SHA256_STATE_INIT;
ctx->operation_mode = ESP_SHA_MODE_SOFTWARE;
ctx->first_block = false;
return PSA_SUCCESS;
}
static const uint32_t K[] = {
0x428A2F98, 0x71374491, 0xB5C0FBCF, 0xE9B5DBA5,
0x3956C25B, 0x59F111F1, 0x923F82A4, 0xAB1C5ED5,
0xD807AA98, 0x12835B01, 0x243185BE, 0x550C7DC3,
0x72BE5D74, 0x80DEB1FE, 0x9BDC06A7, 0xC19BF174,
0xE49B69C1, 0xEFBE4786, 0x0FC19DC6, 0x240CA1CC,
0x2DE92C6F, 0x4A7484AA, 0x5CB0A9DC, 0x76F988DA,
0x983E5152, 0xA831C66D, 0xB00327C8, 0xBF597FC7,
0xC6E00BF3, 0xD5A79147, 0x06CA6351, 0x14292967,
0x27B70A85, 0x2E1B2138, 0x4D2C6DFC, 0x53380D13,
0x650A7354, 0x766A0ABB, 0x81C2C92E, 0x92722C85,
0xA2BFE8A1, 0xA81A664B, 0xC24B8B70, 0xC76C51A3,
0xD192E819, 0xD6990624, 0xF40E3585, 0x106AA070,
0x19A4C116, 0x1E376C08, 0x2748774C, 0x34B0BCB5,
0x391C0CB3, 0x4ED8AA4A, 0x5B9CCA4F, 0x682E6FF3,
0x748F82EE, 0x78A5636F, 0x84C87814, 0x8CC70208,
0x90BEFFFA, 0xA4506CEB, 0xBEF9A3F7, 0xC67178F2,
};
#define SHR(x,n) ((x & 0xFFFFFFFF) >> n)
#define ROTR(x,n) (SHR(x,n) | (x << (32 - n)))
#define S0(x) (ROTR(x, 7) ^ ROTR(x,18) ^ SHR(x, 3))
#define S1(x) (ROTR(x,17) ^ ROTR(x,19) ^ SHR(x,10))
#define S2(x) (ROTR(x, 2) ^ ROTR(x,13) ^ ROTR(x,22))
#define S3(x) (ROTR(x, 6) ^ ROTR(x,11) ^ ROTR(x,25))
#define F0(x,y,z) ((x & y) | (z & (x | y)))
#define F1(x,y,z) (z ^ (x & (y ^ z)))
#define R(t) \
( \
W[t] = S1(W[t - 2]) + W[t - 7] + \
S0(W[t - 15]) + W[t - 16] \
)
#define P(a,b,c,d,e,f,g,h,x,K) \
{ \
temp1 = h + S3(e) + F1(e,f,g) + K + x; \
temp2 = S2(a) + F0(a,b,c); \
d += temp1; h = temp1 + temp2; \
}
static void esp_sha256_software_process(esp_sha256_context *ctx, const unsigned char data[64])
{
uint32_t temp1, temp2, W[64] = {0};
uint32_t A[8] = {0};
unsigned int i = 0;
for ( i = 0; i < 8; i++ ) {
A[i] = ctx->state[i];
}
#if defined(MBEDTLS_SHA256_SMALLER)
for ( i = 0; i < 64; i++ ) {
if ( i < 16 ) {
GET_UINT32_BE( W[i], data, 4 * i );
} else {
R( i );
}
P( A[0], A[1], A[2], A[3], A[4], A[5], A[6], A[7], W[i], K[i] );
temp1 = A[7]; A[7] = A[6]; A[6] = A[5]; A[5] = A[4]; A[4] = A[3];
A[3] = A[2]; A[2] = A[1]; A[1] = A[0]; A[0] = temp1;
}
#else /* MBEDTLS_SHA256_SMALLER */
for ( i = 0; i < 16; i++ ) {
GET_UINT32_BE( W[i], data, 4 * i );
}
for ( i = 0; i < 16; i += 8 ) {
P( A[0], A[1], A[2], A[3], A[4], A[5], A[6], A[7], W[i + 0], K[i + 0] );
P( A[7], A[0], A[1], A[2], A[3], A[4], A[5], A[6], W[i + 1], K[i + 1] );
P( A[6], A[7], A[0], A[1], A[2], A[3], A[4], A[5], W[i + 2], K[i + 2] );
P( A[5], A[6], A[7], A[0], A[1], A[2], A[3], A[4], W[i + 3], K[i + 3] );
P( A[4], A[5], A[6], A[7], A[0], A[1], A[2], A[3], W[i + 4], K[i + 4] );
P( A[3], A[4], A[5], A[6], A[7], A[0], A[1], A[2], W[i + 5], K[i + 5] );
P( A[2], A[3], A[4], A[5], A[6], A[7], A[0], A[1], W[i + 6], K[i + 6] );
P( A[1], A[2], A[3], A[4], A[5], A[6], A[7], A[0], W[i + 7], K[i + 7] );
}
for ( i = 16; i < 64; i += 8 ) {
P( A[0], A[1], A[2], A[3], A[4], A[5], A[6], A[7], R(i + 0), K[i + 0] );
P( A[7], A[0], A[1], A[2], A[3], A[4], A[5], A[6], R(i + 1), K[i + 1] );
P( A[6], A[7], A[0], A[1], A[2], A[3], A[4], A[5], R(i + 2), K[i + 2] );
P( A[5], A[6], A[7], A[0], A[1], A[2], A[3], A[4], R(i + 3), K[i + 3] );
P( A[4], A[5], A[6], A[7], A[0], A[1], A[2], A[3], R(i + 4), K[i + 4] );
P( A[3], A[4], A[5], A[6], A[7], A[0], A[1], A[2], R(i + 5), K[i + 5] );
P( A[2], A[3], A[4], A[5], A[6], A[7], A[0], A[1], R(i + 6), K[i + 6] );
P( A[1], A[2], A[3], A[4], A[5], A[6], A[7], A[0], R(i + 7), K[i + 7] );
}
#endif /* MBEDTLS_SHA256_SMALLER */
for ( i = 0; i < 8; i++ ) {
ctx->state[i] += A[i];
}
}
static int esp_internal_sha256_parallel_engine_process(esp_sha256_context *ctx, const unsigned char data[64], bool read_digest)
{
if (ctx->sha_state == ESP_SHA256_STATE_INIT) {
if (esp_sha_try_lock_engine(SHA2_256)) {
printf("Got the SHA2_256 engine lock\n");
ctx->first_block = true;
ctx->sha_state = ESP_SHA256_STATE_IN_PROCESS;
ctx->operation_mode = ESP_SHA_MODE_HARDWARE;
} else {
printf("Failed to lock SHA2_256 engine\n");
return -1;
ctx->operation_mode = ESP_SHA_MODE_SOFTWARE;
}
ctx->sha_state = ESP_SHA256_STATE_IN_PROCESS;
} else if (ctx->sha_state == ESP_SHA256_STATE_IN_PROCESS) {
// printf("SHA1 in process\n");
ctx->first_block = false;
}
esp_sha_block(SHA2_256, data, ctx->first_block);
if (read_digest) {
esp_sha_read_digest_state(SHA2_256, ctx->state);
if (ctx->operation_mode == ESP_SHA_MODE_HARDWARE) {
esp_sha_block(SHA2_256, data, ctx->first_block);
if (read_digest) {
esp_sha_read_digest_state(SHA2_256, ctx->state);
}
} else {
// Software mode processing can be added here if needed
esp_sha256_software_process(ctx, data);
}
return 0;
@@ -86,9 +235,6 @@ static int esp_sha256_update(esp_sha256_context *ctx, const unsigned char *input
ilen -= 64;
}
// esp_sha_read_digest_state(SHA2_256, ctx->state);
if ( ilen > 0 ) {
memcpy( (void *) (ctx->buffer + left), input, ilen );
}
@@ -104,7 +250,6 @@ psa_status_t esp_sha256_driver_update(
if (ctx == NULL || input == NULL) {
return PSA_ERROR_INVALID_ARGUMENT;
}
int ret = esp_sha256_update(ctx, input, input_length);
if (ret != ESP_OK) {
return PSA_ERROR_HARDWARE_FAILURE;
@@ -113,26 +258,6 @@ psa_status_t esp_sha256_driver_update(
return PSA_SUCCESS;
}
static int esp_sha256_starts( esp_sha256_context *ctx, int is224 )
{
memset( ctx, 0, sizeof( esp_sha256_context ) );
ctx->total[0] = 0;
ctx->total[1] = 0;
ctx->state[0] = 0x6A09E667;
ctx->state[1] = 0xBB67AE85;
ctx->state[2] = 0x3C6EF372;
ctx->state[3] = 0xA54FF53A;
ctx->state[4] = 0x510E527F;
ctx->state[5] = 0x9B05688C;
ctx->state[6] = 0x1F83D9AB;
ctx->state[7] = 0x5BE0CD19;
// esp_sha_unlock_engine(SHA2_256);
ctx->sha_state = ESP_SHA256_STATE_INIT;
return 0;
}
static int esp_sha256_finish(esp_sha256_context *ctx, unsigned char *output)
{
int ret = -1;
@@ -158,7 +283,14 @@ static int esp_sha256_finish(esp_sha256_context *ctx, unsigned char *output)
goto out;
}
esp_sha_read_digest_state(SHA2_256, ctx->state);
if (ctx->sha_state == ESP_SHA256_STATE_IN_PROCESS) {
// If there is no more input data, and state is in hardware, read it out to ctx->state
// This ensures that ctx->state always has the latest digest state
if (ctx->operation_mode == ESP_SHA_MODE_HARDWARE) {
esp_sha_read_digest_state(SHA2_256, ctx->state);
} else {
}
}
PUT_UINT32_BE( ctx->state[0], output, 0 );
PUT_UINT32_BE( ctx->state[1], output, 4 );
@@ -167,12 +299,15 @@ static int esp_sha256_finish(esp_sha256_context *ctx, unsigned char *output)
PUT_UINT32_BE( ctx->state[4], output, 16 );
PUT_UINT32_BE( ctx->state[5], output, 20 );
PUT_UINT32_BE( ctx->state[6], output, 24 );
PUT_UINT32_BE( ctx->state[7], output, 28 );
out:
esp_sha_unlock_engine(SHA2_256);
if (ctx->operation_mode == ESP_SHA_MODE_HARDWARE) {
esp_sha_unlock_engine(SHA2_256);
ctx->operation_mode = ESP_SHA_MODE_SOFTWARE;
}
memset(ctx, 0, sizeof(esp_sha256_context));
return ret;
}
@@ -249,3 +384,32 @@ psa_status_t esp_sha256_driver_finish(
return PSA_SUCCESS;
}
psa_status_t esp_sha256_driver_abort(esp_sha256_context *ctx)
{
if (!ctx) {
return PSA_ERROR_INVALID_ARGUMENT;
}
// Also unlock the hardware engine if it was in use
if (ctx->operation_mode == ESP_SHA_MODE_HARDWARE) {
esp_sha_unlock_engine(SHA2_256);
ctx->operation_mode = ESP_SHA_MODE_SOFTWARE;
}
memset(ctx, 0, sizeof(esp_sha256_context));
return PSA_SUCCESS;
}
psa_status_t esp_sha256_driver_clone(const esp_sha256_context *source_ctx, esp_sha256_context *target_ctx)
{
if (source_ctx == NULL || target_ctx == NULL) {
return PSA_ERROR_INVALID_ARGUMENT;
}
memcpy(target_ctx, source_ctx, sizeof(esp_sha256_context));
// If the source context is in hardware mode, we need to read the digest state
// from the hardware engine to ensure the target context has the correct state
if (source_ctx->operation_mode == ESP_SHA_MODE_HARDWARE) {
esp_sha_read_digest_state(SHA2_256, target_ctx->state);
target_ctx->operation_mode = ESP_SHA_MODE_SOFTWARE; // Cloned context operates in software mode
}
return PSA_SUCCESS;
}
components/mbedtls/port/psa_driver/esp_sha/parallel_engine/psa_crypto_driver_esp_sha512.c
+213 -63
View File
@@ -20,17 +20,9 @@
#define UL64(x) x##ULL
#endif
static const unsigned char sha512_padding[128] = {
0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
};
/*
* 64-bit integer manipulation macros (big endian)
*/
#ifndef GET_UINT64_BE
#define GET_UINT64_BE(n,b,i) \
{ \
@@ -59,29 +51,193 @@ static const unsigned char sha512_padding[128] = {
}
#endif /* PUT_UINT64_BE */
static const unsigned char sha512_padding[128] = {
0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
};
inline static esp_sha_type sha_type(const esp_sha512_context *ctx)
{
return ctx->mode;
}
psa_status_t esp_sha512_starts(esp_sha512_context *ctx, int mode)
{
memset( ctx, 0, sizeof( esp_sha512_context ) );
ctx->total[0] = 0;
ctx->total[1] = 0;
if ( mode == SHA2_512 ) {
/* SHA-512 */
ctx->state[0] = UL64(0x6A09E667F3BCC908);
ctx->state[1] = UL64(0xBB67AE8584CAA73B);
ctx->state[2] = UL64(0x3C6EF372FE94F82B);
ctx->state[3] = UL64(0xA54FF53A5F1D36F1);
ctx->state[4] = UL64(0x510E527FADE682D1);
ctx->state[5] = UL64(0x9B05688C2B3E6C1F);
ctx->state[6] = UL64(0x1F83D9ABFB41BD6B);
ctx->state[7] = UL64(0x5BE0CD19137E2179);
} else {
/* SHA-384 */
ctx->state[0] = UL64(0xCBBB9D5DC1059ED8);
ctx->state[1] = UL64(0x629A292A367CD507);
ctx->state[2] = UL64(0x9159015A3070DD17);
ctx->state[3] = UL64(0x152FECD8F70E5939);
ctx->state[4] = UL64(0x67332667FFC00B31);
ctx->state[5] = UL64(0x8EB44A8768581511);
ctx->state[6] = UL64(0xDB0C2E0D64F98FA7);
ctx->state[7] = UL64(0x47B5481DBEFA4FA4);
}
ctx->mode = mode;
ctx->sha_state = ESP_SHA512_STATE_INIT;
if (ctx->operation_mode == ESP_SHA_MODE_HARDWARE) {
esp_sha_unlock_engine(sha_type(ctx));
}
return ESP_OK;
}
/*
* Round constants
*/
static const uint64_t K[80] = {
UL64(0x428A2F98D728AE22), UL64(0x7137449123EF65CD),
UL64(0xB5C0FBCFEC4D3B2F), UL64(0xE9B5DBA58189DBBC),
UL64(0x3956C25BF348B538), UL64(0x59F111F1B605D019),
UL64(0x923F82A4AF194F9B), UL64(0xAB1C5ED5DA6D8118),
UL64(0xD807AA98A3030242), UL64(0x12835B0145706FBE),
UL64(0x243185BE4EE4B28C), UL64(0x550C7DC3D5FFB4E2),
UL64(0x72BE5D74F27B896F), UL64(0x80DEB1FE3B1696B1),
UL64(0x9BDC06A725C71235), UL64(0xC19BF174CF692694),
UL64(0xE49B69C19EF14AD2), UL64(0xEFBE4786384F25E3),
UL64(0x0FC19DC68B8CD5B5), UL64(0x240CA1CC77AC9C65),
UL64(0x2DE92C6F592B0275), UL64(0x4A7484AA6EA6E483),
UL64(0x5CB0A9DCBD41FBD4), UL64(0x76F988DA831153B5),
UL64(0x983E5152EE66DFAB), UL64(0xA831C66D2DB43210),
UL64(0xB00327C898FB213F), UL64(0xBF597FC7BEEF0EE4),
UL64(0xC6E00BF33DA88FC2), UL64(0xD5A79147930AA725),
UL64(0x06CA6351E003826F), UL64(0x142929670A0E6E70),
UL64(0x27B70A8546D22FFC), UL64(0x2E1B21385C26C926),
UL64(0x4D2C6DFC5AC42AED), UL64(0x53380D139D95B3DF),
UL64(0x650A73548BAF63DE), UL64(0x766A0ABB3C77B2A8),
UL64(0x81C2C92E47EDAEE6), UL64(0x92722C851482353B),
UL64(0xA2BFE8A14CF10364), UL64(0xA81A664BBC423001),
UL64(0xC24B8B70D0F89791), UL64(0xC76C51A30654BE30),
UL64(0xD192E819D6EF5218), UL64(0xD69906245565A910),
UL64(0xF40E35855771202A), UL64(0x106AA07032BBD1B8),
UL64(0x19A4C116B8D2D0C8), UL64(0x1E376C085141AB53),
UL64(0x2748774CDF8EEB99), UL64(0x34B0BCB5E19B48A8),
UL64(0x391C0CB3C5C95A63), UL64(0x4ED8AA4AE3418ACB),
UL64(0x5B9CCA4F7763E373), UL64(0x682E6FF3D6B2B8A3),
UL64(0x748F82EE5DEFB2FC), UL64(0x78A5636F43172F60),
UL64(0x84C87814A1F0AB72), UL64(0x8CC702081A6439EC),
UL64(0x90BEFFFA23631E28), UL64(0xA4506CEBDE82BDE9),
UL64(0xBEF9A3F7B2C67915), UL64(0xC67178F2E372532B),
UL64(0xCA273ECEEA26619C), UL64(0xD186B8C721C0C207),
UL64(0xEADA7DD6CDE0EB1E), UL64(0xF57D4F7FEE6ED178),
UL64(0x06F067AA72176FBA), UL64(0x0A637DC5A2C898A6),
UL64(0x113F9804BEF90DAE), UL64(0x1B710B35131C471B),
UL64(0x28DB77F523047D84), UL64(0x32CAAB7B40C72493),
UL64(0x3C9EBE0A15C9BEBC), UL64(0x431D67C49C100D4C),
UL64(0x4CC5D4BECB3E42B6), UL64(0x597F299CFC657E2A),
UL64(0x5FCB6FAB3AD6FAEC), UL64(0x6C44198C4A475817)
};
static void esp_sha512_software_process(esp_sha512_context *ctx, const unsigned char data[128])
{
int i;
uint64_t temp1, temp2, W[80];
uint64_t A, B, C, D, E, F, G, H;
#define SHR(x,n) (x >> n)
#define ROTR(x,n) (SHR(x,n) | (x << (64 - n)))
#define S0(x) (ROTR(x, 1) ^ ROTR(x, 8) ^ SHR(x, 7))
#define S1(x) (ROTR(x,19) ^ ROTR(x,61) ^ SHR(x, 6))
#define S2(x) (ROTR(x,28) ^ ROTR(x,34) ^ ROTR(x,39))
#define S3(x) (ROTR(x,14) ^ ROTR(x,18) ^ ROTR(x,41))
#define F0(x,y,z) ((x & y) | (z & (x | y)))
#define F1(x,y,z) (z ^ (x & (y ^ z)))
#define P(a,b,c,d,e,f,g,h,x,K) \
{ \
temp1 = h + S3(e) + F1(e,f,g) + K + x; \
temp2 = S2(a) + F0(a,b,c); \
d += temp1; h = temp1 + temp2; \
}
for ( i = 0; i < 16; i++ ) {
GET_UINT64_BE( W[i], data, i << 3 );
}
for ( ; i < 80; i++ ) {
W[i] = S1(W[i - 2]) + W[i - 7] +
S0(W[i - 15]) + W[i - 16];
}
A = ctx->state[0];
B = ctx->state[1];
C = ctx->state[2];
D = ctx->state[3];
E = ctx->state[4];
F = ctx->state[5];
G = ctx->state[6];
H = ctx->state[7];
i = 0;
do {
P( A, B, C, D, E, F, G, H, W[i], K[i] ); i++;
P( H, A, B, C, D, E, F, G, W[i], K[i] ); i++;
P( G, H, A, B, C, D, E, F, W[i], K[i] ); i++;
P( F, G, H, A, B, C, D, E, W[i], K[i] ); i++;
P( E, F, G, H, A, B, C, D, W[i], K[i] ); i++;
P( D, E, F, G, H, A, B, C, W[i], K[i] ); i++;
P( C, D, E, F, G, H, A, B, W[i], K[i] ); i++;
P( B, C, D, E, F, G, H, A, W[i], K[i] ); i++;
} while ( i < 80 );
ctx->state[0] += A;
ctx->state[1] += B;
ctx->state[2] += C;
ctx->state[3] += D;
ctx->state[4] += E;
ctx->state[5] += F;
ctx->state[6] += G;
ctx->state[7] += H;
}
static int esp_internal_sha512_parallel_engine_process( esp_sha512_context *ctx, const unsigned char data[128], bool read_digest )
{
if (ctx->sha_state == ESP_SHA512_STATE_INIT) {
if (esp_sha_try_lock_engine(SHA2_512)) {
printf("Got the SHA512 engine lock\n");
if (esp_sha_try_lock_engine(sha_type(ctx))) {
ctx->first_block = true;
ctx->sha_state = ESP_SHA512_STATE_IN_PROCESS;
ctx->operation_mode = ESP_SHA_MODE_HARDWARE;
} else {
printf("Failed to lock SHA512 engine\n");
return -1;
// printf("Failed to lock SHA512 engine\n");
ctx->operation_mode = ESP_SHA_MODE_SOFTWARE;
}
ctx->sha_state = ESP_SHA512_STATE_IN_PROCESS;
} else if (ctx->sha_state == ESP_SHA512_STATE_IN_PROCESS) {
// printf("SHA512 in process\n");
ctx->first_block = false;
}
esp_sha_block(sha_type(ctx), data, ctx->first_block);
if (read_digest) {
esp_sha_read_digest_state(sha_type(ctx), ctx->state);
if (ctx->operation_mode == ESP_SHA_MODE_HARDWARE) {
esp_sha_block(sha_type(ctx), data, ctx->first_block);
if (read_digest) {
esp_sha_read_digest_state(sha_type(ctx), ctx->state);
}
} else {
// Software mode processing can be added here if needed
esp_sha512_software_process(ctx, data);
}
return 0;
@@ -127,8 +283,6 @@ static int esp_sha512_update(esp_sha512_context *ctx, const unsigned char *input
ilen -= 128;
}
// esp_sha_read_digest_state(sha_type(ctx), ctx->state);
if ( ilen > 0 ) {
memcpy( (void *) (ctx->buffer + left), input, ilen );
}
@@ -136,42 +290,6 @@ static int esp_sha512_update(esp_sha512_context *ctx, const unsigned char *input
return 0;
}
static int esp_sha512_starts( esp_sha512_context *ctx, int mode )
{
memset( ctx, 0, sizeof( esp_sha512_context ) );
ctx->total[0] = 0;
ctx->total[1] = 0;
if ( mode == SHA2_512 ) {
/* SHA-512 */
ctx->state[0] = UL64(0x6A09E667F3BCC908);
ctx->state[1] = UL64(0xBB67AE8584CAA73B);
ctx->state[2] = UL64(0x3C6EF372FE94F82B);
ctx->state[3] = UL64(0xA54FF53A5F1D36F1);
ctx->state[4] = UL64(0x510E527FADE682D1);
ctx->state[5] = UL64(0x9B05688C2B3E6C1F);
ctx->state[6] = UL64(0x1F83D9ABFB41BD6B);
ctx->state[7] = UL64(0x5BE0CD19137E2179);
} else {
/* SHA-384 */
printf("SHA-384 Init\n");
ctx->state[0] = UL64(0xCBBB9D5DC1059ED8);
ctx->state[1] = UL64(0x629A292A367CD507);
ctx->state[2] = UL64(0x9159015A3070DD17);
ctx->state[3] = UL64(0x152FECD8F70E5939);
ctx->state[4] = UL64(0x67332667FFC00B31);
ctx->state[5] = UL64(0x8EB44A8768581511);
ctx->state[6] = UL64(0xDB0C2E0D64F98FA7);
ctx->state[7] = UL64(0x47B5481DBEFA4FA4);
}
ctx->mode = mode;
// esp_sha_unlock_engine(sha_type(ctx));
ctx->sha_state = ESP_SHA512_STATE_INIT;
return 0;
}
static int esp_sha512_finish(esp_sha512_context *ctx, unsigned char *output)
{
int ret = -1;
@@ -200,8 +318,9 @@ static int esp_sha512_finish(esp_sha512_context *ctx, unsigned char *output)
if (ctx->sha_state == ESP_SHA512_STATE_IN_PROCESS) {
// If there is no more input data, and state is in hardware, read it out to ctx->state
// This ensures that ctx->state always has the latest digest state
esp_sha_read_digest_state(SHA2_512, ctx->state);
ctx->sha_state = ESP_SHA512_STATE_INIT;
if (ctx->operation_mode == ESP_SHA_MODE_HARDWARE) {
esp_sha_read_digest_state(sha_type(ctx), ctx->state);
}
}
PUT_UINT64_BE( ctx->state[0], output, 0 );
@@ -217,8 +336,11 @@ static int esp_sha512_finish(esp_sha512_context *ctx, unsigned char *output)
}
out:
printf("Releasing SHA512 engine lock\n");
esp_sha_unlock_engine(sha_type(ctx));
if (ctx->operation_mode == ESP_SHA_MODE_HARDWARE) {
esp_sha_unlock_engine(sha_type(ctx));
ctx->operation_mode = ESP_SHA_MODE_SOFTWARE;
}
memset(ctx, 0, sizeof(esp_sha512_context));
return ret;
}
@@ -232,7 +354,6 @@ psa_status_t esp_sha512_driver_compute(
size_t hash_size,
size_t *hash_length)
{
printf("SHA512 Driver Compute\n");
if (!hash || !hash_length) {
return PSA_ERROR_INVALID_ARGUMENT;
}
@@ -306,3 +427,32 @@ psa_status_t esp_sha512_driver_finish(
return PSA_SUCCESS;
}
psa_status_t esp_sha512_driver_abort(esp_sha512_context *ctx)
{
if (!ctx) {
return PSA_ERROR_INVALID_ARGUMENT;
}
// Also unlock the hardware engine if it was in use
if (ctx->operation_mode == ESP_SHA_MODE_HARDWARE) {
esp_sha_unlock_engine(sha_type(ctx));
ctx->operation_mode = ESP_SHA_MODE_SOFTWARE;
}
memset(ctx, 0, sizeof(esp_sha512_context));
return PSA_SUCCESS;
}
psa_status_t esp_sha512_driver_clone(const esp_sha512_context *source_ctx, esp_sha512_context *target_ctx)
{
if (source_ctx == NULL || target_ctx == NULL) {
return PSA_ERROR_INVALID_ARGUMENT;
}
memcpy(target_ctx, source_ctx, sizeof(esp_sha512_context));
// If the source context is in hardware mode, we need to read the digest state
// from the hardware engine to ensure the target context has the correct state
if (source_ctx->operation_mode == ESP_SHA_MODE_HARDWARE) {
esp_sha_read_digest_state(sha_type(source_ctx), target_ctx->state);
target_ctx->operation_mode = ESP_SHA_MODE_SOFTWARE; // Cloned context operates in software mode
}
return PSA_SUCCESS;
}
components/mbedtls/port/psa_driver/esp_sha/psa_crypto_driver_esp_sha.c
+39 -11
View File
@@ -116,7 +116,7 @@ psa_status_t esp_sha_hash_setup(esp_sha_hash_operation_t *operation, psa_algorit
esp_sha1_context *sha1_ctx = calloc(1, sizeof(esp_sha1_context));
operation->sha_ctx = sha1_ctx;
operation->sha_type = ESP_SHA_OPERATION_TYPE_SHA1;
return PSA_SUCCESS;
return esp_sha1_starts(sha1_ctx);
} else
#endif // CONFIG_SOC_SHA_SUPPORT_SHA1
#if CONFIG_SOC_SHA_SUPPORT_SHA256
@@ -127,13 +127,13 @@ psa_status_t esp_sha_hash_setup(esp_sha_hash_operation_t *operation, psa_algorit
alg == PSA_ALG_SHA_256) {
esp_sha256_context *sha256_ctx = calloc(1, sizeof(esp_sha256_context));
operation->sha_ctx = sha256_ctx;
sha256_ctx->mode = SHA2_256;
int mode = SHA2_256;
operation->sha_type = ESP_SHA_OPERATION_TYPE_SHA256;
#if CONFIG_SOC_SHA_SUPPORT_SHA224
operation->sha_type = (alg == PSA_ALG_SHA_224) ? ESP_SHA_OPERATION_TYPE_SHA224 : ESP_SHA_OPERATION_TYPE_SHA256;
sha256_ctx->mode = (alg == PSA_ALG_SHA_224) ? SHA2_224 : SHA2_256;
mode = (alg == PSA_ALG_SHA_224) ? SHA2_224 : SHA2_256;
#endif // CONFIG_SOC_SHA_SUPPORT_SHA224
return PSA_SUCCESS;
return esp_sha256_starts(sha256_ctx, mode);
} else
#endif // CONFIG_SOC_SHA_SUPPORT_SHA256
#if CONFIG_SOC_SHA_SUPPORT_SHA512
@@ -144,13 +144,13 @@ psa_status_t esp_sha_hash_setup(esp_sha_hash_operation_t *operation, psa_algorit
alg == PSA_ALG_SHA_512) {
esp_sha512_context *sha512_ctx = calloc(1, sizeof(esp_sha512_context));
operation->sha_ctx = sha512_ctx;
sha512_ctx->mode = SHA2_512;
int mode = SHA2_512;
operation->sha_type = ESP_SHA_OPERATION_TYPE_SHA512;
#if CONFIG_SOC_SHA_SUPPORT_SHA384
operation->sha_type = (alg == PSA_ALG_SHA_384) ? ESP_SHA_OPERATION_TYPE_SHA384 : ESP_SHA_OPERATION_TYPE_SHA512;
sha512_ctx->mode = (alg == PSA_ALG_SHA_384) ? SHA2_384 : SHA2_512;
mode = (alg == PSA_ALG_SHA_384) ? SHA2_384 : SHA2_512;
#endif // CONFIG_SOC_SHA_SUPPORT_SHA384
return PSA_SUCCESS;
return esp_sha512_starts(sha512_ctx, mode);
}
#endif // CONFIG_SOC_SHA_SUPPORT_SHA512
return PSA_ERROR_NOT_SUPPORTED;
@@ -233,7 +233,35 @@ psa_status_t esp_sha_hash_abort(esp_sha_hash_operation_t *operation)
if (!operation) {
return PSA_ERROR_INVALID_ARGUMENT;
}
#if CONFIG_SOC_SHA_SUPPORT_SHA1
if (operation->sha_type == ESP_SHA_OPERATION_TYPE_SHA1) {
esp_sha1_context *ctx = (esp_sha1_context *)operation->sha_ctx;
if (ctx) {
esp_sha1_driver_abort(ctx);
}
} else
#endif // CONFIG_SOC_SHA_SUPPORT_SHA1
#if CONFIG_SOC_SHA_SUPPORT_SHA224 || CONFIG_SOC_SHA_SUPPORT_SHA256
if (operation->sha_type == ESP_SHA_OPERATION_TYPE_SHA256 ||
operation->sha_type == ESP_SHA_OPERATION_TYPE_SHA224) {
esp_sha256_context *ctx = (esp_sha256_context *)operation->sha_ctx;
if (ctx) {
esp_sha256_driver_abort(ctx);
}
} else
#endif // CONFIG_SOC_SHA_SUPPORT_SHA224 || CONFIG_SOC_SHA_SUPPORT_SHA256
#if CONFIG_SOC_SHA_SUPPORT_SHA384 || CONFIG_SOC_SHA_SUPPORT_SHA512
if (operation->sha_type == ESP_SHA_OPERATION_TYPE_SHA384 ||
operation->sha_type == ESP_SHA_OPERATION_TYPE_SHA512) {
esp_sha512_context *ctx = (esp_sha512_context *)operation->sha_ctx;
if (ctx) {
esp_sha512_driver_abort(ctx);
}
} else
#endif // CONFIG_SOC_SHA_SUPPORT_SHA384 || CONFIG_SOC_SHA_SUPPORT_SHA512
{
return PSA_ERROR_NOT_SUPPORTED;
}
if (operation->sha_ctx) {
free(operation->sha_ctx);
operation->sha_ctx = NULL;
@@ -253,7 +281,7 @@ psa_status_t esp_sha_hash_clone(
if (!target_operation->sha_ctx) {
return PSA_ERROR_INSUFFICIENT_MEMORY;
}
memcpy(target_operation->sha_ctx, source_operation->sha_ctx, sizeof(esp_sha1_context));
esp_sha1_driver_clone(source_operation->sha_ctx, target_operation->sha_ctx);
} else
#endif // CONFIG_SOC_SHA_SUPPORT_SHA1
#if CONFIG_SOC_SHA_SUPPORT_SHA224 || CONFIG_SOC_SHA_SUPPORT_SHA256
@@ -263,7 +291,7 @@ psa_status_t esp_sha_hash_clone(
if (!target_operation->sha_ctx) {
return PSA_ERROR_INSUFFICIENT_MEMORY;
}
memcpy(target_operation->sha_ctx, source_operation->sha_ctx, sizeof(esp_sha256_context));
esp_sha256_driver_clone(source_operation->sha_ctx, target_operation->sha_ctx);
} else
#endif // CONFIG_SOC_SHA_SUPPORT_SHA224 || CONFIG_SOC_SHA_SUPPORT_SHA256
#if CONFIG_SOC_SHA_SUPPORT_SHA384 || CONFIG_SOC_SHA_SUPPORT_SHA512
@@ -273,7 +301,7 @@ psa_status_t esp_sha_hash_clone(
if (!target_operation->sha_ctx) {
return PSA_ERROR_INSUFFICIENT_MEMORY;
}
memcpy(target_operation->sha_ctx, source_operation->sha_ctx, sizeof(esp_sha512_context));
esp_sha512_driver_clone(source_operation->sha_ctx, target_operation->sha_ctx);
} else
#endif // CONFIG_SOC_SHA_SUPPORT_SHA384 || CONFIG_SOC_SHA_SUPPORT_SHA512
{
components/mbedtls/port/psa_driver/include/psa_crypto_driver_esp_sha_contexts.h
+17
View File
@@ -21,6 +21,7 @@
#include <stdint.h>
#include <stdbool.h>
#include "sdkconfig.h"
#if defined(ESP_SHA_DRIVER_ENABLED)
@@ -50,6 +51,13 @@ typedef enum {
ESP_SHA512_STATE_IN_PROCESS
} esp_sha512_state;
#if CONFIG_SOC_SHA_SUPPORT_PARALLEL_ENG
typedef enum {
ESP_SHA_MODE_SOFTWARE,
ESP_SHA_MODE_HARDWARE
} esp_sha_mode_t;
#endif /* CONFIG_SOC_SHA_SUPPORT_PARALLEL_ENG */
/**
* \brief ESP SHA1 context structure
*/
@@ -59,6 +67,9 @@ typedef struct {
unsigned char buffer[64]; /*!< The data block being processed. */
bool first_block; /*!< First block flag for hardware initialization */
int sha_state; /*!< SHA operation state */
#if CONFIG_SOC_SHA_SUPPORT_PARALLEL_ENG
esp_sha_mode_t operation_mode; /*!< Hardware or Software mode */
#endif /* CONFIG_SOC_SHA_SUPPORT_PARALLEL_ENG */
} esp_sha1_context;
/**
@@ -71,6 +82,9 @@ typedef struct {
bool first_block; /*!< First block flag for hardware initialization */
int sha_state; /*!< SHA operation state */
int mode; /*!< SHA2_224 or SHA2_256 */
#if CONFIG_SOC_SHA_SUPPORT_PARALLEL_ENG
esp_sha_mode_t operation_mode; /*!< Hardware or Software mode */
#endif /* CONFIG_SOC_SHA_SUPPORT_PARALLEL_ENG */
} esp_sha256_context;
/**
@@ -85,6 +99,9 @@ typedef struct {
int sha_state;
int mode;
uint32_t t_val; /*!< t_val for 512/t mode */
#if CONFIG_SOC_SHA_SUPPORT_PARALLEL_ENG
esp_sha_mode_t operation_mode; /*!< Hardware or Software mode */
#endif /* CONFIG_SOC_SHA_SUPPORT_PARALLEL_ENG */
} esp_sha512_context;
typedef void *esp_sha_context_t;
components/mbedtls/test_apps/main/CMakeLists.txt
+2 -2
View File
@@ -6,8 +6,8 @@ set(TEST_CRTS "crts/server_cert_chain.pem"
"crts/correct_sig_crt_esp32_com.pem")
idf_component_register(
# SRC_DIRS "."
SRCS "app_main.c" "test_sha.c" "test_sha_perf.c" "test_mbedtls_utils.c"
SRC_DIRS "."
# SRCS "app_main.c" "test_sha.c" "test_sha_perf.c" "test_mbedtls_utils.c"
PRIV_INCLUDE_DIRS "."
PRIV_REQUIRES efuse cmock test_utils mbedtls esp_timer unity spi_flash esp_psram esp_security
EMBED_TXTFILES ${TEST_CRTS}
components/mbedtls/test_apps/main/test_aes_perf.c
+8 -6
View File
@@ -25,10 +25,10 @@ TEST_CASE("mbedtls AES performance", "[aes][timeout=60]")
uint8_t iv[16];
uint8_t key[16];
psa_status_t status = psa_crypto_init();
if (status != PSA_SUCCESS) {
TEST_FAIL_MESSAGE("PSA crypto initialization failed");
}
psa_status_t status = PSA_SUCCESS;
// if (status != PSA_SUCCESS) {
// TEST_FAIL_MESSAGE("PSA crypto initialization failed");
// }
memset(iv, 0xEE, 16);
memset(key, 0x44, 16);
@@ -41,14 +41,16 @@ TEST_CASE("mbedtls AES performance", "[aes][timeout=60]")
psa_set_key_usage_flags(&attributes, PSA_KEY_USAGE_ENCRYPT | PSA_KEY_USAGE_DECRYPT);
psa_set_key_algorithm(&attributes, PSA_ALG_CBC_NO_PADDING);
psa_set_key_type(&attributes, PSA_KEY_TYPE_AES);
psa_set_key_bits(&attributes, 128);
status = psa_import_key(&attributes, key, sizeof(key), &key_id);
if (status != PSA_SUCCESS) {
TEST_FAIL_MESSAGE("Failed to import key");
}
psa_cipher_operation_t operation = psa_cipher_operation_init();
psa_cipher_operation_t operation = PSA_CIPHER_OPERATION_INIT;
status = psa_cipher_encrypt_setup(&operation, key_id, PSA_ALG_CBC_NO_PADDING);
if (status != PSA_SUCCESS) {
printf("Failed to setup AES encryption with status: %ld\n", status);
TEST_FAIL_MESSAGE("Failed to setup AES encryption");
}
@@ -91,7 +93,7 @@ TEST_CASE("mbedtls AES performance", "[aes][timeout=60]")
psa_reset_key_attributes(&attributes);
free(buf);
mbedtls_psa_crypto_free();
// mbedtls_psa_crypto_free();
// bytes/usec = MB/sec
float mb_sec = (CALL_SZ * CALLS) / elapsed_usec;
components/mbedtls/test_apps/main/test_aes_sha_parallel.c
+12 -9
View File
@@ -1,5 +1,5 @@
/*
* SPDX-FileCopyrightText: 2021-2024 Espressif Systems (Shanghai) CO LTD
* SPDX-FileCopyrightText: 2021-2025 Espressif Systems (Shanghai) CO LTD
*
* SPDX-License-Identifier: Apache-2.0
*/
@@ -16,6 +16,7 @@
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "freertos/semphr.h"
#include "psa/crypto.h"
static SemaphoreHandle_t done_sem;
@@ -28,18 +29,20 @@ static const uint8_t sha256_thousand_bs[32] = {
static void tskRunSHA256Test(void *pvParameters)
{
mbedtls_sha256_context sha256_ctx;
unsigned char sha256[32];
psa_hash_operation_t operation = PSA_HASH_OPERATION_INIT;
psa_status_t status;
size_t hash_length = 0;
for (int i = 0; i < 1000; i++) {
mbedtls_sha256_init(&sha256_ctx);
TEST_ASSERT_EQUAL(0, mbedtls_sha256_starts(&sha256_ctx, false));
status = psa_hash_setup(&operation, PSA_ALG_SHA_256);
TEST_ASSERT_EQUAL(PSA_SUCCESS, status);
for (int j = 0; j < 10; j++) {
TEST_ASSERT_EQUAL(0, mbedtls_sha256_update(&sha256_ctx, (unsigned char *)one_hundred_bs, 100));
status = psa_hash_update(&operation, (unsigned char *)one_hundred_bs, 100);
TEST_ASSERT_EQUAL(PSA_SUCCESS, status);
}
TEST_ASSERT_EQUAL(0, mbedtls_sha256_finish(&sha256_ctx, sha256));
mbedtls_sha256_free(&sha256_ctx);
status = psa_hash_finish(&operation, sha256, sizeof(sha256), &hash_length);
operation = psa_hash_operation_init();
TEST_ASSERT_EQUAL(PSA_SUCCESS, status);
TEST_ASSERT_EQUAL_MEMORY_MESSAGE(sha256_thousand_bs, sha256, 32, "SHA256 calculation");
}
xSemaphoreGive(done_sem);
components/mbedtls/test_apps/main/test_aes_sha_rsa.c
+26 -10
View File
@@ -1,5 +1,5 @@
/*
* SPDX-FileCopyrightText: 2021-2022 Espressif Systems (Shanghai) CO LTD
* SPDX-FileCopyrightText: 2021-2025 Espressif Systems (Shanghai) CO LTD
*
* SPDX-License-Identifier: Apache-2.0
*/
@@ -25,6 +25,7 @@
#include "aes/esp_aes.h"
#include "mbedtls/rsa.h"
#include "mbedtls/sha256.h"
#include "psa/crypto.h"
static const char *TAG = "test";
static volatile bool exit_flag = false;
@@ -75,27 +76,42 @@ static void mbedtls_sha256_task(void *pvParameters)
SemaphoreHandle_t *sema = (SemaphoreHandle_t *) pvParameters;
ESP_LOGI(TAG, "mbedtls_sha256_task is started");
const char *input = "@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_abcdefghijklmnopqrstuvwxyz~DEL0123456789Space!#$%&()*+,-.0123456789:;<=>?";
mbedtls_sha256_context sha256_ctx;
// mbedtls_sha256_context sha256_ctx;
unsigned char output[32];
unsigned char output_origin[32];
mbedtls_sha256_init(&sha256_ctx);
psa_hash_operation_t sha256_op = PSA_HASH_OPERATION_INIT;
psa_status_t status = psa_hash_setup(&sha256_op, PSA_ALG_SHA_256);
TEST_ASSERT_EQUAL(PSA_SUCCESS, status);
// mbedtls_sha256_init(&sha256_ctx);
memset(output, 0, sizeof(output));
mbedtls_sha256_starts(&sha256_ctx, false);
// mbedtls_sha256_starts(&sha256_ctx, false);
for (int i = 0; i < 3; ++i) {
mbedtls_sha256_update(&sha256_ctx, (unsigned char *)input, 100);
// mbedtls_sha256_update(&sha256_ctx, (unsigned char *)input, 100);
status = psa_hash_update(&sha256_op, (const uint8_t *)input, 100);
TEST_ASSERT_EQUAL(PSA_SUCCESS, status);
}
mbedtls_sha256_finish(&sha256_ctx, output);
// mbedtls_sha256_finish(&sha256_ctx, output);
size_t hash_length = 0;
status = psa_hash_finish(&sha256_op, output, sizeof(output), &hash_length);
TEST_ASSERT_EQUAL(PSA_SUCCESS, status);
memcpy(output_origin, output, sizeof(output));
while (exit_flag == false) {
mbedtls_sha256_init(&sha256_ctx);
// mbedtls_sha256_init(&sha256_ctx);
psa_hash_operation_t sha256_operation = PSA_HASH_OPERATION_INIT;
status = psa_hash_setup(&sha256_operation, PSA_ALG_SHA_256);
TEST_ASSERT_EQUAL(PSA_SUCCESS, status);
memset(output, 0, sizeof(output));
mbedtls_sha256_starts(&sha256_ctx, false);
// mbedtls_sha256_starts(&sha256_ctx, false);
for (int i = 0; i < 3; ++i) {
mbedtls_sha256_update(&sha256_ctx, (unsigned char *)input, 100);
// mbedtls_sha256_update(&sha256_ctx, (unsigned char *)input, 100);
status = psa_hash_update(&sha256_operation, (const uint8_t *)input, 100);
TEST_ASSERT_EQUAL(PSA_SUCCESS, status);
}
mbedtls_sha256_finish(&sha256_ctx, output);
status = psa_hash_finish(&sha256_operation, output, sizeof(output), &hash_length);
TEST_ASSERT_EQUAL(PSA_SUCCESS, status);
// mbedtls_sha256_finish(&sha256_ctx, output);
TEST_ASSERT_EQUAL_MEMORY_MESSAGE(output, output_origin, sizeof(output), "MBEDTLS SHA256 must match");
}
components/mbedtls/test_apps/main/test_ecp.c
+28 -13
View File
@@ -18,6 +18,7 @@
#include <mbedtls/ecdh.h>
#include <mbedtls/ecdsa.h>
#include <mbedtls/error.h>
#include "psa/crypto.h"
#include "test_utils.h"
#include "ccomp_timer.h"
@@ -54,24 +55,38 @@
TEST_CASE("mbedtls ECDH Generate Key", "[mbedtls]")
{
mbedtls_ecdh_context ctx;
mbedtls_entropy_context entropy;
mbedtls_ctr_drbg_context ctr_drbg;
// mbedtls_ecdh_context ctx;
// mbedtls_entropy_context entropy;
// mbedtls_ctr_drbg_context ctr_drbg;
mbedtls_ecdh_init(&ctx);
mbedtls_ctr_drbg_init(&ctr_drbg);
// mbedtls_ecdh_init(&ctx);
// mbedtls_ctr_drbg_init(&ctr_drbg);
mbedtls_entropy_init(&entropy);
TEST_ASSERT_MBEDTLS_OK( mbedtls_ctr_drbg_seed(&ctr_drbg, mbedtls_entropy_func, &entropy, NULL, 0) );
// mbedtls_entropy_init(&entropy);
// TEST_ASSERT_MBEDTLS_OK( mbedtls_ctr_drbg_seed(&ctr_drbg, mbedtls_entropy_func, &entropy, NULL, 0) );
TEST_ASSERT_MBEDTLS_OK( mbedtls_ecp_group_load(ACCESS_ECDH(&ctx, grp), MBEDTLS_ECP_DP_CURVE25519) );
// TEST_ASSERT_MBEDTLS_OK( mbedtls_ecp_group_load(ACCESS_ECDH(&ctx, grp), MBEDTLS_ECP_DP_CURVE25519) );
TEST_ASSERT_MBEDTLS_OK( mbedtls_ecdh_gen_public(ACCESS_ECDH(&ctx, grp), ACCESS_ECDH(&ctx, d), ACCESS_ECDH(&ctx, Q),
mbedtls_ctr_drbg_random, &ctr_drbg ) );
// TEST_ASSERT_MBEDTLS_OK( mbedtls_ecdh_gen_public(ACCESS_ECDH(&ctx, grp), ACCESS_ECDH(&ctx, d), ACCESS_ECDH(&ctx, Q),
// mbedtls_psa_get_random, MBEDTLS_PSA_RANDOM_STATE ) );
mbedtls_ecdh_free(&ctx);
mbedtls_ctr_drbg_free(&ctr_drbg);
mbedtls_entropy_free(&entropy);
// mbedtls_ecdh_free(&ctx);
// mbedtls_ctr_drbg_free(&ctr_drbg);
// mbedtls_entropy_free(&entropy);
psa_key_attributes_t key_attributes;
psa_key_id_t key_id;
psa_set_key_type(&key_attributes, PSA_KEY_TYPE_ECC_KEY_PAIR(PSA_ECC_FAMILY_MONTGOMERY));
psa_set_key_usage_flags(&key_attributes, PSA_KEY_USAGE_DERIVE);
psa_set_key_bits(&key_attributes, 255);
psa_set_key_lifetime(&key_attributes, PSA_KEY_LIFETIME_VOLATILE);
psa_set_key_algorithm(&key_attributes, PSA_ALG_ECDH);
psa_status_t status = psa_generate_key(&key_attributes, &key_id);
TEST_ASSERT_EQUAL(PSA_SUCCESS, status);
psa_reset_key_attributes(&key_attributes);
psa_destroy_key(key_id);
}
TEST_CASE("mbedtls ECP self-tests", "[mbedtls]")
components/mbedtls/test_apps/main/test_esp_crt_bundle.c
+5 -2
View File
@@ -310,8 +310,11 @@ void client_task(void *pvParameters)
mbedtls_net_free( &client->client_fd);
/* Test with bundle that does contain the CA crt */
esp_crt_bundle_attach(&client->conf);
esp_crt_bundle_set(server_cert_bundle_start, server_cert_bundle_end - server_cert_bundle_start);
ret = esp_crt_bundle_attach(&client->conf);
TEST_ASSERT_EQUAL(ESP_OK, ret);
ret = esp_crt_bundle_set(server_cert_bundle_start, server_cert_bundle_end - server_cert_bundle_start);
TEST_ASSERT_EQUAL(ESP_OK, ret);
ESP_LOGI(TAG, "Connecting to %s:%s...", SERVER_ADDRESS, SERVER_PORT);
if ((ret = mbedtls_net_connect(&client->client_fd, SERVER_ADDRESS, SERVER_PORT, MBEDTLS_NET_PROTO_TCP)) != 0) {
components/mbedtls/test_apps/main/test_mbedtls_sha.c
+5 -1
View File
@@ -24,6 +24,7 @@
#include "soc/soc_caps.h"
#include "test_utils.h"
#include "esp_memory_utils.h"
#if 0
TEST_CASE("mbedtls SHA self-tests", "[mbedtls]")
{
@@ -31,7 +32,9 @@ TEST_CASE("mbedtls SHA self-tests", "[mbedtls]")
#if CONFIG_MBEDTLS_SHA1_C
TEST_ASSERT_FALSE_MESSAGE(mbedtls_sha1_self_test(1), "SHA1 self-tests should pass.");
#endif
TEST_ASSERT_FALSE_MESSAGE(mbedtls_sha256_self_test(1), "SHA256 self-tests should pass.");
#if CONFIG_MBEDTLS_SHA256_C
// TEST_ASSERT_FALSE_MESSAGE(mbedtls_sha256_self_test(1), "SHA256 self-tests should pass.");
#endif
#if CONFIG_MBEDTLS_SHA512_C
TEST_ASSERT_FALSE_MESSAGE(mbedtls_sha512_self_test(1), "SHA512 self-tests should pass.");
#endif
@@ -618,3 +621,4 @@ TEST_CASE("mbedtls SHA stack in PSRAM", "[mbedtls]")
}
#endif //CONFIG_FREERTOS_TASK_CREATE_ALLOW_EXT_MEM && CONFIG_SPIRAM_USE_MALLOC
#endif // 0
components/mbedtls/test_apps/main/test_psa_aes.c
+7 -7
View File
@@ -102,7 +102,7 @@ TEST_CASE("PSA AES-CTR multipart", "[psa-aes]")
/* Destroy the key */
psa_destroy_key(key_id);
mbedtls_psa_crypto_free();
// mbedtls_psa_crypto_free();
}
TEST_CASE("PSA AES-ECB multipart", "[psa-aes]")
@@ -180,7 +180,7 @@ TEST_CASE("PSA AES-ECB multipart", "[psa-aes]")
/* Destroy the key */
psa_destroy_key(key_id);
mbedtls_psa_crypto_free();
// // mbedtls_psa_crypto_free();
}
TEST_CASE("PSA AES-CBC multipart", "[psa-aes]")
@@ -261,7 +261,7 @@ TEST_CASE("PSA AES-CBC multipart", "[psa-aes]")
/* Destroy the key */
psa_destroy_key(key_id);
mbedtls_psa_crypto_free();
// mbedtls_psa_crypto_free();
}
#if 0
@@ -411,7 +411,7 @@ TEST_CASE("PSA AES-CBC-PKCS7 multipart", "[psa-aes]")
free(decryptedtext2);
psa_destroy_key(key_id);
mbedtls_psa_crypto_free();
// mbedtls_psa_crypto_free();
}
#endif
@@ -492,7 +492,7 @@ TEST_CASE("PSA AES-CFB multipart", "[psa-aes]")
/* Destroy the key */
psa_destroy_key(key_id);
mbedtls_psa_crypto_free();
// mbedtls_psa_crypto_free();
}
TEST_CASE("PSA AES-OFB multipart", "[psa-aes]")
@@ -572,7 +572,7 @@ TEST_CASE("PSA AES-OFB multipart", "[psa-aes]")
/* Destroy the key */
psa_destroy_key(key_id);
mbedtls_psa_crypto_free();
// mbedtls_psa_crypto_free();
}
@@ -628,5 +628,5 @@ TEST_CASE("PSA AES-CBC one-shot", "[psa-aes]")
/* Destroy the key */
psa_destroy_key(key_id);
mbedtls_psa_crypto_free();
// mbedtls_psa_crypto_free();
}
components/mbedtls/test_apps/main/test_psa_aes_gcm.c
+2 -2
View File
@@ -131,7 +131,7 @@ TEST_CASE("PSA AES-GCM multipart", "[psa-aes-gcm]")
/* Destroy the key */
psa_destroy_key(key_id);
mbedtls_psa_crypto_free();
// mbedtls_psa_crypto_free();
}
TEST_CASE("PSA AES-GCM one-shot", "[psa-aes-gcm]")
@@ -208,5 +208,5 @@ TEST_CASE("PSA AES-GCM one-shot", "[psa-aes-gcm]")
/* Destroy the key */
psa_destroy_key(key_id);
mbedtls_psa_crypto_free();
// mbedtls_psa_crypto_free();
}
components/mbedtls/test_apps/main/test_psa_cmac.c
+7 -7
View File
@@ -104,7 +104,7 @@ TEST_CASE("PSA CMAC AES-128 test", "[psa_cmac]")
// Cleanup
psa_destroy_key(key_id);
free(cmac);
mbedtls_psa_crypto_free();
// mbedtls_psa_crypto_free();
}
TEST_CASE("PSA CMAC AES-256 test", "[psa_cmac]")
@@ -152,7 +152,7 @@ TEST_CASE("PSA CMAC AES-256 test", "[psa_cmac]")
// Cleanup
psa_destroy_key(key_id);
free(cmac);
mbedtls_psa_crypto_free();
// mbedtls_psa_crypto_free();
}
TEST_CASE("PSA CMAC AES-128 multipart test", "[psa_cmac]")
@@ -209,7 +209,7 @@ TEST_CASE("PSA CMAC AES-128 multipart test", "[psa_cmac]")
// Cleanup
psa_destroy_key(key_id);
free(cmac);
mbedtls_psa_crypto_free();
// mbedtls_psa_crypto_free();
}
TEST_CASE("PSA CMAC AES-128 multipart verify test", "[psa_cmac]")
@@ -273,7 +273,7 @@ TEST_CASE("PSA CMAC AES-128 multipart verify test", "[psa_cmac]")
// Cleanup
psa_destroy_key(key_id);
free(cmac);
mbedtls_psa_crypto_free();
// mbedtls_psa_crypto_free();
}
TEST_CASE("PSA CMAC zero-length test", "[psa_cmac]")
@@ -321,7 +321,7 @@ TEST_CASE("PSA CMAC zero-length test", "[psa_cmac]")
// Cleanup
psa_destroy_key(key_id);
free(cmac);
mbedtls_psa_crypto_free();
// mbedtls_psa_crypto_free();
}
TEST_CASE("PSA CMAC memory alignment test", "[psa_cmac]")
@@ -379,7 +379,7 @@ TEST_CASE("PSA CMAC memory alignment test", "[psa_cmac]")
psa_destroy_key(key_id);
free(cmac_internal);
free(cmac_dma);
mbedtls_psa_crypto_free();
// mbedtls_psa_crypto_free();
}
TEST_CASE("PSA CMAC verify failure test", "[psa_cmac]")
@@ -421,6 +421,6 @@ TEST_CASE("PSA CMAC verify failure test", "[psa_cmac]")
// Cleanup
psa_destroy_key(key_id);
mbedtls_psa_crypto_free();
// mbedtls_psa_crypto_free();
}
#endif /* CONFIG_MBEDTLS_CMAC_C */
components/mbedtls/test_apps/main/test_psa_gcm.c
+2 -2
View File
@@ -129,7 +129,7 @@ TEST_CASE("PSA ARIA-GCM multipart", "[psa-gcm]")
/* Destroy the key */
psa_destroy_key(key_id);
mbedtls_psa_crypto_free();
// mbedtls_psa_crypto_free();
}
TEST_CASE("PSA ARIA-GCM one-shot", "[psa-gcm]")
@@ -206,5 +206,5 @@ TEST_CASE("PSA ARIA-GCM one-shot", "[psa-gcm]")
/* Destroy the key */
psa_destroy_key(key_id);
mbedtls_psa_crypto_free();
// mbedtls_psa_crypto_free();
}
components/mbedtls/test_apps/main/test_rsa.c
+45 -44
View File
@@ -336,7 +336,7 @@ _Static_assert(sizeof(pki_rsa2048_output) == 2048/8, "rsa2048 output is wrong si
_Static_assert(sizeof(pki_rsa3072_output) == 3072/8, "rsa3072 output is wrong size");
_Static_assert(sizeof(pki_rsa4096_output) == 4096/8, "rsa4096 output is wrong size");
void mbedtls_mpi_printf(const char *name, const mbedtls_mpi *X);
// void mbedtls_mpi_printf(const char *name, const mbedtls_mpi *X);
static void test_cert(const char *cert, const uint8_t *expected_output, size_t output_len);
@@ -418,22 +418,22 @@ static void rsa_key_operations(int keysize, bool check_performance, bool generat
// return mbedtls_hardware_poll(rng_state, output, len, &olen);
// }
// #ifdef PRINT_DEBUG_INFO
// static void print_rsa_details(mbedtls_rsa_context *rsa)
// {
// mbedtls_mpi X[5];
// for (int i=0; i<5; ++i) {
// mbedtls_mpi_init( &X[i] );
// }
#ifdef PRINT_DEBUG_INFO
static void print_rsa_details(mbedtls_rsa_context *rsa)
{
mbedtls_mpi X[5];
for (int i=0; i<5; ++i) {
mbedtls_mpi_init( &X[i] );
}
// if (0 == mbedtls_rsa_export(rsa, &X[0], &X[1], &X[2], &X[3], &X[4])) {
// for (int i=0; i<5; ++i) {
// mbedtls_mpi_printf((char*)"N\0P\0Q\0D\0E" + 2*i, &X[i]);
// mbedtls_mpi_free( &X[i] );
// }
// }
// }
// #endif
if (0 == mbedtls_rsa_export(rsa, &X[0], &X[1], &X[2], &X[3], &X[4])) {
for (int i=0; i<5; ++i) {
// mbedtls_mpi_printf((char*)"N\0P\0Q\0D\0E" + 2*i, &X[i]);
mbedtls_mpi_free( &X[i] );
}
}
}
#endif
#if CONFIG_FREERTOS_SMP // IDF-5260
TEST_CASE("test performance RSA key operations", "[bignum][timeout=60]")
@@ -528,18 +528,18 @@ static void rsa_key_operations(int keysize, bool check_performance, bool generat
memcpy(&rsa, mbedtls_pk_rsa(clientkey), sizeof(mbedtls_rsa_context));
}
// #ifdef PRINT_DEBUG_INFO
// print_rsa_details(&rsa);
// #endif
#ifdef PRINT_DEBUG_INFO
print_rsa_details(&rsa);
#endif
TEST_ASSERT_EQUAL(keysize, (int)rsa.MBEDTLS_PRIVATE(len) * 8);
TEST_ASSERT_EQUAL(keysize, (int)rsa.MBEDTLS_PRIVATE(D).MBEDTLS_PRIVATE(n) * sizeof(mbedtls_mpi_uint) * 8); // The private exponent
#ifdef SOC_CCOMP_TIMER_SUPPORTED
// int public_perf, private_perf;
int public_perf, private_perf;
ccomp_timer_start();
res = mbedtls_rsa_public(&rsa, orig_buf, encrypted_buf);
// public_perf = ccomp_timer_stop();
public_perf = ccomp_timer_stop();
if (res == MBEDTLS_ERR_MPI_NOT_ACCEPTABLE + MBEDTLS_ERR_RSA_PUBLIC_FAILED) {
mbedtls_rsa_free(&rsa);
@@ -549,17 +549,17 @@ static void rsa_key_operations(int keysize, bool check_performance, bool generat
ccomp_timer_start();
res = mbedtls_rsa_private(&rsa, mbedtls_psa_get_random, MBEDTLS_PSA_RANDOM_STATE, encrypted_buf, decrypted_buf);
// private_perf = ccomp_timer_stop();
private_perf = ccomp_timer_stop();
TEST_ASSERT_EQUAL_HEX16(0, -res);
// We will bring this check back once we have the hardware acceleration with PSA
// if (check_performance && keysize == 2048) {
// TEST_PERFORMANCE_CCOMP_LESS_THAN(RSA_2048KEY_PUBLIC_OP, "%d us", public_perf);
// TEST_PERFORMANCE_CCOMP_LESS_THAN(RSA_2048KEY_PRIVATE_OP, "%d us", private_perf);
// } else if (check_performance && keysize == 4096) {
// TEST_PERFORMANCE_CCOMP_LESS_THAN(RSA_4096KEY_PUBLIC_OP, "%d us", public_perf);
// TEST_PERFORMANCE_CCOMP_LESS_THAN(RSA_4096KEY_PRIVATE_OP, "%d us", private_perf);
// }
if (check_performance && keysize == 2048) {
TEST_PERFORMANCE_CCOMP_LESS_THAN(RSA_2048KEY_PUBLIC_OP, "%d us", public_perf);
TEST_PERFORMANCE_CCOMP_LESS_THAN(RSA_2048KEY_PRIVATE_OP, "%d us", private_perf);
} else if (check_performance && keysize == 4096) {
TEST_PERFORMANCE_CCOMP_LESS_THAN(RSA_4096KEY_PUBLIC_OP, "%d us", public_perf);
TEST_PERFORMANCE_CCOMP_LESS_THAN(RSA_4096KEY_PRIVATE_OP, "%d us", private_perf);
}
#else
res = mbedtls_rsa_public(&rsa, orig_buf, encrypted_buf);
TEST_ASSERT_EQUAL_HEX16(0, -res);
@@ -574,24 +574,25 @@ static void rsa_key_operations(int keysize, bool check_performance, bool generat
}
// We will bring this check back once we have the hardware acceleration with PSA
// TEST_CASE("mbedtls RSA Generate Key", "[mbedtls][timeout=60]")
// {
// psa_status_t status;
// psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
// psa_key_id_t key_id;
TEST_CASE("mbedtls RSA Generate Key", "[mbedtls][timeout=60]")
{
psa_status_t status;
psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
psa_key_id_t key_id;
// psa_set_key_type(&attributes, PSA_KEY_TYPE_RSA_KEY_PAIR);
// psa_set_key_bits(&attributes, 2048);
// psa_set_key_usage_flags(&attributes, PSA_KEY_USAGE_ENCRYPT | PSA_KEY_USAGE_DECRYPT);
// psa_set_key_lifetime(&attributes, PSA_KEY_LIFETIME_VOLATILE);
psa_set_key_type(&attributes, PSA_KEY_TYPE_RSA_KEY_PAIR);
psa_set_key_bits(&attributes, 2048);
psa_set_key_usage_flags(&attributes, PSA_KEY_USAGE_ENCRYPT | PSA_KEY_USAGE_DECRYPT);
psa_set_key_lifetime(&attributes, PSA_KEY_LIFETIME_VOLATILE);
// status = psa_generate_key(&attributes, &key_id);
// TEST_ASSERT_EQUAL_HEX(status, PSA_SUCCESS);
status = psa_generate_key(&attributes, &key_id);
printf("Status: %ld\n", status);
TEST_ASSERT_EQUAL_HEX(status, PSA_SUCCESS);
// psa_reset_key_attributes(&attributes);
psa_reset_key_attributes(&attributes);
// status = psa_destroy_key(key_id);
// TEST_ASSERT_EQUAL_HEX(status, PSA_SUCCESS);
// }
status = psa_destroy_key(key_id);
TEST_ASSERT_EQUAL_HEX(status, PSA_SUCCESS);
}
#endif // CONFIG_MBEDTLS_HARDWARE_MPI
components/mbedtls/test_apps/main/test_sha.c
+3
View File
@@ -28,6 +28,8 @@
#include "sha/sha_parallel_engine.h"
#if MBEDTLS_MAJOR_VERSION < 4
/* Note: Most of the SHA functions are called as part of mbedTLS, so
are tested as part of mbedTLS tests. Only esp_sha() is different.
*/
@@ -273,3 +275,4 @@ TEST_CASE("Test esp_sha() function with long input", "[hw_crypto]")
#endif
#endif // SOC_SHA_SUPPORTED
#endif // MBEDTLS_MAJOR_VERSION
components/mbedtls/test_apps/sdkconfig.defaults
+1
View File
@@ -9,3 +9,4 @@ CONFIG_COMPILER_STACK_CHECK=y
CONFIG_ESP_TASK_WDT_EN=y
CONFIG_ESP_TASK_WDT_INIT=n
CONFIG_COMPILER_OPTIMIZATION_PERF=y
CONFIG_MBEDTLS_COMPILER_OPTIMIZATION_PERF=y
components/wpa_supplicant/esp_supplicant/src/crypto/crypto_mbedtls-ec.c
-10
View File
@@ -912,11 +912,6 @@ int crypto_ec_get_publickey_buf(struct crypto_ec_key *key, u8 *key_buf, int len)
int crypto_write_pubkey_der(struct crypto_ec_key *key, unsigned char **key_buf)
{
psa_status_t status = psa_crypto_init();
if (status != PSA_SUCCESS) {
return -1;
}
unsigned char *buf = os_malloc(ECP_PUB_DER_MAX_BYTES);
if (!buf) {
wpa_printf(MSG_ERROR, "memory allocation failed");
@@ -971,11 +966,6 @@ struct crypto_ec_key *crypto_ec_key_parse_priv(const u8 *privkey, size_t privkey
* mbedtls_pk_parse_key() to parse the private key and then import it into PSA.
*/
psa_status_t status = psa_crypto_init();
if (status != PSA_SUCCESS) {
return NULL;
}
int ret;
mbedtls_pk_context *kctx = (mbedtls_pk_context *)crypto_alloc_key();
psa_key_id_t *key_id = os_calloc(1, sizeof(psa_key_id_t));
components/wpa_supplicant/esp_supplicant/src/crypto/fastpbkdf2.c
+7 -7
View File
@@ -410,6 +410,13 @@ void fastpbkdf2_hmac_sha1(const uint8_t *pw, size_t npw,
goto cleanup;
}
// Set iteration count
status = psa_key_derivation_input_integer(&operation, PSA_KEY_DERIVATION_INPUT_COST,
iterations);
if (status != PSA_SUCCESS) {
goto cleanup;
}
// Add salt
status = psa_key_derivation_input_bytes(&operation, PSA_KEY_DERIVATION_INPUT_SALT,
salt, nsalt);
@@ -423,13 +430,6 @@ void fastpbkdf2_hmac_sha1(const uint8_t *pw, size_t npw,
goto cleanup;
}
// Set iteration count
status = psa_key_derivation_input_integer(&operation, PSA_KEY_DERIVATION_INPUT_COST,
iterations);
if (status != PSA_SUCCESS) {
goto cleanup;
}
// Generate output
status = psa_key_derivation_output_bytes(&operation, out, nout);