Skip to content

Commit 8f2047e

Browse files
FrauschiFrauschi
committed
Add DMA support for AES-ECB
1 parent d1384f3 commit 8f2047e

11 files changed

Lines changed: 634 additions & 27 deletions

‎benchmark/bench_modules/wh_bench_mod_aes.c‎

Lines changed: 200 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -380,6 +380,138 @@ int wh_Bench_Mod_Aes256CTRDecryptDma(whClientContext* client,
380380

381381
#endif /* WOLFSSL_AES_COUNTER */
382382
#if defined(HAVE_AES_ECB)
383+
#if defined(WOLFHSM_CFG_DMA)
384+
static int _benchAesEcbDma(whClientContext* client, whBenchOpContext* ctx,
385+
int id, const uint8_t* key, size_t keyLen,
386+
int encrypt)
387+
{
388+
int ret = 0;
389+
int needEvict = 0;
390+
whKeyId keyId = WH_KEYID_ERASED;
391+
Aes aes[1];
392+
char keyLabel[] = "key label";
393+
const size_t inLen = WOLFHSM_CFG_BENCH_DMA_BUFFER_SIZE / 2;
394+
int i;
395+
const uint8_t* in = NULL;
396+
uint8_t* out = NULL;
397+
398+
#if defined(WOLFHSM_CFG_TEST_POSIX)
399+
/* Allocate buffers using XMALLOC with heap hints for DMA */
400+
if (ctx->transportType == WH_BENCH_TRANSPORT_POSIX_DMA) {
401+
void* heap =
402+
posixTransportShm_GetDmaHeap(client->comm->transport_context);
403+
in = XMALLOC(inLen, heap, DYNAMIC_TYPE_TMP_BUFFER);
404+
if (in == NULL) {
405+
WH_BENCH_PRINTF("Failed to allocate memory for DMA input\n");
406+
return WH_ERROR_NOSPACE;
407+
}
408+
409+
out = XMALLOC(inLen, heap, DYNAMIC_TYPE_TMP_BUFFER);
410+
if (out == NULL) {
411+
WH_BENCH_PRINTF("Failed to allocate memory for DMA output\n");
412+
XFREE((uint8_t*)in, heap, DYNAMIC_TYPE_TMP_BUFFER);
413+
return WH_ERROR_NOSPACE;
414+
}
415+
}
416+
else
417+
#endif /* WOLFHSM_CFG_TEST_POSIX */
418+
{
419+
in = WH_BENCH_DMA_BUFFER;
420+
out = (uint8_t*)in + inLen;
421+
}
422+
423+
#if defined(WOLFHSM_CFG_BENCH_INIT_DATA_BUFFERS)
424+
/* Initialize the input buffer with something non-zero */
425+
memset((uint8_t*)in, 0xAA, inLen);
426+
memset(out, 0xAA, inLen);
427+
#endif
428+
429+
/* Initialize the aes struct */
430+
ret = wc_AesInit(aes, NULL, WH_DEV_ID_DMA);
431+
if (ret != 0) {
432+
WH_BENCH_PRINTF("Failed to wc_AesInit %d\n", ret);
433+
goto exit;
434+
}
435+
436+
/* cache the key on the HSM */
437+
ret = wh_Client_KeyCache(client, 0, (uint8_t*)keyLabel, sizeof(keyLabel),
438+
(uint8_t*)key, keyLen, &keyId);
439+
if (ret != 0) {
440+
WH_BENCH_PRINTF("Failed to wh_Client_KeyCache %d\n", ret);
441+
goto exit;
442+
}
443+
444+
needEvict = 1;
445+
446+
/* set the keyId on the struct */
447+
ret = wh_Client_AesSetKeyId(aes, keyId);
448+
if (ret != 0) {
449+
WH_BENCH_PRINTF("Failed to wh_Client_SetKeyIdAes %d\n", ret);
450+
goto exit;
451+
}
452+
453+
ret = wh_Bench_SetDataSize(ctx, id, inLen);
454+
if (ret != 0) {
455+
WH_BENCH_PRINTF("Failed to wh_Bench_SetDataSize %d\n", ret);
456+
goto exit;
457+
}
458+
459+
/* Perform the benchmark */
460+
for (i = 0; i < WOLFHSM_CFG_BENCH_CRYPT_ITERS; i++) {
461+
int benchStartRet;
462+
int benchStopRet;
463+
464+
if (encrypt) {
465+
benchStartRet = wh_Bench_StartOp(ctx, id);
466+
ret = wc_AesEcbEncrypt(aes, out, in, inLen);
467+
benchStopRet = wh_Bench_StopOp(ctx, id);
468+
}
469+
else {
470+
benchStartRet = wh_Bench_StartOp(ctx, id);
471+
ret = wc_AesEcbDecrypt(aes, out, in, inLen);
472+
benchStopRet = wh_Bench_StopOp(ctx, id);
473+
}
474+
475+
if (benchStartRet != 0) {
476+
WH_BENCH_PRINTF("Failed to wh_Bench_StartOp %d\n", benchStartRet);
477+
ret = benchStartRet;
478+
goto exit;
479+
}
480+
if (ret != 0) {
481+
WH_BENCH_PRINTF("Failed to wc_AesEcb%s %d\n",
482+
encrypt ? "Encrypt" : "Decrypt", ret);
483+
goto exit;
484+
}
485+
if (benchStopRet != 0) {
486+
WH_BENCH_PRINTF("Failed to wh_Bench_StopOp %d\n", benchStopRet);
487+
ret = benchStopRet;
488+
goto exit;
489+
}
490+
}
491+
492+
exit:
493+
if (needEvict) {
494+
(void)wh_Client_KeyEvict(client, keyId);
495+
}
496+
wc_AesFree(aes);
497+
498+
#if defined(WOLFHSM_CFG_TEST_POSIX)
499+
if (ctx->transportType == WH_BENCH_TRANSPORT_POSIX_DMA) {
500+
void* heap =
501+
posixTransportShm_GetDmaHeap(client->comm->transport_context);
502+
if (in != NULL) {
503+
XFREE((uint8_t*)in, heap, DYNAMIC_TYPE_TMP_BUFFER);
504+
}
505+
if (out != NULL) {
506+
XFREE(out, heap, DYNAMIC_TYPE_TMP_BUFFER);
507+
}
508+
}
509+
#endif /* WOLFHSM_CFG_TEST_POSIX */
510+
511+
return ret;
512+
}
513+
#endif /* WOLFHSM_CFG_DMA */
514+
383515
static int _benchAesEcb(whClientContext* client, whBenchOpContext* ctx, int id,
384516
const uint8_t* key, size_t keyLen, int encrypt)
385517
{
@@ -510,6 +642,74 @@ int wh_Bench_Mod_Aes256ECBDecrypt(whClientContext* client,
510642
return _benchAesEcb(client, ctx, id, (uint8_t*)key256, sizeof(key256),
511643
DECRYPT);
512644
}
645+
646+
int wh_Bench_Mod_Aes128ECBEncryptDma(whClientContext* client,
647+
whBenchOpContext* ctx, int id,
648+
void* params)
649+
{
650+
#if defined(WOLFHSM_CFG_DMA)
651+
(void)params;
652+
return _benchAesEcbDma(client, ctx, id, (uint8_t*)key128, sizeof(key128),
653+
ENCRYPT);
654+
#else
655+
(void)client;
656+
(void)ctx;
657+
(void)id;
658+
(void)params;
659+
return WH_ERROR_NOTIMPL;
660+
#endif
661+
}
662+
663+
int wh_Bench_Mod_Aes128ECBDecryptDma(whClientContext* client,
664+
whBenchOpContext* ctx, int id,
665+
void* params)
666+
{
667+
#if defined(WOLFHSM_CFG_DMA)
668+
(void)params;
669+
return _benchAesEcbDma(client, ctx, id, (uint8_t*)key128, sizeof(key128),
670+
DECRYPT);
671+
#else
672+
(void)client;
673+
(void)ctx;
674+
(void)id;
675+
(void)params;
676+
return WH_ERROR_NOTIMPL;
677+
#endif
678+
}
679+
680+
int wh_Bench_Mod_Aes256ECBEncryptDma(whClientContext* client,
681+
whBenchOpContext* ctx, int id,
682+
void* params)
683+
{
684+
#if defined(WOLFHSM_CFG_DMA)
685+
(void)params;
686+
return _benchAesEcbDma(client, ctx, id, (uint8_t*)key256, sizeof(key256),
687+
ENCRYPT);
688+
#else
689+
(void)client;
690+
(void)ctx;
691+
(void)id;
692+
(void)params;
693+
return WH_ERROR_NOTIMPL;
694+
#endif
695+
}
696+
697+
int wh_Bench_Mod_Aes256ECBDecryptDma(whClientContext* client,
698+
whBenchOpContext* ctx, int id,
699+
void* params)
700+
{
701+
#if defined(WOLFHSM_CFG_DMA)
702+
(void)params;
703+
return _benchAesEcbDma(client, ctx, id, (uint8_t*)key256, sizeof(key256),
704+
DECRYPT);
705+
#else
706+
(void)client;
707+
(void)ctx;
708+
(void)id;
709+
(void)params;
710+
return WH_ERROR_NOTIMPL;
711+
#endif
712+
}
513713
#endif /* HAVE_AES_ECB */
514714

515715
#if defined(HAVE_AES_CBC)

‎benchmark/bench_modules/wh_bench_mod_all.h‎

Lines changed: 16 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -48,6 +48,14 @@ int wh_Bench_Mod_Aes128ECBEncrypt(whClientContext* client,
4848
int wh_Bench_Mod_Aes128ECBDecrypt(whClientContext* client,
4949
whBenchOpContext* ctx, int id, void* params);
5050

51+
int wh_Bench_Mod_Aes128ECBEncryptDma(whClientContext* client,
52+
whBenchOpContext* ctx, int id,
53+
void* params);
54+
55+
int wh_Bench_Mod_Aes128ECBDecryptDma(whClientContext* client,
56+
whBenchOpContext* ctx, int id,
57+
void* params);
58+
5159
int wh_Bench_Mod_Aes128CBCEncrypt(whClientContext* client,
5260
whBenchOpContext* ctx, int id, void* params);
5361

@@ -96,6 +104,14 @@ int wh_Bench_Mod_Aes256ECBEncrypt(whClientContext* client,
96104
int wh_Bench_Mod_Aes256ECBDecrypt(whClientContext* client,
97105
whBenchOpContext* ctx, int id, void* params);
98106

107+
int wh_Bench_Mod_Aes256ECBEncryptDma(whClientContext* client,
108+
whBenchOpContext* ctx, int id,
109+
void* params);
110+
111+
int wh_Bench_Mod_Aes256ECBDecryptDma(whClientContext* client,
112+
whBenchOpContext* ctx, int id,
113+
void* params);
114+
99115
int wh_Bench_Mod_Aes256CBCEncrypt(whClientContext* client,
100116
whBenchOpContext* ctx, int id, void* params);
101117

‎benchmark/wh_bench.c‎

Lines changed: 8 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -97,8 +97,12 @@ typedef enum BenchModuleIdx {
9797
#if defined(HAVE_AES_ECB)
9898
BENCH_MODULE_IDX_AES_128_ECB_ENCRYPT,
9999
BENCH_MODULE_IDX_AES_128_ECB_DECRYPT,
100+
BENCH_MODULE_IDX_AES_128_ECB_ENCRYPT_DMA,
101+
BENCH_MODULE_IDX_AES_128_ECB_DECRYPT_DMA,
100102
BENCH_MODULE_IDX_AES_256_ECB_ENCRYPT,
101103
BENCH_MODULE_IDX_AES_256_ECB_DECRYPT,
104+
BENCH_MODULE_IDX_AES_256_ECB_ENCRYPT_DMA,
105+
BENCH_MODULE_IDX_AES_256_ECB_DECRYPT_DMA,
102106
#endif /* HAVE_AES_ECB */
103107
#if defined(HAVE_AES_CBC)
104108
BENCH_MODULE_IDX_AES_128_CBC_ENCRYPT,
@@ -283,8 +287,12 @@ static BenchModule g_benchModules[] = {
283287
#if defined(HAVE_AES_ECB)
284288
[BENCH_MODULE_IDX_AES_128_ECB_ENCRYPT] = {"AES-128-ECB-Encrypt", wh_Bench_Mod_Aes128ECBEncrypt, BENCH_THROUGHPUT_XBPS, 0, NULL},
285289
[BENCH_MODULE_IDX_AES_128_ECB_DECRYPT] = {"AES-128-ECB-Decrypt", wh_Bench_Mod_Aes128ECBDecrypt, BENCH_THROUGHPUT_XBPS, 0, NULL},
290+
[BENCH_MODULE_IDX_AES_128_ECB_ENCRYPT_DMA] = {"AES-128-ECB-Encrypt-DMA", wh_Bench_Mod_Aes128ECBEncryptDma, BENCH_THROUGHPUT_XBPS, 0, NULL},
291+
[BENCH_MODULE_IDX_AES_128_ECB_DECRYPT_DMA] = {"AES-128-ECB-Decrypt-DMA", wh_Bench_Mod_Aes128ECBDecryptDma, BENCH_THROUGHPUT_XBPS, 0, NULL},
286292
[BENCH_MODULE_IDX_AES_256_ECB_ENCRYPT] = {"AES-256-ECB-Encrypt", wh_Bench_Mod_Aes256ECBEncrypt, BENCH_THROUGHPUT_XBPS, 0, NULL},
287293
[BENCH_MODULE_IDX_AES_256_ECB_DECRYPT] = {"AES-256-ECB-Decrypt", wh_Bench_Mod_Aes256ECBDecrypt, BENCH_THROUGHPUT_XBPS, 0, NULL},
294+
[BENCH_MODULE_IDX_AES_256_ECB_ENCRYPT_DMA] = {"AES-256-ECB-Encrypt-DMA", wh_Bench_Mod_Aes256ECBEncryptDma, BENCH_THROUGHPUT_XBPS, 0, NULL},
295+
[BENCH_MODULE_IDX_AES_256_ECB_DECRYPT_DMA] = {"AES-256-ECB-Decrypt-DMA", wh_Bench_Mod_Aes256ECBDecryptDma, BENCH_THROUGHPUT_XBPS, 0, NULL},
288296
#endif /* HAVE_AES_ECB */
289297
#if defined(HAVE_AES_CBC)
290298
[BENCH_MODULE_IDX_AES_128_CBC_ENCRYPT] = {"AES-128-CBC-Encrypt", wh_Bench_Mod_Aes128CBCEncrypt, BENCH_THROUGHPUT_XBPS, 0, NULL},

‎benchmark/wh_bench_ops.h‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -26,7 +26,7 @@
2626
#include <stdint.h>
2727

2828
/* Maximum number of operations that can be registered */
29-
#define MAX_BENCH_OPS 99
29+
#define MAX_BENCH_OPS 103
3030
/* Maximum length of operation name */
3131
#define MAX_OP_NAME 64
3232

0 commit comments

Comments
 (0)