espressif/esp-idf
1
0
Fork 0
mirror of https://github.com/espressif/esp-idf.git synced 2026-04-27 19:13:21 +00:00
Code Issues Packages Projects Releases Wiki Activity

Merge branch 'fix/recursion_caused_due_to_unaligned_ext_mem_buf_v6.0' into 'release/v6.0'

Browse Source 
AES driver should use internal buffers to perform chunk wise operations when external buffers are unaligned (v6.0)

See merge request espressif/esp-idf!43897
This commit is contained in:
Mahavir Jain
2025-12-14 18:48:13 +05:30
parent 062d70efcc c2dffd77fa
commit 6fb5705832
8 changed files with 616 additions and 157 deletions
Download Patch File Download Diff File Expand all files Collapse all files
components/mbedtls/port/aes/dma/esp_aes_dma_core.c
+29 -12
View File
@@ -217,13 +217,20 @@ static inline size_t get_cache_line_size(const void *addr)
return (size_t)cache_hal_get_cache_line_size(cache_level, CACHE_TYPE_DATA);
}
/* Output buffers in external ram needs to be 16-byte aligned and DMA can't access input in the iCache mem range,
reallocate them into internal memory and encrypt in chunks to avoid
having to malloc too big of a buffer
The function esp_aes_process_dma_ext_ram zeroises the output buffer in the case of memory allocation failure.
*/
/**
* @brief Output buffers located in external RAM must be aligned to dcache_line_size, and DMA cannot access input data residing in the iCache memory range.
* To accommodate this issues, we reallocate them into internal memory and process the AES operation in chunks, avoiding large single-block allocations.
*
* In the case of ESP32-P4, internal memory is also cacheable, so using internal RAM does not bypass the buffer-alignment requirement; the cache still enforces aligned
* memory-to-cache (M2C) operations. Therefore, to safely perform an M2C sync on an unaligned buffer, we must ALIGN_UP the output buffer to the nearest cache line
* regardless of whether the output buffer resides in internal or external memory.
* (The ESP32-P4 AES driver already performs cache-to-memory (C2M) operations on the output buffer using the aligned-up length, which prevents the corruption that could
* otherwise occur when extra cache-line bytes need to be included during an aligned-up M2C operation.).
*
* Thus, for ESP32-P4, we reallocate the buffers into cache-line-size aligned external memory addresses itself, and use the above strategy to perform the AES operation in chunks.
*
* @note The function esp_aes_process_dma_ext_ram zeroises the output buffer in the case of memory allocation failure.
*/
static int esp_aes_process_dma_ext_ram(esp_aes_context *ctx, const unsigned char *input, unsigned char *output, size_t len, uint8_t *stream_out, bool realloc_input, bool realloc_output)
{
size_t chunk_len;
@@ -240,8 +247,9 @@ static int esp_aes_process_dma_ext_ram(esp_aes_context *ctx, const unsigned char
size_t output_alignment = 1;
/* When AES-DMA operations are carried out using external memory with external memory encryption enabled,
we need to make sure that the addresses and the sizes of the buffers on which the DMA operates are 16 byte-aligned. */
#ifdef SOC_GDMA_EXT_MEM_ENC_ALIGNMENT
we need to make sure that the addresses and the sizes of the buffers on which the DMA operates are 16 byte-aligned.
This is only applicable for ESP32-P4, as other targets use internal memory for DMA operations. */
#if SOC_CACHE_INTERNAL_MEM_VIA_L1CACHE
if (efuse_hal_flash_encryption_enabled()) {
if (esp_ptr_external_ram(input) || esp_ptr_external_ram(output) || esp_ptr_in_drom(input) || esp_ptr_in_drom(output)) {
size_t input_cache_line_size = get_cache_line_size(input);
@@ -253,7 +261,7 @@ static int esp_aes_process_dma_ext_ram(esp_aes_context *ctx, const unsigned char
output_heap_caps = MALLOC_CAP_8BIT | (esp_ptr_external_ram(output) ? MALLOC_CAP_SPIRAM : MALLOC_CAP_DMA | MALLOC_CAP_INTERNAL);
}
}
#endif /* SOC_GDMA_EXT_MEM_ENC_ALIGNMENT */
#endif /* SOC_CACHE_INTERNAL_MEM_VIA_L1CACHE */
if (realloc_input) {
input_buf = heap_caps_aligned_alloc(input_alignment, chunk_len, input_heap_caps);
@@ -358,6 +366,8 @@ static inline esp_err_t dma_desc_link(crypto_dma_desc_t *dmadesc, size_t crypto_
dmadesc[i].next = ((i == crypto_dma_desc_num - 1) ? NULL : &dmadesc[i+1]);
#if SOC_CACHE_INTERNAL_MEM_VIA_L1CACHE
/* Write back both input buffers and output buffers to clear any cache dirty bit if set */
// Even output buffers are C2M synced here, because, while performing an aligned up M2C operation,
// extra bytes in the cache (len - ALIGN_UP(len)) might get corrupted if not C2M synced before.
ret = esp_cache_msync(dmadesc[i].buffer, ALIGN_UP(dmadesc[i].dw0.length, buffer_cache_line_size), ESP_CACHE_MSYNC_FLAG_DIR_C2M);
if (ret != ESP_OK) {
return ret;
@@ -646,6 +656,12 @@ int esp_aes_process_dma(esp_aes_context *ctx, const unsigned char *input, unsign
goto cleanup;
}
for (int i = 0; i < output_dma_desc_num; i++) {
// Align the output buffer to the cache line size before performing the M2C sync, because M2C sync cannot be performed on buffers with unaligned lengths.
// Note: This does not corrupt the extra bytes in the cache (len - ALIGN_UP(len)) because the ESP32-P4 AES driver already performs cache-to-memory (C2M)
// operations on the output buffer using the aligned-up length.
// But what if those extra bytes get updated (say by a different process) during the AES operation? Would the updated value be lost/corrupted?
// No, because the heap allocator would have already allocated a ALIGNED_UP buffer for the output buffer according to the alignment requirements,
// while allocating the output buffer (see esp_heap_adjust_alignment_to_hw()).
if (esp_cache_msync(output_desc[i].buffer, ALIGN_UP(output_desc[i].dw0.length, output_cache_line_size), ESP_CACHE_MSYNC_FLAG_DIR_M2C) != ESP_OK) {
ESP_LOGE(TAG, "Output DMA descriptor buffers cache sync M2C failed");
ret = -1;
@@ -1006,11 +1022,12 @@ int esp_aes_process_dma(esp_aes_context *ctx, const unsigned char *input, unsign
#if (CONFIG_SPIRAM && SOC_PSRAM_DMA_CAPABLE)
#ifdef SOC_GDMA_EXT_MEM_ENC_ALIGNMENT
if (efuse_hal_flash_encryption_enabled()) {
if (esp_ptr_external_ram(input) || esp_ptr_external_ram(output) || esp_ptr_in_drom(input) || esp_ptr_in_drom(output)) {
if (esp_ptr_external_ram(input) || esp_ptr_in_drom(input)) {
if (((intptr_t)(input) & (SOC_GDMA_EXT_MEM_ENC_ALIGNMENT - 1)) != 0) {
input_needs_realloc = true;
}
}
if (esp_ptr_external_ram(output) || esp_ptr_in_drom(output)) {
if (((intptr_t)(output) & (SOC_GDMA_EXT_MEM_ENC_ALIGNMENT - 1)) != 0) {
output_needs_realloc = true;
}
components/mbedtls/test_apps/.build-test-rules.yml
+1 -4
View File
@@ -6,11 +6,8 @@ components/mbedtls/test_apps:
- if: CONFIG_NAME == "psram_all_ext" and SOC_SPIRAM_SUPPORTED != 1
- if: CONFIG_NAME == "ecdsa_sign" and SOC_ECDSA_SUPPORTED != 1
- if: CONFIG_NAME == "psram_all_ext_flash_enc" and SOC_SPIRAM_SUPPORTED != 1
- if: IDF_TARGET == "esp32p4"
temporary: true
reason: p4 rev3 migration # TODO: IDF-14367
disable_test:
- if: CONFIG_NAME == "psram_all_ext_flash_enc" and IDF_TARGET not in ["esp32"]
- if: CONFIG_NAME == "psram_all_ext_flash_enc" and IDF_TARGET not in ["esp32", "esp32p4", "esp32c5"]
reason: lack of runners
depends_components:
- efuse
components/mbedtls/test_apps/README.md
+2 -2
View File
@@ -1,2 +1,2 @@
| Supported Targets | ESP32 | ESP32-C2 | ESP32-C3 | ESP32-C5 | ESP32-C6 | ESP32-C61 | ESP32-H2 | ESP32-H21 | ESP32-H4 | ESP32-S2 | ESP32-S3 |
| ----------------- | ----- | -------- | -------- | -------- | -------- | --------- | -------- | --------- | -------- | -------- | -------- |
| Supported Targets | ESP32 | ESP32-C2 | ESP32-C3 | ESP32-C5 | ESP32-C6 | ESP32-C61 | ESP32-H2 | ESP32-H21 | ESP32-H4 | ESP32-P4 | ESP32-S2 | ESP32-S3 |
| ----------------- | ----- | -------- | -------- | -------- | -------- | --------- | -------- | --------- | -------- | -------- | -------- | -------- |
components/mbedtls/test_apps/main/test_aes.c
+574 -84
View File
@@ -1,5 +1,5 @@
/*
* SPDX-FileCopyrightText: 2022-2024 Espressif Systems (Shanghai) CO LTD
* SPDX-FileCopyrightText: 2022-2025 Espressif Systems (Shanghai) CO LTD
*
* SPDX-License-Identifier: Unlicense OR CC0-1.0
*/
@@ -23,6 +23,18 @@
#include "esp_memory_utils.h"
#include "soc/lldesc.h"
#define INTERNAL_DMA_CAPS (MALLOC_CAP_8BIT | MALLOC_CAP_DMA | MALLOC_CAP_INTERNAL)
#define PSRAM_DMA_CAPS (MALLOC_CAP_8BIT | MALLOC_CAP_SPIRAM)
#define TEST_AES_CBC_DMA_MODE_LEN 1600
#define TEST_AES_CTR_DMA_MODE_LEN 1000
#define TEST_AES_OFB_DMA_MODE_LEN 1000
#define TEST_AES_CFB8_DMA_MODE_LEN 1000
#define TEST_AES_CFB128_DMA_MODE_LEN 1000
#define TEST_AES_CTR_STREAM_DMA_MODE_LEN 1000
#define TEST_AES_OFB_STREAM_DMA_MODE_LEN 1000
#define TEST_AES_CFB8_STREAM_DMA_MODE_LEN 1000
#define TEST_AES_CFB128_STREAM_DMA_MODE_LEN 1000
static const uint8_t key_256[] = {
0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
@@ -69,9 +81,9 @@ static const uint8_t iv[] = {
print("Ciphertext: {}".format(as_c_array(ct)))
*/
TEST_CASE("mbedtls CBC AES-256 test", "[aes]")
static void aes_cbc_test(unsigned int SZ)
{
const unsigned SZ = 1600;
mbedtls_aes_context ctx;
uint8_t nonce[16];
@@ -85,9 +97,9 @@ TEST_CASE("mbedtls CBC AES-256 test", "[aes]")
memcpy(nonce, iv, 16);
// allocate internal memory
uint8_t *ciphertext = heap_caps_malloc(SZ, MALLOC_CAP_8BIT|MALLOC_CAP_INTERNAL);
uint8_t *plaintext = heap_caps_malloc(SZ, MALLOC_CAP_8BIT|MALLOC_CAP_INTERNAL);
uint8_t *decryptedtext = heap_caps_malloc(SZ, MALLOC_CAP_8BIT|MALLOC_CAP_INTERNAL);
uint8_t *ciphertext = heap_caps_malloc(SZ, INTERNAL_DMA_CAPS);
uint8_t *plaintext = heap_caps_malloc(SZ, INTERNAL_DMA_CAPS);
uint8_t *decryptedtext = heap_caps_malloc(SZ, INTERNAL_DMA_CAPS);
TEST_ASSERT_NOT_NULL(ciphertext);
TEST_ASSERT_NOT_NULL(plaintext);
@@ -116,6 +128,11 @@ TEST_CASE("mbedtls CBC AES-256 test", "[aes]")
free(decryptedtext);
}
TEST_CASE("mbedtls CBC AES-256 test", "[aes]")
{
aes_cbc_test(TEST_AES_CBC_DMA_MODE_LEN);
}
TEST_CASE("mbedtls CBC AES-256 DMA buffer align test", "[aes]")
{
#define ALIGN_DOWN(val, align) ((val) & ~((align) - 1))
@@ -134,9 +151,9 @@ TEST_CASE("mbedtls CBC AES-256 DMA buffer align test", "[aes]")
memcpy(nonce, iv, 16);
// allocate internal memory
uint8_t *ciphertext = heap_caps_malloc(SZ, MALLOC_CAP_8BIT|MALLOC_CAP_INTERNAL);
uint8_t *plaintext = heap_caps_malloc(SZ, MALLOC_CAP_8BIT|MALLOC_CAP_INTERNAL);
uint8_t *decryptedtext = heap_caps_malloc(SZ, MALLOC_CAP_8BIT|MALLOC_CAP_INTERNAL);
uint8_t *ciphertext = heap_caps_malloc(SZ, INTERNAL_DMA_CAPS);
uint8_t *plaintext = heap_caps_malloc(SZ, INTERNAL_DMA_CAPS);
uint8_t *decryptedtext = heap_caps_malloc(SZ, INTERNAL_DMA_CAPS);
TEST_ASSERT_NOT_NULL(ciphertext);
TEST_ASSERT_NOT_NULL(plaintext);
@@ -165,9 +182,8 @@ TEST_CASE("mbedtls CBC AES-256 DMA buffer align test", "[aes]")
free(decryptedtext);
}
TEST_CASE("mbedtls CTR AES-256 test", "[aes]")
static void aes_ctr_test(unsigned int SZ)
{
const unsigned SZ = 1000;
mbedtls_aes_context ctx;
uint8_t nonce[16];
uint8_t stream_block[16];
@@ -183,9 +199,9 @@ TEST_CASE("mbedtls CTR AES-256 test", "[aes]")
memcpy(nonce, iv, 16);
// allocate internal memory
uint8_t *ciphertext = heap_caps_malloc(SZ, MALLOC_CAP_8BIT|MALLOC_CAP_INTERNAL);
uint8_t *plaintext = heap_caps_malloc(SZ, MALLOC_CAP_8BIT|MALLOC_CAP_INTERNAL);
uint8_t *decryptedtext = heap_caps_malloc(SZ, MALLOC_CAP_8BIT|MALLOC_CAP_INTERNAL);
uint8_t *ciphertext = heap_caps_malloc(SZ, INTERNAL_DMA_CAPS);
uint8_t *plaintext = heap_caps_malloc(SZ, INTERNAL_DMA_CAPS);
uint8_t *decryptedtext = heap_caps_malloc(SZ, INTERNAL_DMA_CAPS);
TEST_ASSERT_NOT_NULL(ciphertext);
TEST_ASSERT_NOT_NULL(plaintext);
@@ -214,9 +230,13 @@ TEST_CASE("mbedtls CTR AES-256 test", "[aes]")
free(decryptedtext);
}
TEST_CASE("mbedtls OFB AES-256 test", "[aes]")
TEST_CASE("mbedtls CTR AES-256 test", "[aes]")
{
aes_ctr_test(TEST_AES_CTR_DMA_MODE_LEN);
}
static void aes_ofb_test(unsigned int SZ)
{
const unsigned SZ = 1000;
mbedtls_aes_context ctx;
uint8_t nonce[16];
size_t nc_off = 0;
@@ -231,9 +251,9 @@ TEST_CASE("mbedtls OFB AES-256 test", "[aes]")
memcpy(nonce, iv, 16);
// allocate internal memory
uint8_t *ciphertext = heap_caps_malloc(SZ, MALLOC_CAP_8BIT|MALLOC_CAP_INTERNAL);
uint8_t *plaintext = heap_caps_malloc(SZ, MALLOC_CAP_8BIT|MALLOC_CAP_INTERNAL);
uint8_t *decryptedtext = heap_caps_malloc(SZ, MALLOC_CAP_8BIT|MALLOC_CAP_INTERNAL);
uint8_t *ciphertext = heap_caps_malloc(SZ, INTERNAL_DMA_CAPS);
uint8_t *plaintext = heap_caps_malloc(SZ, INTERNAL_DMA_CAPS);
uint8_t *decryptedtext = heap_caps_malloc(SZ, INTERNAL_DMA_CAPS);
TEST_ASSERT_NOT_NULL(ciphertext);
TEST_ASSERT_NOT_NULL(plaintext);
@@ -262,9 +282,13 @@ TEST_CASE("mbedtls OFB AES-256 test", "[aes]")
free(decryptedtext);
}
TEST_CASE("mbedtls CFB-8 AES-256 test", "[aes]")
TEST_CASE("mbedtls OFB AES-256 test", "[aes]")
{
aes_ofb_test(TEST_AES_OFB_DMA_MODE_LEN);
}
static void aes_cfb8_test(unsigned int SZ)
{
const unsigned SZ = 1000;
mbedtls_aes_context ctx;
uint8_t nonce[16];
@@ -278,9 +302,9 @@ TEST_CASE("mbedtls CFB-8 AES-256 test", "[aes]")
memcpy(nonce, iv, 16);
// allocate internal memory
uint8_t *ciphertext = heap_caps_malloc(SZ, MALLOC_CAP_8BIT|MALLOC_CAP_INTERNAL);
uint8_t *plaintext = heap_caps_malloc(SZ, MALLOC_CAP_8BIT|MALLOC_CAP_INTERNAL);
uint8_t *decryptedtext = heap_caps_malloc(SZ, MALLOC_CAP_8BIT|MALLOC_CAP_INTERNAL);
uint8_t *ciphertext = heap_caps_malloc(SZ, INTERNAL_DMA_CAPS);
uint8_t *plaintext = heap_caps_malloc(SZ, INTERNAL_DMA_CAPS);
uint8_t *decryptedtext = heap_caps_malloc(SZ, INTERNAL_DMA_CAPS);
TEST_ASSERT_NOT_NULL(ciphertext);
TEST_ASSERT_NOT_NULL(plaintext);
@@ -308,9 +332,13 @@ TEST_CASE("mbedtls CFB-8 AES-256 test", "[aes]")
free(decryptedtext);
}
TEST_CASE("mbedtls CFB-128 AES-256 test", "[aes]")
TEST_CASE("mbedtls CFB-8 AES-256 test", "[aes]")
{
aes_cfb8_test(TEST_AES_CFB8_DMA_MODE_LEN);
}
static void aes_cfb128_test(unsigned int SZ)
{
const unsigned SZ = 1000;
mbedtls_aes_context ctx;
uint8_t nonce[16];
size_t nc_off = 0;
@@ -325,9 +353,9 @@ TEST_CASE("mbedtls CFB-128 AES-256 test", "[aes]")
memcpy(nonce, iv, 16);
// allocate internal memory
uint8_t *ciphertext = heap_caps_malloc(SZ, MALLOC_CAP_8BIT|MALLOC_CAP_INTERNAL);
uint8_t *plaintext = heap_caps_malloc(SZ, MALLOC_CAP_8BIT|MALLOC_CAP_INTERNAL);
uint8_t *decryptedtext = heap_caps_malloc(SZ, MALLOC_CAP_8BIT|MALLOC_CAP_INTERNAL);
uint8_t *ciphertext = heap_caps_malloc(SZ, INTERNAL_DMA_CAPS);
uint8_t *plaintext = heap_caps_malloc(SZ, INTERNAL_DMA_CAPS);
uint8_t *decryptedtext = heap_caps_malloc(SZ, INTERNAL_DMA_CAPS);
TEST_ASSERT_NOT_NULL(ciphertext);
TEST_ASSERT_NOT_NULL(plaintext);
@@ -356,9 +384,13 @@ TEST_CASE("mbedtls CFB-128 AES-256 test", "[aes]")
free(decryptedtext);
}
static void aes_ctr_stream_test(void)
TEST_CASE("mbedtls CFB-128 AES-256 test", "[aes]")
{
aes_cfb128_test(TEST_AES_CFB128_DMA_MODE_LEN);
}
static void aes_ctr_stream_test(uint32_t input_buf_caps, uint32_t output_buf_caps, unsigned int SZ)
{
const unsigned SZ = 100;
mbedtls_aes_context ctx;
uint8_t nonce[16];
uint8_t key[16];
@@ -372,12 +404,12 @@ static void aes_ctr_stream_test(void)
nonce = b'\xee' * 16
cipher = Cipher(algorithms.AES(key), modes.CTR(nonce), backend=default_backend())
encryptor = cipher.encryptor()
ct = encryptor.update(b'\xaa' * 100) + encryptor.finalize()
ct = encryptor.update(b'\xaa' * 1000) + encryptor.finalize()
ct_arr = ""
for idx, b in enumerate(ct):
if idx % 8 == 0:
ct_arr += '\n'
ct_arr += "0x{}, ".format(binascii.hexlify(b))
ct_arr += "0x{}, ".format(format(b, '02x'))
print(ct_arr)
*/
const uint8_t expected_cipher[] = {
@@ -393,17 +425,128 @@ static void aes_ctr_stream_test(void)
0xd0, 0x5e, 0xe5, 0x3f, 0xc5, 0xed, 0x5c, 0x18,
0xa7, 0x84, 0xd8, 0xdf, 0x9d, 0xb5, 0x06, 0xb1,
0xa7, 0xcf, 0x2e, 0x7a, 0x51, 0xfc, 0x44, 0xc5,
0xb9, 0x5f, 0x22, 0x47,
0xb9, 0x5f, 0x22, 0x47, 0x91, 0xbd, 0x67, 0x89,
0x15, 0xcd, 0x6a, 0xac, 0xa7, 0x8f, 0x6c, 0xff,
0x64, 0xc4, 0xbd, 0x53, 0xb6, 0x24, 0x13, 0xd4,
0x30, 0x3e, 0x80, 0xb9, 0x5f, 0xf6, 0x79, 0x4c,
0x3c, 0x11, 0xce, 0x45, 0xb2, 0x4b, 0x70, 0x2d,
0x73, 0xc8, 0x0d, 0x4c, 0x82, 0xa6, 0x8a, 0xe2,
0x4e, 0x56, 0x07, 0xdf, 0xaf, 0x2a, 0x15, 0x08,
0xef, 0x5d, 0x96, 0x69, 0xe9, 0xe7, 0xc0, 0x1f,
0x7b, 0x67, 0x68, 0xaf, 0xe9, 0x9c, 0xb4, 0x15,
0x49, 0x95, 0x1a, 0x71, 0xb3, 0x7b, 0x4b, 0x26,
0xf1, 0x9e, 0x72, 0xf3, 0xa5, 0x24, 0x46, 0x96,
0xda, 0x11, 0xd5, 0xa7, 0x05, 0xc4, 0x36, 0x11,
0xb2, 0x01, 0x5d, 0xe8, 0x67, 0xe6, 0x4a, 0xe7,
0x44, 0x22, 0xb9, 0xa8, 0x8f, 0x26, 0x62, 0x80,
0x3e, 0xf5, 0xfe, 0x51, 0x46, 0x20, 0x23, 0x1b,
0x97, 0xb4, 0x6e, 0x5c, 0xe9, 0x3e, 0xe3, 0x79,
0xf4, 0xd0, 0xc6, 0x81, 0x59, 0x8d, 0x99, 0x55,
0x12, 0x37, 0x55, 0x28, 0xda, 0x3d, 0x70, 0xc9,
0x6a, 0xb9, 0xd7, 0xee, 0x55, 0x35, 0x0f, 0x96,
0xde, 0x19, 0x6f, 0x44, 0xba, 0x66, 0x9b, 0xdd,
0x5a, 0x7b, 0xc6, 0x45, 0xf8, 0x6e, 0x8b, 0xa1,
0xf1, 0xe1, 0x44, 0x33, 0xe9, 0x10, 0x81, 0xed,
0xba, 0x21, 0xf3, 0x01, 0xab, 0x78, 0x7d, 0x64,
0x05, 0xda, 0xc7, 0xce, 0x34, 0x8d, 0x74, 0xef,
0x22, 0xa8, 0x77, 0xc4, 0x43, 0x06, 0xcd, 0x29,
0xfb, 0xc8, 0x20, 0x13, 0xbb, 0x41, 0xf2, 0x5c,
0x3b, 0x99, 0x2e, 0xbe, 0xb0, 0xaa, 0x78, 0xd8,
0xfa, 0xcd, 0x28, 0x30, 0x23, 0xc2, 0xd3, 0xb4,
0x63, 0x0d, 0x46, 0x14, 0xa1, 0x73, 0xb7, 0xed,
0xf8, 0xb8, 0x38, 0x0e, 0xde, 0x6a, 0x8a, 0x11,
0x35, 0x7e, 0xe6, 0x55, 0x2d, 0xe8, 0xa1, 0xa1,
0xa0, 0x79, 0x8a, 0x47, 0x50, 0xbe, 0x13, 0x93,
0x05, 0x6c, 0x52, 0x7d, 0x41, 0x79, 0xcd, 0x64,
0x45, 0x3e, 0xce, 0xa3, 0xa8, 0xf2, 0xa6, 0x0c,
0xee, 0xf2, 0x13, 0xaa, 0x5d, 0xdc, 0x59, 0x5a,
0x7a, 0x96, 0x1f, 0xe0, 0xcc, 0x10, 0x46, 0xcd,
0xfa, 0x9d, 0x85, 0x25, 0xd0, 0x48, 0x2d, 0xb1,
0x34, 0x81, 0xce, 0xd1, 0xae, 0x4d, 0xd8, 0x6f,
0xea, 0xbe, 0x42, 0x68, 0x5a, 0xa5, 0x63, 0x68,
0x86, 0x8a, 0x39, 0x78, 0x2f, 0x66, 0xd9, 0x85,
0xbf, 0x88, 0x9a, 0x7e, 0xc7, 0xc2, 0x3a, 0xeb,
0x5e, 0xc8, 0x3c, 0x35, 0xf2, 0xfc, 0x68, 0x21,
0xca, 0x75, 0xbb, 0x3d, 0x53, 0x02, 0xe8, 0xb1,
0xba, 0x57, 0x92, 0xd3, 0x8d, 0x69, 0xe7, 0x23,
0x8f, 0xea, 0xf0, 0xf2, 0x4d, 0xde, 0x9d, 0x2a,
0xab, 0x3a, 0x90, 0x10, 0x5f, 0x29, 0x19, 0x1a,
0xf7, 0x02, 0x0a, 0x57, 0x3f, 0x39, 0x7a, 0xd9,
0xf4, 0x75, 0x95, 0x6c, 0xce, 0x2e, 0xa1, 0xb9,
0x0d, 0x78, 0x03, 0x42, 0xec, 0x5b, 0x60, 0xcb,
0xb5, 0x06, 0xde, 0x6e, 0xec, 0x6e, 0x2d, 0x62,
0x78, 0x1e, 0x8c, 0x40, 0x02, 0x52, 0xeb, 0xe9,
0xe9, 0x39, 0xea, 0xee, 0x7f, 0xa0, 0x6c, 0x2e,
0x93, 0x2a, 0xe4, 0xaf, 0x05, 0xa7, 0xa9, 0xc5,
0x2a, 0x44, 0x6d, 0x5a, 0x46, 0x41, 0x03, 0x85,
0x4c, 0x27, 0xb5, 0x83, 0xfd, 0xb9, 0xb9, 0x68,
0x35, 0x26, 0xae, 0xcc, 0xca, 0x59, 0xa2, 0xe8,
0x9d, 0xa5, 0xde, 0x90, 0x4f, 0xef, 0x8c, 0x92,
0x11, 0x9f, 0x69, 0xd9, 0x66, 0x1c, 0xee, 0x83,
0xe3, 0xe9, 0x60, 0x05, 0x0b, 0x43, 0x2b, 0x82,
0xd7, 0x59, 0xdf, 0xb4, 0x1f, 0x19, 0x1b, 0xbe,
0x30, 0x98, 0x71, 0x7e, 0xb9, 0xc0, 0xf5, 0xe2,
0x08, 0xf4, 0x58, 0x42, 0x8a, 0x5b, 0xbb, 0x45,
0xcf, 0x10, 0x89, 0xdf, 0xec, 0x97, 0x1a, 0x2f,
0xac, 0xd7, 0xce, 0xd0, 0x62, 0x84, 0x6b, 0xa2,
0xb6, 0xa8, 0x1b, 0xce, 0x7d, 0x68, 0xac, 0x31,
0x30, 0x41, 0x09, 0x53, 0xaf, 0x53, 0x41, 0x8e,
0xef, 0x34, 0x0f, 0x4a, 0xf2, 0xaa, 0x42, 0xc1,
0x9e, 0x68, 0xf6, 0xda, 0xb0, 0x5d, 0xa8, 0x40,
0xa5, 0x1f, 0x1d, 0x5f, 0x73, 0xfb, 0x2c, 0x82,
0x42, 0x24, 0x70, 0xce, 0x30, 0x95, 0x69, 0xd1,
0xed, 0xa5, 0xd9, 0xd0, 0xab, 0xb8, 0x9d, 0x8a,
0x4d, 0xa0, 0x89, 0xb1, 0xaf, 0x93, 0x28, 0x59,
0xfc, 0x6f, 0x5a, 0x97, 0x9a, 0xe9, 0x02, 0x8e,
0xa1, 0x4e, 0x72, 0xde, 0x53, 0x5a, 0x0b, 0x42,
0x72, 0x38, 0x41, 0x5f, 0x0c, 0x51, 0xac, 0xa8,
0xb5, 0x17, 0x32, 0x1e, 0x18, 0xd6, 0x54, 0x67,
0x0e, 0xc6, 0x43, 0xd0, 0xe0, 0xb6, 0xac, 0x40,
0xfa, 0xaa, 0x76, 0xe3, 0x8d, 0xdb, 0x8a, 0x4a,
0xa9, 0x09, 0xbb, 0x65, 0xd5, 0xca, 0xaa, 0xf5,
0x0b, 0x63, 0xe0, 0x24, 0x79, 0x56, 0xd8, 0x1f,
0x58, 0xc4, 0xc6, 0x31, 0x56, 0xfe, 0xba, 0xd6,
0x85, 0xbd, 0x89, 0x92, 0x66, 0xff, 0xf1, 0xaf,
0x52, 0x35, 0x1e, 0xa6, 0xa5, 0xcc, 0x9a, 0xc1,
0x3b, 0x61, 0x72, 0x90, 0xaf, 0xab, 0x04, 0xbb,
0xc0, 0x9a, 0xd1, 0xb9, 0xc0, 0x1b, 0x6b, 0xd0,
0x6d, 0x95, 0x17, 0x43, 0x2b, 0x78, 0xaa, 0x52,
0xc1, 0x57, 0x3f, 0xa5, 0xaa, 0x2d, 0xd7, 0x6c,
0xf7, 0x97, 0x13, 0xb0, 0x99, 0xdb, 0x3f, 0xef,
0xb8, 0xb0, 0xa6, 0x14, 0xbd, 0xea, 0xc2, 0x0a,
0x84, 0x56, 0xf8, 0x2b, 0xa3, 0xdc, 0x48, 0xd1,
0x75, 0xa2, 0xa8, 0x2a, 0xdc, 0xa8, 0x70, 0xe4,
0xc1, 0x92, 0xb8, 0x71, 0x67, 0x51, 0x92, 0xbb,
0x7d, 0xba, 0x78, 0xed, 0x93, 0x99, 0x0e, 0x56,
0x2d, 0xe3, 0x43, 0x7d, 0xee, 0x02, 0x51, 0x15,
0x64, 0x1e, 0x13, 0x04, 0xbb, 0xa0, 0xb4, 0x0c,
0xb7, 0x30, 0xbb, 0x1f, 0x93, 0x30, 0x4e, 0x99,
0xad, 0x4f, 0xce, 0x0b, 0xa1, 0x7f, 0xdf, 0x66,
0x44, 0xb0, 0x49, 0x2c, 0x16, 0x9e, 0x22, 0x9b,
0x88, 0xf0, 0x2b, 0x7d, 0xdd, 0x46, 0x50, 0x27,
0xef, 0x61, 0x7b, 0xe2, 0xd8, 0xfd, 0x42, 0x10,
0xeb, 0x07, 0xdf, 0x31, 0xf2, 0xb9, 0xab, 0xba,
0x04, 0x95, 0xa7, 0xb3, 0x74, 0x71, 0xa8, 0x34,
0x31, 0x95, 0xd6, 0x9a, 0x01, 0xd8, 0xab, 0x94,
0xcc, 0x38, 0x8d, 0xb1, 0xa2, 0xe4, 0xeb, 0x86,
0xbc, 0x84, 0x22, 0x23, 0xc2, 0xf3, 0x48, 0xaa,
0xb9, 0x70, 0xd4, 0x20, 0x3c, 0xef, 0x61, 0xe2,
0x10, 0x7c, 0x03, 0x6a, 0x8b, 0xab, 0x6b, 0xce,
0xa2, 0x38, 0xaa, 0xc1, 0x43, 0x5c, 0x9b, 0x06,
0x1e, 0x55, 0x13, 0x49, 0x36, 0x35, 0x6e, 0x10,
0x56, 0xe2, 0x0c, 0xe2, 0x2f, 0xb9, 0x67, 0xc6,
0xb0, 0x61, 0xd9, 0x1d, 0x81, 0xb9, 0x47, 0x64,
0xd3, 0x7a, 0x55, 0x56, 0x6c, 0xf5, 0x15, 0xc8,
0x23, 0xdc, 0x5f, 0xf9, 0xff, 0xba, 0x28, 0xe4,
};
memset(nonce, 0xEE, 16);
memset(key, 0x44, 16);
// allocate internal memory
uint8_t *ciphertext = heap_caps_malloc(SZ, MALLOC_CAP_DMA | MALLOC_CAP_8BIT | MALLOC_CAP_INTERNAL);
uint8_t *plaintext = heap_caps_malloc(SZ, MALLOC_CAP_DMA | MALLOC_CAP_8BIT | MALLOC_CAP_INTERNAL);
uint8_t *decryptedtext = heap_caps_malloc(SZ, MALLOC_CAP_DMA | MALLOC_CAP_8BIT | MALLOC_CAP_INTERNAL);
uint8_t *ciphertext = heap_caps_malloc(SZ, input_buf_caps);
uint8_t *plaintext = heap_caps_malloc(SZ, output_buf_caps);
uint8_t *decryptedtext = heap_caps_malloc(SZ, INTERNAL_DMA_CAPS);
TEST_ASSERT_NOT_NULL(ciphertext);
TEST_ASSERT_NOT_NULL(plaintext);
@@ -458,13 +601,11 @@ static void aes_ctr_stream_test(void)
TEST_CASE("mbedtls CTR stream test", "[aes]")
{
aes_ctr_stream_test();
aes_ctr_stream_test(INTERNAL_DMA_CAPS, INTERNAL_DMA_CAPS, TEST_AES_CTR_STREAM_DMA_MODE_LEN);
}
TEST_CASE("mbedtls OFB stream test", "[aes]")
static void aes_ofb_stream_test(unsigned int SZ)
{
const unsigned SZ = 100;
mbedtls_aes_context ctx;
uint8_t iv[16];
uint8_t key[16];
@@ -477,12 +618,12 @@ TEST_CASE("mbedtls OFB stream test", "[aes]")
iv = b'\xee' * 16
cipher = Cipher(algorithms.AES(key), modes.OFB(iv), backend=default_backend())
encryptor = cipher.encryptor()
ct = encryptor.update(b'\xaa' * 100) + encryptor.finalize()
ct = encryptor.update(b'\xaa' * 1000) + encryptor.finalize()
ct_arr = ""
for idx, b in enumerate(ct):
if idx % 8 == 0:
ct_arr += '\n'
ct_arr += "0x{}, ".format(binascii.hexlify(b))
ct_arr += "0x{}, ".format(format(b, '02x'))
print(ct_arr)
*/
const uint8_t expected_cipher[] = {
@@ -498,16 +639,127 @@ TEST_CASE("mbedtls OFB stream test", "[aes]")
0x2a, 0x76, 0x80, 0x20, 0x82, 0x39, 0xa2, 0x21,
0xf8, 0x7a, 0xec, 0xae, 0x82, 0x6a, 0x5c, 0xd3,
0x04, 0xd9, 0xbd, 0xe4, 0x53, 0xc9, 0xdf, 0x67,
0xaa, 0x5c, 0xaf, 0xa6,
0xaa, 0x5c, 0xaf, 0xa6, 0x95, 0x84, 0x01, 0xae,
0x62, 0x24, 0xc7, 0xf5, 0x44, 0x30, 0x9b, 0xea,
0xd5, 0x53, 0x62, 0xd6, 0x0d, 0x7a, 0x00, 0x19,
0x86, 0xab, 0x97, 0x7d, 0x28, 0xa9, 0x08, 0xc8,
0x5e, 0x20, 0x2c, 0x79, 0x24, 0x62, 0x45, 0x3e,
0x4a, 0x3c, 0x34, 0x73, 0xd3, 0x84, 0xa1, 0xc7,
0xee, 0x32, 0xe6, 0x29, 0xa7, 0x28, 0x8b, 0x23,
0x90, 0x7a, 0x51, 0x3d, 0xac, 0x78, 0x08, 0x7a,
0x9d, 0x01, 0x2e, 0xc4, 0x78, 0xd3, 0x58, 0x1d,
0x9b, 0x66, 0x67, 0x89, 0x83, 0xfe, 0x28, 0x04,
0x7e, 0x19, 0x2b, 0x2d, 0xbc, 0x23, 0x36, 0x58,
0xef, 0x0a, 0x55, 0x8c, 0x8c, 0xa8, 0x70, 0xc6,
0xd6, 0x60, 0xfa, 0x00, 0x61, 0x72, 0x28, 0x39,
0xa7, 0xa7, 0x53, 0x26, 0x2b, 0x92, 0x2f, 0x44,
0xa7, 0xb7, 0x69, 0x2c, 0x2a, 0xef, 0xf1, 0x1d,
0x04, 0x9f, 0x39, 0x8c, 0xd1, 0x00, 0xf6, 0x93,
0xdd, 0xe3, 0xd2, 0x7e, 0x68, 0x1a, 0xac, 0x51,
0x21, 0x3a, 0xfb, 0x7d, 0x58, 0x00, 0x38, 0xa4,
0xbc, 0xd6, 0x9b, 0xb0, 0xfd, 0x5b, 0x99, 0x40,
0x0e, 0x35, 0x87, 0x22, 0x59, 0x80, 0xc6, 0x7c,
0x06, 0x35, 0x22, 0x18, 0x0d, 0xdb, 0x40, 0x8a,
0xe7, 0x8e, 0x13, 0x4a, 0x8f, 0xe7, 0xe6, 0x5c,
0x88, 0x21, 0xfa, 0xc1, 0xf2, 0xb0, 0x1e, 0x4a,
0x49, 0x6d, 0x9c, 0x28, 0x79, 0xa9, 0x2c, 0xea,
0xb6, 0x14, 0xb0, 0xc9, 0x7a, 0xfe, 0x45, 0x2d,
0xec, 0xbf, 0x65, 0x51, 0x50, 0x34, 0xf8, 0x25,
0x7d, 0x47, 0x58, 0xc5, 0x65, 0x88, 0x57, 0x2e,
0xa5, 0x10, 0xf2, 0xe9, 0x18, 0x2c, 0x90, 0x1e,
0xb2, 0xf5, 0x4e, 0xd0, 0xd8, 0x02, 0xed, 0x90,
0xbb, 0x9e, 0xa9, 0x79, 0xbc, 0x5c, 0x4f, 0xb9,
0xe3, 0x47, 0x75, 0xbe, 0xa7, 0x21, 0xaf, 0x9a,
0x40, 0xc3, 0x86, 0x34, 0x0d, 0x06, 0xb6, 0x12,
0xbf, 0x12, 0xee, 0x79, 0xdb, 0xca, 0x44, 0x1f,
0xc6, 0x6d, 0xab, 0xa7, 0x9c, 0x37, 0x50, 0x5a,
0x49, 0xff, 0xb4, 0xcf, 0x72, 0xb1, 0x47, 0xd2,
0xaa, 0xbc, 0xb4, 0xd4, 0xb3, 0x5b, 0xdd, 0x16,
0x76, 0xc1, 0x85, 0xd0, 0x7d, 0x1a, 0x27, 0xe4,
0xc8, 0x7b, 0x30, 0x32, 0x5b, 0x6e, 0x51, 0x2d,
0x00, 0x5a, 0x47, 0x80, 0xdb, 0xe9, 0x07, 0xff,
0x63, 0xf1, 0x8b, 0xd3, 0x5a, 0xf5, 0xf4, 0x5b,
0x6c, 0xba, 0x8e, 0x9e, 0x3c, 0x6e, 0x6e, 0xf6,
0x0f, 0xc9, 0x42, 0xc9, 0xf9, 0x74, 0x87, 0x86,
0xeb, 0x36, 0x01, 0x69, 0xa4, 0xae, 0x11, 0xfb,
0x95, 0x7f, 0xe1, 0xc5, 0x6f, 0xe6, 0xe5, 0xfa,
0x01, 0xb2, 0x82, 0x17, 0x41, 0x2f, 0x91, 0xb0,
0x99, 0xbd, 0xfb, 0x38, 0xab, 0x7c, 0x31, 0xcf,
0x7d, 0xbf, 0xb5, 0xee, 0xb0, 0x1c, 0x84, 0x0b,
0xbc, 0xcd, 0xfa, 0x6f, 0xdb, 0xc1, 0x4d, 0x87,
0xe7, 0x0a, 0xaf, 0x6b, 0xd3, 0xfc, 0xe0, 0x88,
0xdc, 0xa5, 0x66, 0xe9, 0x94, 0xd0, 0x3e, 0x00,
0xc8, 0xf6, 0xc2, 0x2d, 0x00, 0xbf, 0x09, 0x30,
0xe5, 0x4f, 0xe7, 0x6b, 0x6b, 0x78, 0x68, 0xb6,
0x9a, 0x45, 0x44, 0x37, 0x18, 0x77, 0xe4, 0xe1,
0xb4, 0x5d, 0x74, 0x9e, 0xef, 0xaf, 0xe0, 0x10,
0x48, 0x06, 0xff, 0xcc, 0xb2, 0x7b, 0xbc, 0x40,
0x64, 0x94, 0x37, 0x60, 0x52, 0xaa, 0xe0, 0xad,
0xf4, 0x05, 0xf9, 0x24, 0x1b, 0xf1, 0x46, 0x47,
0x07, 0x42, 0xa4, 0xa6, 0x09, 0x04, 0x71, 0xa6,
0x8d, 0x42, 0x2a, 0x38, 0x1b, 0x7d, 0xb9, 0x84,
0xcd, 0xa1, 0x0d, 0x96, 0x11, 0xdb, 0x08, 0xe9,
0x63, 0x39, 0xf8, 0x91, 0x26, 0x03, 0x01, 0x13,
0xfb, 0xb2, 0xb6, 0xe5, 0xe0, 0xab, 0x65, 0x1b,
0xc2, 0x99, 0x16, 0xd7, 0x74, 0xd6, 0x70, 0x39,
0x43, 0x0e, 0xff, 0x62, 0xcc, 0x46, 0xba, 0x62,
0x15, 0xba, 0xa8, 0x9d, 0xe6, 0x9d, 0x7b, 0xbc,
0xfa, 0xb2, 0xde, 0xc5, 0x7a, 0xa2, 0x7a, 0x5f,
0x1f, 0x66, 0x45, 0x2e, 0x1c, 0xfc, 0xc2, 0x53,
0xfd, 0x7f, 0x1c, 0x14, 0x42, 0x91, 0x84, 0xea,
0xaf, 0x6d, 0x95, 0x12, 0x71, 0xbf, 0x5f, 0xf2,
0x68, 0x05, 0xa6, 0xa8, 0xcb, 0x6e, 0x07, 0x58,
0xdb, 0xdc, 0x4d, 0x6c, 0x51, 0xa9, 0xe0, 0x93,
0x7d, 0x00, 0x15, 0x27, 0x13, 0x62, 0x7c, 0xab,
0x84, 0xf0, 0xbb, 0xb9, 0x50, 0x67, 0x96, 0x9d,
0x48, 0xe3, 0x43, 0x5f, 0x8d, 0x1d, 0xf4, 0x03,
0x58, 0xf1, 0xcb, 0x67, 0x6f, 0x5e, 0xb3, 0x4c,
0x1f, 0x57, 0x9b, 0x29, 0xa6, 0x9b, 0xef, 0x39,
0xf0, 0xa4, 0x85, 0x1b, 0x59, 0x51, 0x8a, 0x69,
0x44, 0xcc, 0xeb, 0xf9, 0xf0, 0x01, 0xac, 0xdf,
0x28, 0xdf, 0x46, 0x2a, 0x50, 0x57, 0xca, 0x21,
0x93, 0x00, 0x9f, 0x3b, 0xed, 0x72, 0x9b, 0x37,
0xcf, 0x6a, 0x8b, 0x6c, 0xe7, 0x59, 0xb5, 0x13,
0x1f, 0x29, 0xf7, 0x89, 0x2d, 0xf4, 0x10, 0xdc,
0x5d, 0x3e, 0xee, 0x01, 0x5e, 0x62, 0x62, 0xec,
0x1b, 0x89, 0x2d, 0x3b, 0x9b, 0x5e, 0x48, 0x74,
0xd4, 0xba, 0x78, 0xf4, 0xfa, 0xfb, 0x4c, 0x3b,
0xa5, 0xb7, 0x69, 0xb0, 0x36, 0x68, 0xcd, 0x98,
0xc9, 0x3f, 0x6a, 0x20, 0x10, 0xf6, 0x11, 0x2e,
0x6d, 0x88, 0x37, 0x77, 0x92, 0xa3, 0x70, 0x16,
0x41, 0x8c, 0x5f, 0x4a, 0x6f, 0x27, 0x50, 0x07,
0x7e, 0xc5, 0x04, 0x27, 0xb3, 0xc3, 0x7d, 0xf6,
0xe1, 0x04, 0xdd, 0xe3, 0xb9, 0xf7, 0x02, 0x74,
0x5c, 0x00, 0xeb, 0xb5, 0x46, 0x19, 0x36, 0x6a,
0x23, 0xd6, 0x1d, 0x2d, 0xee, 0xa5, 0x0f, 0x20,
0x9d, 0xfa, 0x76, 0x57, 0x22, 0x17, 0xfa, 0x5a,
0x5d, 0x63, 0x85, 0x46, 0x43, 0x10, 0xc2, 0xa7,
0x05, 0x8c, 0x41, 0x14, 0x0c, 0xa1, 0xdf, 0x26,
0xee, 0xd3, 0xc7, 0x06, 0x45, 0x54, 0xe3, 0xc5,
0x7f, 0xfd, 0x52, 0xc3, 0xe8, 0xf9, 0x3a, 0x96,
0xd7, 0x32, 0x38, 0xa9, 0xd3, 0x7e, 0x15, 0x16,
0x3e, 0xcd, 0xcf, 0xd2, 0xea, 0x01, 0xd4, 0xc6,
0x3a, 0x01, 0x4d, 0x0f, 0x64, 0xf9, 0xc1, 0xe0,
0xf4, 0xcd, 0xc0, 0xe8, 0x50, 0x4f, 0x79, 0xb9,
0x79, 0xae, 0x15, 0x1e, 0x6d, 0xf9, 0x2a, 0xca,
0x37, 0x79, 0x34, 0x2b, 0x96, 0x18, 0x2c, 0x88,
0x3f, 0x2b, 0xf1, 0x8d, 0x6d, 0x56, 0x60, 0xe8,
0x36, 0x48, 0x0c, 0x0b, 0x78, 0x79, 0x71, 0x67,
0xf2, 0x35, 0x2d, 0x4c, 0xf2, 0x9f, 0xc7, 0xce,
0x4d, 0x36, 0x92, 0xeb, 0x81, 0x30, 0xac, 0xcf,
0xbc, 0x34, 0x13, 0x42, 0x39, 0x74, 0x8f, 0x23,
0x77, 0xd3, 0x2b, 0x7e, 0xd3, 0x5d, 0x0c, 0x36,
0x73, 0x4b, 0x09, 0xb2, 0xc9, 0xd2, 0xd2, 0x07,
0xda, 0xbd, 0x8f, 0x78, 0xb8, 0xdf, 0x29, 0xdb,
0xe4, 0xbf, 0xcd, 0x23, 0x2f, 0x7a, 0x58, 0x86,
};
memset(key, 0x44, 16);
// allocate internal memory
uint8_t *ciphertext = heap_caps_malloc(SZ, MALLOC_CAP_DMA | MALLOC_CAP_8BIT | MALLOC_CAP_INTERNAL);
uint8_t *plaintext = heap_caps_malloc(SZ, MALLOC_CAP_DMA | MALLOC_CAP_8BIT | MALLOC_CAP_INTERNAL);
uint8_t *decryptedtext = heap_caps_malloc(SZ, MALLOC_CAP_DMA | MALLOC_CAP_8BIT | MALLOC_CAP_INTERNAL);
uint8_t *ciphertext = heap_caps_malloc(SZ, INTERNAL_DMA_CAPS);
uint8_t *plaintext = heap_caps_malloc(SZ, INTERNAL_DMA_CAPS);
uint8_t *decryptedtext = heap_caps_malloc(SZ, INTERNAL_DMA_CAPS);
TEST_ASSERT_NOT_NULL(ciphertext);
TEST_ASSERT_NOT_NULL(plaintext);
@@ -552,9 +804,13 @@ TEST_CASE("mbedtls OFB stream test", "[aes]")
free(decryptedtext);
}
TEST_CASE("mbedtls CFB8 stream test", "[aes]")
TEST_CASE("mbedtls OFB stream test", "[aes]")
{
aes_ofb_stream_test(TEST_AES_OFB_STREAM_DMA_MODE_LEN);
}
static void aes_cfb8_stream_test(unsigned int SZ)
{
const unsigned SZ = 32;
mbedtls_aes_context ctx;
uint8_t iv[16];
uint8_t key[16];
@@ -567,12 +823,12 @@ TEST_CASE("mbedtls CFB8 stream test", "[aes]")
iv = b'\xee' * 16
cipher = Cipher(algorithms.AES(key), modes.CFB8(iv), backend=default_backend())
encryptor = cipher.encryptor()
ct = encryptor.update(b'\xaa' * 100) + encryptor.finalize()
ct = encryptor.update(b'\xaa' * 1000) + encryptor.finalize()
ct_arr = ""
for idx, b in enumerate(ct):
if idx % 8 == 0:
ct_arr += '\n'
ct_arr += "0x{}, ".format(binascii.hexlify(b))
ct_arr += "0x{}, ".format(format(b, '02x'))
print(ct_arr)
*/
const uint8_t expected_cipher[] = {
@@ -588,16 +844,127 @@ TEST_CASE("mbedtls CFB8 stream test", "[aes]")
0xa6, 0xac, 0x0b, 0x54, 0x25, 0x24, 0x67, 0xd6,
0x09, 0xb1, 0x8f, 0x91, 0x63, 0xbd, 0xdf, 0xa1,
0x8a, 0xa3, 0x2e, 0xeb, 0x15, 0x7d, 0xe5, 0x37,
0xe5, 0x5a, 0x9f, 0xa5,
0xe5, 0x5a, 0x9f, 0xa5, 0x21, 0xc2, 0xbd, 0xd6,
0x05, 0xed, 0xf3, 0xbe, 0xe4, 0xf2, 0x8c, 0xd6,
0x6a, 0xae, 0x1e, 0x3d, 0x7a, 0x5f, 0xf1, 0x1f,
0x95, 0xe9, 0x6d, 0xbf, 0x14, 0x56, 0x2f, 0x7f,
0x4e, 0x0d, 0xc7, 0xf0, 0x81, 0x50, 0xca, 0x58,
0xe4, 0xe3, 0xf0, 0xa7, 0x38, 0x45, 0xfb, 0xc1,
0xf0, 0x6e, 0xb1, 0x94, 0x08, 0x29, 0xf1, 0x7d,
0x6f, 0x97, 0x14, 0xb5, 0x2b, 0x6d, 0x9d, 0x6a,
0x52, 0xc8, 0xd6, 0x64, 0xe4, 0x79, 0x40, 0x8c,
0x9d, 0x40, 0x81, 0xf0, 0x68, 0xc8, 0xce, 0x4e,
0xcf, 0xf5, 0xdc, 0x05, 0x49, 0x7c, 0x7c, 0x72,
0x36, 0xe9, 0x1a, 0x72, 0x15, 0x9c, 0x9a, 0xc4,
0x62, 0xba, 0xa5, 0xbe, 0xf6, 0x4e, 0x29, 0x6d,
0xe0, 0xe1, 0x41, 0xbd, 0x7d, 0x7d, 0xe5, 0xbe,
0xaf, 0xd3, 0x85, 0xb7, 0x0e, 0x7a, 0xd7, 0xe7,
0xf4, 0xeb, 0x28, 0xd3, 0xa2, 0xf9, 0x30, 0x9b,
0xe7, 0x61, 0x6b, 0x7c, 0x13, 0x98, 0xa6, 0xc8,
0xdc, 0xd1, 0xcf, 0x9d, 0xfa, 0xf8, 0xdc, 0x89,
0xe7, 0xdc, 0x27, 0x38, 0x94, 0x7a, 0x76, 0x49,
0xe3, 0xfe, 0x3e, 0xc1, 0xc7, 0x95, 0x07, 0x48,
0x33, 0xf7, 0x54, 0x24, 0x21, 0xc0, 0x86, 0xc5,
0xcf, 0xd4, 0x67, 0x18, 0x31, 0x5d, 0xb0, 0x40,
0x7f, 0x37, 0xb7, 0x01, 0xf6, 0x93, 0xbf, 0x4f,
0x65, 0x19, 0x03, 0xf3, 0x4f, 0x7a, 0x84, 0x13,
0x4b, 0x3d, 0x4c, 0x83, 0x58, 0xce, 0xe3, 0x84,
0xf5, 0xea, 0xe2, 0x24, 0x91, 0x04, 0xd9, 0x96,
0x47, 0x15, 0xdd, 0xfe, 0xae, 0xc3, 0x88, 0xe6,
0x23, 0xbf, 0x57, 0x9c, 0x46, 0x07, 0xf4, 0x32,
0x88, 0xb3, 0x99, 0x93, 0xd9, 0x0c, 0x5d, 0x39,
0xba, 0x7d, 0xd1, 0x92, 0x3c, 0x3c, 0x69, 0xe1,
0xcc, 0xb2, 0x5f, 0x76, 0x10, 0xd2, 0x9e, 0x60,
0xb1, 0x5a, 0x1c, 0x9f, 0x88, 0xb1, 0x27, 0xeb,
0x89, 0x59, 0x29, 0xaa, 0x8f, 0x8c, 0x57, 0x2d,
0xc8, 0x3e, 0x07, 0xd4, 0x1b, 0x11, 0x6a, 0x7a,
0x5d, 0x29, 0xf6, 0x56, 0xe2, 0x8f, 0x12, 0xcf,
0x33, 0x79, 0x02, 0xf2, 0x3b, 0xc2, 0x8f, 0x0d,
0x02, 0x47, 0xba, 0xdd, 0x55, 0x1f, 0x41, 0x71,
0x08, 0x1c, 0x9e, 0xa7, 0x79, 0xec, 0x49, 0xf3,
0x33, 0x2a, 0x09, 0xa8, 0xe6, 0xba, 0x1c, 0xa9,
0x0f, 0x67, 0xda, 0xc3, 0xec, 0x3c, 0x22, 0xc1,
0xf5, 0x54, 0x3b, 0x40, 0xdc, 0x47, 0xb8, 0x53,
0x35, 0x55, 0x1c, 0xa3, 0x76, 0x36, 0x77, 0xe2,
0xe8, 0x97, 0x25, 0x20, 0x71, 0x39, 0x35, 0x71,
0x80, 0x35, 0xda, 0x64, 0xab, 0x3c, 0xd1, 0x94,
0x1d, 0xca, 0x55, 0x83, 0xad, 0xe2, 0xed, 0xb8,
0x3f, 0xa4, 0x5d, 0xb2, 0xcc, 0x01, 0x90, 0x02,
0x81, 0xe6, 0xc1, 0x1c, 0x4e, 0x17, 0x32, 0x9f,
0xdb, 0x24, 0x24, 0x8f, 0x60, 0x71, 0xe2, 0xba,
0x15, 0x1b, 0x83, 0x7a, 0xdb, 0x21, 0x7d, 0x0b,
0x67, 0xec, 0xa3, 0xf0, 0x5e, 0xe2, 0xd2, 0x80,
0xa8, 0x77, 0x4f, 0x7a, 0xf3, 0xb9, 0xef, 0x68,
0x34, 0xfe, 0x3b, 0x4f, 0x6b, 0xbc, 0xdf, 0x32,
0x68, 0xc5, 0xea, 0xb5, 0xcf, 0xe3, 0x33, 0xbf,
0xc7, 0x57, 0xd9, 0x12, 0xa4, 0x2a, 0x09, 0x81,
0x4e, 0x1b, 0x8c, 0xd9, 0x58, 0x15, 0x5d, 0xe1,
0xef, 0x13, 0xe7, 0x35, 0xb1, 0x32, 0x00, 0x74,
0x68, 0x2d, 0x7d, 0x5d, 0xd2, 0xce, 0x72, 0xd6,
0xe1, 0x67, 0x98, 0xed, 0xfb, 0x0e, 0xee, 0xe8,
0x9a, 0x0a, 0x57, 0x87, 0xe7, 0x1f, 0xc0, 0xa8,
0x4a, 0x6a, 0x32, 0x8c, 0x98, 0x72, 0x89, 0x29,
0xfe, 0xf7, 0x30, 0x7a, 0xa3, 0xd7, 0xcc, 0xa8,
0x0b, 0x84, 0xf7, 0xfb, 0x58, 0x05, 0x84, 0xa4,
0xf6, 0x73, 0x5e, 0x5f, 0xb3, 0x9e, 0xa1, 0x24,
0x8b, 0xd7, 0x2c, 0xbc, 0x9c, 0x0c, 0x17, 0xe2,
0xac, 0x6a, 0xce, 0x8e, 0x24, 0x56, 0x97, 0x9b,
0xd4, 0xd8, 0x52, 0x92, 0x3c, 0x23, 0x4b, 0x90,
0x0c, 0x6c, 0x7c, 0xa4, 0x8f, 0xee, 0xd1, 0x14,
0x3a, 0x82, 0xae, 0xf2, 0x23, 0xfc, 0xfa, 0x29,
0x43, 0x9e, 0xa9, 0x8e, 0xd9, 0xa3, 0x37, 0x64,
0xbe, 0x50, 0x49, 0x34, 0x92, 0x1b, 0x7e, 0x06,
0x85, 0x51, 0x7f, 0x21, 0x19, 0xa1, 0x9a, 0xfd,
0x95, 0x76, 0xfd, 0x80, 0x79, 0xdb, 0x40, 0xe2,
0x6d, 0xfb, 0x38, 0xe9, 0xe4, 0x6d, 0x65, 0x6d,
0x1f, 0x97, 0x6c, 0x06, 0x3f, 0xee, 0x5b, 0x9a,
0x85, 0x19, 0xeb, 0xae, 0x65, 0x68, 0x90, 0xa7,
0xb7, 0x47, 0x0c, 0x08, 0xc6, 0x8f, 0x37, 0x00,
0xde, 0xe5, 0x3e, 0xe1, 0x60, 0x88, 0x0d, 0x85,
0x50, 0x30, 0xf2, 0x68, 0x79, 0x39, 0x37, 0xe9,
0x0c, 0x3f, 0xdd, 0x88, 0x83, 0x3a, 0x00, 0x80,
0xd4, 0x16, 0x06, 0x84, 0x18, 0xa0, 0x2c, 0x04,
0x17, 0xae, 0x6a, 0x36, 0x38, 0xe1, 0x40, 0xb0,
0xfb, 0x77, 0x8f, 0xee, 0x24, 0xe5, 0x5e, 0xec,
0xa8, 0x7a, 0x0a, 0xec, 0xf9, 0x3d, 0x45, 0x77,
0x0f, 0x9c, 0x67, 0xa1, 0xc8, 0x80, 0xb8, 0x7e,
0x41, 0x9b, 0x49, 0x43, 0x7a, 0x06, 0x76, 0x5b,
0x6e, 0x48, 0xdd, 0x66, 0xc6, 0x4b, 0x55, 0x2f,
0x45, 0x73, 0xa4, 0x84, 0xbe, 0xcb, 0xe9, 0xc9,
0x70, 0xbf, 0x54, 0x79, 0x0a, 0x29, 0x2b, 0xa3,
0x95, 0xe8, 0x08, 0xc7, 0xb2, 0x92, 0x57, 0x6c,
0x73, 0x3e, 0xe8, 0xff, 0xf7, 0x64, 0x61, 0x89,
0x68, 0x7e, 0x0c, 0xc7, 0xc3, 0x21, 0xea, 0xcc,
0x34, 0xda, 0x10, 0x0f, 0x10, 0x35, 0x4c, 0xbf,
0x1c, 0xa2, 0x3b, 0x1a, 0xba, 0x1c, 0x1d, 0xc3,
0x1e, 0xb8, 0x7a, 0xf2, 0x7d, 0x31, 0x1d, 0x83,
0xce, 0x3b, 0x5c, 0x5a, 0x03, 0xe3, 0xfc, 0x9a,
0xfe, 0xaa, 0x3c, 0xf9, 0x9f, 0x60, 0x7c, 0x54,
0x02, 0x70, 0x23, 0xdb, 0x23, 0xe7, 0x4d, 0x5b,
0x41, 0x8c, 0x1b, 0x01, 0xc9, 0x8e, 0x41, 0xb3,
0xb9, 0x61, 0x90, 0xc1, 0x2b, 0xc5, 0xfa, 0xcf,
0x05, 0x4d, 0xe0, 0x1a, 0x9f, 0xc3, 0xa3, 0x6c,
0x81, 0x4c, 0x6a, 0x33, 0x8f, 0x74, 0x71, 0x79,
0x5d, 0x30, 0x62, 0x03, 0xaa, 0x52, 0x61, 0x0d,
0xaf, 0xf7, 0xe1, 0x80, 0x5b, 0x97, 0x30, 0x6d,
0x31, 0x21, 0xc1, 0x02, 0x43, 0x99, 0x2b, 0x49,
0xe9, 0x83, 0x5d, 0x24, 0x40, 0x5a, 0xcd, 0x2f,
0x20, 0xe4, 0x69, 0x7a, 0x22, 0xcf, 0x1d, 0xb2,
0x90, 0x2d, 0xda, 0x42, 0xf8, 0xb3, 0x8a, 0x3d,
0x55, 0x5a, 0xc5, 0x0f, 0x12, 0x25, 0x3d, 0x98,
0xa1, 0x83, 0xd3, 0x3b, 0xa5, 0xe1, 0x36, 0x2f,
0x85, 0xe1, 0x4b, 0x48, 0x5e, 0xe7, 0xc1, 0x57,
0x19, 0xca, 0xc0, 0xc0, 0x23, 0x59, 0x06, 0xb6,
0x32, 0xeb, 0x9e, 0x2b, 0xf5, 0x23, 0x5a, 0x90,
0xfc, 0x6d, 0xd1, 0xcd, 0x3a, 0x93, 0xdd, 0xc2,
};
memset(key, 0x44, 16);
// allocate internal memory
uint8_t *ciphertext = heap_caps_malloc(SZ, MALLOC_CAP_DMA | MALLOC_CAP_8BIT | MALLOC_CAP_INTERNAL);
uint8_t *plaintext = heap_caps_malloc(SZ, MALLOC_CAP_DMA | MALLOC_CAP_8BIT | MALLOC_CAP_INTERNAL);
uint8_t *decryptedtext = heap_caps_malloc(SZ, MALLOC_CAP_DMA | MALLOC_CAP_8BIT | MALLOC_CAP_INTERNAL);
uint8_t *ciphertext = heap_caps_malloc(SZ, INTERNAL_DMA_CAPS);
uint8_t *plaintext = heap_caps_malloc(SZ, INTERNAL_DMA_CAPS);
uint8_t *decryptedtext = heap_caps_malloc(SZ, INTERNAL_DMA_CAPS);
TEST_ASSERT_NOT_NULL(ciphertext);
TEST_ASSERT_NOT_NULL(plaintext);
@@ -637,9 +1004,13 @@ TEST_CASE("mbedtls CFB8 stream test", "[aes]")
free(decryptedtext);
}
TEST_CASE("mbedtls CFB128 stream test", "[aes]")
TEST_CASE("mbedtls CFB8 stream test", "[aes]")
{
aes_cfb8_stream_test(TEST_AES_CFB8_STREAM_DMA_MODE_LEN);
}
static void aes_cfb128_stream_test(unsigned int SZ)
{
const unsigned SZ = 32;
mbedtls_aes_context ctx;
uint8_t iv[16];
uint8_t key[16];
@@ -652,12 +1023,12 @@ TEST_CASE("mbedtls CFB128 stream test", "[aes]")
iv = b'\xee' * 16
cipher = Cipher(algorithms.AES(key), modes.CFB(iv), backend=default_backend())
encryptor = cipher.encryptor()
ct = encryptor.update(b'\xaa' * 100) + encryptor.finalize()
ct = encryptor.update(b'\xaa' * 1000) + encryptor.finalize()
ct_arr = ""
for idx, b in enumerate(ct):
if idx % 8 == 0:
ct_arr += '\n'
ct_arr += "0x{}, ".format(binascii.hexlify(b))
ct_arr += "0x{}, ".format(format(b, '02x'))
print(ct_arr)
*/
const uint8_t expected_cipher[] = {
@@ -673,16 +1044,127 @@ TEST_CASE("mbedtls CFB128 stream test", "[aes]")
0xf4, 0x23, 0x61, 0x12, 0x71, 0xbe, 0x03, 0x74,
0x99, 0x81, 0x9d, 0x65, 0x48, 0xd9, 0xd4, 0x67,
0xd1, 0x31, 0xe8, 0x44, 0x27, 0x17, 0xd4, 0x2d,
0x3d, 0x59, 0xf7, 0xd3,
0x3d, 0x59, 0xf7, 0xd3, 0x9a, 0x7a, 0x82, 0xac,
0x6d, 0x78, 0xad, 0xae, 0x07, 0x41, 0xec, 0xce,
0x55, 0xad, 0x97, 0x1a, 0x2c, 0x87, 0xc6, 0xa1,
0x4e, 0x25, 0xe7, 0xbd, 0x2d, 0xa4, 0x62, 0xb9,
0xa1, 0xc4, 0xf2, 0xb3, 0xae, 0x6a, 0x47, 0x06,
0x5b, 0x18, 0xcc, 0x58, 0x5a, 0x37, 0x8a, 0xe2,
0x7c, 0x87, 0x77, 0x10, 0xd1, 0xec, 0xbc, 0x5a,
0xbd, 0xb8, 0x66, 0x20, 0x90, 0xb6, 0x82, 0x53,
0xe3, 0x7d, 0xbb, 0x68, 0xa0, 0x51, 0x40, 0x1c,
0x16, 0x66, 0x9a, 0x48, 0xf2, 0xc5, 0xe9, 0xe1,
0xc2, 0xa9, 0x09, 0xda, 0xa9, 0x75, 0xee, 0xfa,
0x4e, 0xe0, 0x72, 0x3c, 0x2e, 0x4f, 0xb4, 0x76,
0x0d, 0x7c, 0x38, 0x36, 0x14, 0xa4, 0x41, 0x90,
0xc1, 0x65, 0x98, 0x16, 0x73, 0xae, 0x63, 0x6f,
0x7d, 0xba, 0x25, 0x7c, 0x86, 0x5c, 0x1e, 0x2f,
0x72, 0x67, 0xfb, 0xe9, 0xd4, 0xad, 0x89, 0x48,
0x0c, 0xd7, 0x5a, 0xe1, 0x92, 0xf9, 0xc9, 0x8e,
0xe3, 0x64, 0xcd, 0x20, 0xd8, 0xec, 0x95, 0x39,
0x78, 0xdb, 0xac, 0x5b, 0xb0, 0x38, 0x13, 0xee,
0xfe, 0xec, 0x1e, 0x2e, 0xe3, 0x57, 0xc1, 0x04,
0x7a, 0xee, 0x1b, 0xbc, 0x85, 0x71, 0x26, 0x51,
0xfb, 0x1d, 0xe4, 0xfb, 0x29, 0x2c, 0xd0, 0x12,
0x94, 0xcf, 0x2b, 0x01, 0x7f, 0xb4, 0x95, 0x0c,
0xc6, 0x3c, 0x3b, 0x31, 0x2e, 0x1d, 0x39, 0x85,
0x50, 0x20, 0x70, 0x68, 0x25, 0x7e, 0xeb, 0xd6,
0x77, 0xd0, 0x66, 0x0d, 0xd0, 0x69, 0x12, 0x8f,
0x00, 0x77, 0xd4, 0xcd, 0xcc, 0xd9, 0xd1, 0x1c,
0x77, 0xf9, 0x57, 0xca, 0xdf, 0x73, 0x90, 0xad,
0x6e, 0xb7, 0xd8, 0x96, 0x58, 0xc7, 0x7d, 0xd3,
0x41, 0xb1, 0x74, 0x9f, 0xae, 0x2f, 0x8d, 0x25,
0xd4, 0xb1, 0xe8, 0xcb, 0x77, 0xe9, 0xb5, 0x57,
0xfb, 0xc7, 0x4b, 0x06, 0x4f, 0x61, 0xcd, 0x2c,
0xfe, 0x46, 0x93, 0x2f, 0x60, 0x02, 0x68, 0xe4,
0x07, 0x85, 0x59, 0x39, 0x07, 0x5d, 0x2f, 0x13,
0xa3, 0x29, 0x04, 0xab, 0x21, 0xb2, 0x35, 0x8a,
0xd6, 0xc1, 0x1c, 0x0c, 0xb6, 0x4b, 0x0e, 0x67,
0xdc, 0xc8, 0xb3, 0x5f, 0x43, 0xde, 0xba, 0x05,
0xe4, 0xbd, 0xa9, 0xf3, 0x28, 0x67, 0x23, 0x24,
0x6e, 0x7a, 0xac, 0xce, 0x2b, 0x58, 0x2f, 0xfc,
0xe8, 0x3e, 0x0b, 0x51, 0x4c, 0xd7, 0x8a, 0xdf,
0xa8, 0x5a, 0xeb, 0x45, 0xf1, 0x4a, 0x57, 0x0a,
0x8c, 0xf5, 0x58, 0x7e, 0xb9, 0x1b, 0x11, 0x48,
0x75, 0x7c, 0x2c, 0x07, 0x31, 0x96, 0x8b, 0xab,
0x2a, 0x0b, 0x97, 0x6b, 0x59, 0x70, 0xdb, 0x3f,
0xf0, 0x68, 0xd2, 0x29, 0xef, 0x1a, 0x65, 0x09,
0xf1, 0x06, 0xc9, 0xd7, 0x68, 0x8d, 0x97, 0x17,
0x68, 0x5d, 0xdc, 0x62, 0xe9, 0xbb, 0x47, 0xa6,
0x92, 0x32, 0xb3, 0x1e, 0x5c, 0x81, 0xc6, 0x54,
0x41, 0xa8, 0xa2, 0x71, 0x3c, 0xf2, 0x48, 0xd3,
0x4b, 0x23, 0x9d, 0x46, 0x10, 0x90, 0xda, 0xae,
0x67, 0x3b, 0x21, 0xe2, 0xde, 0x79, 0x29, 0x32,
0x35, 0x58, 0x15, 0x0c, 0xc3, 0xbf, 0x67, 0xbb,
0x91, 0x06, 0x6c, 0x7a, 0xb4, 0x58, 0xe1, 0x29,
0x38, 0xe3, 0xda, 0x66, 0x93, 0x38, 0x42, 0xd3,
0x01, 0xc0, 0xe7, 0x4d, 0x0c, 0x66, 0x4b, 0x8b,
0xae, 0x16, 0xba, 0xc4, 0xdb, 0xce, 0x92, 0x2b,
0x88, 0xed, 0xb2, 0x59, 0xd4, 0x2a, 0x0f, 0x7a,
0x3a, 0xce, 0xe0, 0xab, 0xa3, 0x46, 0xe4, 0x2b,
0xd9, 0x0b, 0x14, 0x06, 0xc0, 0x7a, 0xe6, 0x40,
0x23, 0x5d, 0x4d, 0x57, 0x9f, 0xfc, 0x7e, 0x08,
0xfc, 0x52, 0x3d, 0x07, 0xd8, 0xee, 0xfa, 0x7c,
0x2a, 0xbc, 0x93, 0x76, 0x7a, 0xc1, 0x32, 0x7a,
0xd7, 0x52, 0xc4, 0x29, 0xec, 0x6b, 0x3b, 0x6d,
0xc8, 0x63, 0xc5, 0x93, 0x60, 0x0a, 0x7d, 0x37,
0x2e, 0x6c, 0xb0, 0x48, 0xe8, 0x47, 0xa5, 0x6a,
0x9d, 0x75, 0x15, 0xf5, 0xfb, 0x89, 0x44, 0xf6,
0x4c, 0x93, 0xc6, 0xdd, 0xe1, 0x72, 0xc3, 0xb9,
0x77, 0xdf, 0x89, 0xed, 0x01, 0xb0, 0x4f, 0x6d,
0xcf, 0x80, 0xf3, 0x03, 0xb4, 0xca, 0x58, 0xc8,
0x55, 0x89, 0x91, 0x64, 0x66, 0xd5, 0xbe, 0x92,
0xf0, 0x6b, 0xa3, 0xa9, 0xfd, 0x13, 0x31, 0xc2,
0x6d, 0xab, 0xf0, 0xac, 0xce, 0x8c, 0x9d, 0xda,
0x33, 0x97, 0x80, 0x9e, 0x9f, 0xcd, 0x57, 0xde,
0x51, 0x78, 0x2b, 0xc8, 0xe7, 0xe4, 0x46, 0x3a,
0x40, 0x16, 0xd1, 0xe0, 0xb5, 0xe8, 0x47, 0xfc,
0x39, 0x0d, 0x68, 0x41, 0x26, 0x08, 0xdb, 0x3f,
0xf1, 0x54, 0xf1, 0x7e, 0xc8, 0xa9, 0x39, 0x76,
0x4b, 0xb5, 0xbb, 0x2e, 0xb5, 0x14, 0x98, 0x94,
0x14, 0xfd, 0xca, 0xaa, 0xa6, 0x5c, 0x1a, 0x85,
0x9f, 0xab, 0x41, 0x76, 0x6f, 0x5b, 0xaf, 0xc5,
0x4e, 0x7d, 0x2a, 0xe1, 0x19, 0x29, 0x85, 0x49,
0x6c, 0x98, 0x46, 0x3a, 0xaf, 0x49, 0x0a, 0x91,
0x64, 0xd6, 0x0d, 0x82, 0xf5, 0xf1, 0x8e, 0xbb,
0x4c, 0x33, 0xde, 0xc5, 0x22, 0x89, 0x08, 0xd8,
0x00, 0x72, 0x2d, 0x68, 0xd7, 0x4f, 0x7b, 0xc4,
0x1a, 0xa1, 0xfb, 0xd5, 0x41, 0xe2, 0x3b, 0x6c,
0x65, 0xeb, 0xb5, 0xbd, 0x14, 0xe8, 0x21, 0x07,
0x71, 0xb5, 0x87, 0xd1, 0x6f, 0x5b, 0x22, 0x68,
0x25, 0x84, 0xac, 0xfd, 0x4f, 0x51, 0x8b, 0x33,
0x9c, 0xcb, 0x05, 0x0d, 0x28, 0xfe, 0xb6, 0x57,
0x25, 0xd0, 0xe8, 0x7f, 0x7f, 0x2e, 0x5a, 0x32,
0x28, 0x40, 0x5d, 0x7d, 0x74, 0xb4, 0xcd, 0x22,
0x5e, 0xd4, 0x31, 0x10, 0xf6, 0xf6, 0xd8, 0x44,
0xe3, 0xbc, 0x85, 0xd4, 0xf7, 0x2c, 0x0d, 0x7b,
0x88, 0xd0, 0x15, 0x5f, 0x0a, 0x8a, 0x29, 0x01,
0x29, 0x27, 0x26, 0xf1, 0xa3, 0x0b, 0x53, 0x8f,
0xed, 0xad, 0x5e, 0xec, 0xb5, 0x1a, 0x3c, 0x7e,
0x14, 0xaa, 0x47, 0x11, 0xc9, 0x48, 0x32, 0xfe,
0xa6, 0x58, 0xe1, 0x38, 0x76, 0x90, 0x32, 0x5a,
0x5b, 0x13, 0x2d, 0x34, 0x14, 0x00, 0x3f, 0xcc,
0xd7, 0xe8, 0x48, 0x13, 0xe6, 0xfe, 0x8c, 0xd1,
0x33, 0xfe, 0xf8, 0xa6, 0x75, 0xff, 0x2c, 0xb7,
0xfc, 0x18, 0x4c, 0x7c, 0x39, 0x48, 0x88, 0xb1,
0x35, 0x06, 0xfa, 0xad, 0x88, 0xd9, 0xae, 0x42,
0x1b, 0x0b, 0x54, 0x95, 0x44, 0x5d, 0x39, 0xb6,
0xda, 0xe5, 0x2d, 0xeb, 0x1b, 0xca, 0x8f, 0xab,
0xd0, 0xb3, 0x7c, 0xdb, 0x5b, 0x00, 0x92, 0xfb,
0x27, 0x26, 0x46, 0x84, 0xe9, 0xfe, 0x64, 0x0e,
0x80, 0x07, 0x48, 0xf6, 0x44, 0x2f, 0xad, 0x94,
0x54, 0xa0, 0x91, 0x96, 0xc8, 0xf6, 0x55, 0xbd,
0xd5, 0x59, 0xe0, 0xf3, 0xae, 0x2a, 0xee, 0xd6,
0x12, 0xec, 0xd7, 0x90, 0x0f, 0x5f, 0x7c, 0x34,
0x31, 0xdb, 0x42, 0x4d, 0xe4, 0x82, 0x6d, 0xe5,
};
memset(key, 0x44, 16);
// allocate internal memory
uint8_t *ciphertext = heap_caps_malloc(SZ, MALLOC_CAP_DMA | MALLOC_CAP_8BIT | MALLOC_CAP_INTERNAL);
uint8_t *plaintext = heap_caps_malloc(SZ, MALLOC_CAP_DMA | MALLOC_CAP_8BIT | MALLOC_CAP_INTERNAL);
uint8_t *decryptedtext = heap_caps_malloc(SZ, MALLOC_CAP_DMA | MALLOC_CAP_8BIT | MALLOC_CAP_INTERNAL);
uint8_t *ciphertext = heap_caps_malloc(SZ, INTERNAL_DMA_CAPS);
uint8_t *plaintext = heap_caps_malloc(SZ, INTERNAL_DMA_CAPS);
uint8_t *decryptedtext = heap_caps_malloc(SZ, INTERNAL_DMA_CAPS);
TEST_ASSERT_NOT_NULL(ciphertext);
TEST_ASSERT_NOT_NULL(plaintext);
@@ -724,6 +1206,11 @@ TEST_CASE("mbedtls CFB128 stream test", "[aes]")
free(decryptedtext);
}
TEST_CASE("mbedtls CFB128 stream test", "[aes]")
{
aes_cfb128_stream_test(TEST_AES_CFB128_DMA_MODE_LEN);
}
/* Cipher produced via this Python:
import os, binascii
from cryptography.hazmat.primitives.ciphers import Cipher, algorithms, modes
@@ -732,12 +1219,12 @@ TEST_CASE("mbedtls CFB128 stream test", "[aes]")
nonce = b'\xee' * 16
cipher = Cipher(algorithms.AES(key), modes.CTR(nonce), backend=default_backend())
encryptor = cipher.encryptor()
ct = encryptor.update(b'\xaa' * 100) + encryptor.finalize()
ct = encryptor.update(b'\xaa' * 1000) + encryptor.finalize()
ct_arr = ""
for idx, b in enumerate(ct):
if idx % 8 == 0:
ct_arr += '\n'
ct_arr += "0x{}, ".format(binascii.hexlify(b))
ct_arr += "0x{}, ".format(format(b, '02x'))
print(ct_arr)
*/
@@ -760,7 +1247,7 @@ TEST_CASE("mbedtls CTR, input buf = output buf", "[aes]")
memcpy(nonce, iv, 16);
// allocate internal memory
uint8_t *buf = heap_caps_malloc(SZ, MALLOC_CAP_8BIT|MALLOC_CAP_INTERNAL);
uint8_t *buf = heap_caps_malloc(SZ, INTERNAL_DMA_CAPS);
TEST_ASSERT_NOT_NULL(buf);
@@ -804,9 +1291,9 @@ TEST_CASE("mbedtls OFB, chained DMA descriptors", "[aes]")
memcpy(nonce, iv, 16);
// allocate internal memory
uint8_t *ciphertext = heap_caps_malloc(SZ, MALLOC_CAP_8BIT|MALLOC_CAP_INTERNAL);
uint8_t *plaintext = heap_caps_malloc(SZ, MALLOC_CAP_8BIT|MALLOC_CAP_INTERNAL);
uint8_t *decryptedtext = heap_caps_malloc(SZ, MALLOC_CAP_8BIT|MALLOC_CAP_INTERNAL);
uint8_t *ciphertext = heap_caps_malloc(SZ, INTERNAL_DMA_CAPS);
uint8_t *plaintext = heap_caps_malloc(SZ, INTERNAL_DMA_CAPS);
uint8_t *decryptedtext = heap_caps_malloc(SZ, INTERNAL_DMA_CAPS);
TEST_ASSERT_NOT_NULL(ciphertext);
TEST_ASSERT_NOT_NULL(plaintext);
@@ -860,7 +1347,7 @@ void aes_ctr_alignment_test(uint32_t input_buf_caps, uint32_t output_buf_caps)
// allocate memory according the requested caps
uint8_t *ciphertext = heap_caps_malloc(SZ + ALIGNMENT_SIZE_BYTES, output_buf_caps);
uint8_t *plaintext = heap_caps_malloc(SZ + ALIGNMENT_SIZE_BYTES, input_buf_caps);
uint8_t *decryptedtext = heap_caps_malloc(SZ, MALLOC_CAP_DMA | MALLOC_CAP_8BIT | MALLOC_CAP_INTERNAL);
uint8_t *decryptedtext = heap_caps_malloc(SZ, INTERNAL_DMA_CAPS);
TEST_ASSERT_NOT_NULL(ciphertext);
TEST_ASSERT_NOT_NULL(plaintext);
@@ -898,7 +1385,7 @@ void aes_ctr_alignment_test(uint32_t input_buf_caps, uint32_t output_buf_caps)
TEST_CASE("mbedtls AES internal mem alignment tests", "[aes]")
{
uint32_t internal_dma_caps = MALLOC_CAP_DMA | MALLOC_CAP_8BIT | MALLOC_CAP_INTERNAL;
uint32_t internal_dma_caps = INTERNAL_DMA_CAPS;
aes_ctr_alignment_test(internal_dma_caps, internal_dma_caps);
}
@@ -917,7 +1404,7 @@ void aes_psram_one_buf_ctr_test(void)
memset(key, 0x1E, 16);
// allocate external memory
uint8_t *buf = heap_caps_malloc(SZ + ALIGNMENT_SIZE_BYTES, MALLOC_CAP_8BIT | MALLOC_CAP_SPIRAM);
uint8_t *buf = heap_caps_malloc(SZ + ALIGNMENT_SIZE_BYTES, PSRAM_DMA_CAPS);
TEST_ASSERT_NOT_NULL(buf);
@@ -1484,7 +1971,7 @@ void aes_ext_flash_ctr_test(uint32_t output_buf_caps)
memset(key, 0x1E, 16);
uint8_t *ciphertext = heap_caps_malloc(SZ, output_buf_caps);
uint8_t *decryptedtext = heap_caps_malloc(SZ, MALLOC_CAP_8BIT | MALLOC_CAP_DMA | MALLOC_CAP_INTERNAL);
uint8_t *decryptedtext = heap_caps_malloc(SZ, INTERNAL_DMA_CAPS);
TEST_ASSERT_NOT_NULL(ciphertext);
TEST_ASSERT_NOT_NULL(decryptedtext);
@@ -1516,17 +2003,20 @@ void aes_ext_flash_ctr_test(uint32_t output_buf_caps)
/* Tests how crypto DMA handles data in external memory */
TEST_CASE("mbedtls AES PSRAM tests", "[aes]")
{
aes_ctr_alignment_test(MALLOC_CAP_DMA | MALLOC_CAP_8BIT | MALLOC_CAP_INTERNAL, MALLOC_CAP_8BIT | MALLOC_CAP_SPIRAM);
aes_ctr_alignment_test(MALLOC_CAP_8BIT | MALLOC_CAP_SPIRAM, MALLOC_CAP_DMA | MALLOC_CAP_8BIT | MALLOC_CAP_INTERNAL);
aes_ctr_alignment_test(MALLOC_CAP_8BIT | MALLOC_CAP_SPIRAM, MALLOC_CAP_8BIT | MALLOC_CAP_SPIRAM);
aes_ctr_alignment_test(INTERNAL_DMA_CAPS, PSRAM_DMA_CAPS);
aes_ctr_alignment_test(PSRAM_DMA_CAPS, INTERNAL_DMA_CAPS);
aes_ctr_alignment_test(PSRAM_DMA_CAPS, PSRAM_DMA_CAPS);
aes_psram_one_buf_ctr_test();
aes_ctr_stream_test(INTERNAL_DMA_CAPS, PSRAM_DMA_CAPS, TEST_AES_CTR_STREAM_DMA_MODE_LEN);
aes_ctr_stream_test(PSRAM_DMA_CAPS, INTERNAL_DMA_CAPS, TEST_AES_CTR_STREAM_DMA_MODE_LEN);
aes_ctr_stream_test(PSRAM_DMA_CAPS, PSRAM_DMA_CAPS, TEST_AES_CTR_STREAM_DMA_MODE_LEN);
}
/* Tests how crypto DMA handles data from external flash */
TEST_CASE("mbedtls AES external flash tests", "[aes]")
{
aes_ext_flash_ctr_test(MALLOC_CAP_8BIT | MALLOC_CAP_SPIRAM);
aes_ext_flash_ctr_test(MALLOC_CAP_DMA | MALLOC_CAP_8BIT | MALLOC_CAP_INTERNAL);
aes_ext_flash_ctr_test(PSRAM_DMA_CAPS);
aes_ext_flash_ctr_test(INTERNAL_DMA_CAPS);
}
#endif // CONFIG_SPIRAM_USE_MALLOC
@@ -1535,7 +2025,7 @@ static SemaphoreHandle_t done_sem;
static void __attribute__((unused)) aes_ctr_stream_test_task(void *pv)
{
aes_ctr_stream_test();
aes_ctr_stream_test(INTERNAL_DMA_CAPS, INTERNAL_DMA_CAPS, TEST_AES_CTR_STREAM_DMA_MODE_LEN);
xSemaphoreGive(done_sem);
vTaskDelete(NULL);
}
@@ -1571,7 +2061,7 @@ TEST_CASE("mbedtls AES stack in PSRAM", "[mbedtls]")
done_sem = xSemaphoreCreateBinary();
static StaticTask_t psram_task;
size_t STACK_SIZE = 3072;
uint8_t *psram_stack = heap_caps_calloc(STACK_SIZE, 1, MALLOC_CAP_SPIRAM);
uint8_t *psram_stack = heap_caps_calloc(STACK_SIZE, 1, PSRAM_DMA_CAPS);
TEST_ASSERT(esp_ptr_external_ram(psram_stack));
components/mbedtls/test_apps/pytest_mbedtls_ut.py
+10 -20
View File
@@ -3,6 +3,7 @@
import pytest
from pytest_embedded import Dut
from pytest_embedded_idf.utils import idf_parametrize
from pytest_embedded_idf.utils import soc_filtered_targets
@pytest.mark.generic
@@ -34,7 +35,7 @@ def test_mbedtls_esp32_compiler_perf_opt(dut: Dut) -> None:
)
@idf_parametrize('target', ['esp32', 'esp32s2', 'esp32s3', 'esp32c3', 'esp32c5'], indirect=['target'])
def test_mbedtls_aes_no_hw(dut: Dut) -> None:
dut.run_all_single_board_cases()
dut.run_all_single_board_cases(timeout=180)
@pytest.mark.generic
@@ -46,9 +47,9 @@ def test_mbedtls_aes_no_hw(dut: Dut) -> None:
],
indirect=True,
)
@idf_parametrize('target', ['esp32', 'esp32s2', 'esp32s3', 'esp32c5', 'esp32c61'], indirect=['target'])
@idf_parametrize('target', soc_filtered_targets('SOC_SPIRAM_SUPPORTED == 1'), indirect=['target'])
def test_mbedtls_psram(dut: Dut) -> None:
dut.run_all_single_board_cases()
dut.run_all_single_board_cases(timeout=180)
@pytest.mark.flash_encryption_psram
@@ -60,32 +61,21 @@ def test_mbedtls_psram(dut: Dut) -> None:
indirect=True,
)
@idf_parametrize('target', ['esp32'], indirect=['target'])
def test_mbedtls_psram_all_ext_flash_enc(dut: Dut) -> None:
dut.run_all_single_board_cases()
@pytest.mark.generic
@pytest.mark.parametrize(
'config',
['psram_esp32p4_200m', 'psram_all_ext_esp32p4_200m'],
indirect=True,
)
@idf_parametrize('target', ['esp32p4'], indirect=['target'])
def test_mbedtls_psram_esp32p4(dut: Dut) -> None:
dut.run_all_single_board_cases()
def test_mbedtls_psram_all_ext_flash_enc_esp32(dut: Dut) -> None:
dut.run_all_single_board_cases(timeout=180)
@pytest.mark.flash_encryption
@pytest.mark.parametrize(
'config',
[
'psram_all_ext_flash_enc_esp32p4_200m',
'psram_all_ext_flash_enc',
],
indirect=True,
)
@idf_parametrize('target', ['esp32p4'], indirect=['target'])
def test_mbedtls_psram_all_ext_flash_enc_esp32p4_200m(dut: Dut) -> None:
dut.run_all_single_board_cases()
@idf_parametrize('target', ['esp32p4', 'esp32c5'], indirect=['target'])
def test_mbedtls_psram_all_ext_flash_enc(dut: Dut) -> None:
dut.run_all_single_board_cases(timeout=180)
@pytest.mark.ecdsa_efuse
components/mbedtls/test_apps/sdkconfig.ci.psram_all_ext_esp32p4_200m
-8
View File
@@ -1,8 +0,0 @@
CONFIG_IDF_TARGET="esp32p4"
CONFIG_SPIRAM=y
CONFIG_ESP_INT_WDT_TIMEOUT_MS=800
CONFIG_FREERTOS_TASK_CREATE_ALLOW_EXT_MEM=y
CONFIG_SPIRAM_MALLOC_ALWAYSINTERNAL=0
CONFIG_IDF_EXPERIMENTAL_FEATURES=y
CONFIG_SPIRAM_SPEED_200M=y
components/mbedtls/test_apps/sdkconfig.ci.psram_all_ext_flash_enc_esp32p4_200m
-21
View File
@@ -1,21 +0,0 @@
CONFIG_IDF_TARGET="esp32p4"
CONFIG_SPIRAM=y
CONFIG_ESP_INT_WDT_TIMEOUT_MS=800
CONFIG_FREERTOS_TASK_CREATE_ALLOW_EXT_MEM=y
CONFIG_SPIRAM_MALLOC_ALWAYSINTERNAL=0
CONFIG_IDF_EXPERIMENTAL_FEATURES=y
CONFIG_SPIRAM_SPEED_200M=y
# Default settings for testing this example in CI.
# This configuration is not secure, don't use it in production!
# See Flash Encryption API Guide for more details.
CONFIG_SECURE_FLASH_ENC_ENABLED=y
CONFIG_SECURE_FLASH_ENCRYPTION_MODE_DEVELOPMENT=y
CONFIG_SECURE_BOOT_ALLOW_ROM_BASIC=y
CONFIG_SECURE_BOOT_ALLOW_JTAG=y
CONFIG_SECURE_FLASH_UART_BOOTLOADER_ALLOW_ENC=y
CONFIG_SECURE_FLASH_UART_BOOTLOADER_ALLOW_DEC=y
CONFIG_SECURE_FLASH_UART_BOOTLOADER_ALLOW_CACHE=y
CONFIG_SECURE_FLASH_REQUIRE_ALREADY_ENABLED=y
components/mbedtls/test_apps/sdkconfig.ci.psram_esp32p4_200m
-6
View File
@@ -1,6 +0,0 @@
CONFIG_IDF_TARGET="esp32p4"
CONFIG_SPIRAM=y
CONFIG_ESP_INT_WDT_TIMEOUT_MS=800
CONFIG_IDF_EXPERIMENTAL_FEATURES=y
CONFIG_SPIRAM_SPEED_200M=y