add cmac and start of other hash algos

fix for hash dma additions

mldsa using DMA offset feature

remove unused flag and add malloc to cmac benchmark

add macro guards around DMA additions

fix typo for state address with cmac

run git-clang-format

Author: JacobBarthelmeh

benchmark/bench_modules/wh_bench_mod_cmac.c

@@ -23,6 +23,10 @@
 
 #include "wolfssl/wolfcrypt/cmac.h"
 
+#if defined(WOLFHSM_CFG_DMA) && defined(WOLFHSM_CFG_TEST_POSIX)
+#include "port/posix/posix_transport_shm.h"
+#endif /* WOLFHSM_CFG_DMA && WOLFHSM_CFG_POSIX_TRANSPORT */
+
 #if defined(WOLFHSM_CFG_BENCH_ENABLE)
 
 #if defined(WOLFSSL_CMAC) && !defined(NO_AES) && defined(WOLFSSL_AES_DIRECT)
@@ -45,10 +49,11 @@ int _benchCmacAes(whClientContext* client, whBenchOpContext* ctx, int id,
     whKeyId  keyId = WH_KEYID_ERASED;
     Cmac     cmac[1];
     char     keyLabel[] = "baby's first key";
-    byte     tag[16];
+    byte     tag[WC_CMAC_TAG_MAX_SZ];
     int      i;
     uint8_t* in = NULL;
     size_t   inLen;
+    uint8_t* out = NULL;
 
     /* cache the key on the HSM */
     ret = wh_Client_KeyCache(client, 0, (uint8_t*)keyLabel, sizeof(keyLabel),
@@ -58,10 +63,29 @@ int _benchCmacAes(whClientContext* client, whBenchOpContext* ctx, int id,
         return ret;
     }
 
+    out = tag; /* default to using tag buffer on the stack */
 #if defined(WOLFHSM_CFG_DMA)
     if (devId == WH_DEV_ID_DMA) {
-        in    = WH_BENCH_DMA_BUFFER;
         inLen = WOLFHSM_CFG_BENCH_DMA_BUFFER_SIZE;
+        if (ctx->transportType == WH_BENCH_TRANSPORT_POSIX_DMA) {
+            /* if static memory was used with DMA then use XMALLOC */
+            void* heap =
+                posixTransportShm_GetDmaHeap(client->comm->transport_context);
+            in = (uint8_t*)XMALLOC(inLen, heap, DYNAMIC_TYPE_TMP_BUFFER);
+            if (in == NULL) {
+                WH_BENCH_PRINTF("Failed to allocate memory for DMA\n");
+                return WH_ERROR_NOSPACE;
+            }
+            out = (uint8_t*)XMALLOC(WC_CMAC_TAG_MAX_SZ, heap,
+                                    DYNAMIC_TYPE_TMP_BUFFER);
+            if (out == NULL) {
+                WH_BENCH_PRINTF("Failed to allocate memory for DMA\n");
+                return WH_ERROR_NOSPACE;
+            }
+        }
+        else {
+            in = WH_BENCH_DMA_BUFFER;
+        }
     }
     else
 #endif
@@ -102,7 +126,7 @@ int _benchCmacAes(whClientContext* client, whBenchOpContext* ctx, int id,
         benchStartRet = wh_Bench_StartOp(ctx, id);
         /* Oneshot CMAC through wolfCrypt API will always be most performant
          * implementation */
-        ret = wc_AesCmacGenerate_ex(cmac, tag, &outLen, in, inLen, key, keyLen,
+        ret = wc_AesCmacGenerate_ex(cmac, out, &outLen, in, inLen, key, keyLen,
                                     NULL, devId);
         benchStopRet = wh_Bench_StopOp(ctx, id);
 
@@ -132,6 +156,16 @@ int _benchCmacAes(whClientContext* client, whBenchOpContext* ctx, int id,
             ret = evictRet;
         }
     }
+#if defined(WOLFHSM_CFG_DMA)
+    if (devId == WH_DEV_ID_DMA &&
+        ctx->transportType == WH_BENCH_TRANSPORT_POSIX_DMA) {
+        /* if static memory was used with DMA then use XFREE */
+        void* heap =
+            posixTransportShm_GetDmaHeap(client->comm->transport_context);
+        XFREE(in, heap, DYNAMIC_TYPE_TMP_BUFFER);
+        XFREE(out, heap, DYNAMIC_TYPE_TMP_BUFFER);
+    }
+#endif
     (void)wc_CmacFree(cmac);
     return ret;
 }

src/wh_client.c

@@ -1336,7 +1336,9 @@ int wh_Client_KeyCacheDmaRequest(whClientContext* c, uint32_t flags,
                                  const void* keyAddr, uint16_t keySz,
                                  uint16_t keyId)
 {
+    int                                ret;
     whMessageKeystore_CacheDmaRequest* req = NULL;
+    uintptr_t                          keyAddrPtr = 0;
 
     if (c == NULL || (labelSz > 0 && label == NULL)) {
         return WH_ERROR_BADARGS;
@@ -1352,8 +1354,11 @@ int wh_Client_KeyCacheDmaRequest(whClientContext* c, uint32_t flags,
     req->labelSz = labelSz;
 
     /* Set up DMA buffer info */
-    req->key.addr = (uint64_t)((uintptr_t)keyAddr);
     req->key.sz   = keySz;
+    ret           = wh_Client_DmaProcessClientAddress(
+        c, (uintptr_t)keyAddr, (void**)&keyAddrPtr, keySz,
+        WH_DMA_OPER_CLIENT_READ_PRE, (whDmaFlags){0});
+    req->key.addr = keyAddrPtr;
 
     /* Copy label if provided, truncate if necessary */
     if (labelSz > 0) {
@@ -1363,8 +1368,15 @@ int wh_Client_KeyCacheDmaRequest(whClientContext* c, uint32_t flags,
         memcpy(req->label, label, labelSz);
     }
 
-    return wh_Client_SendRequest(c, WH_MESSAGE_GROUP_KEY, WH_KEY_CACHE_DMA,
-                                 sizeof(*req), (uint8_t*)req);
+    if (ret == WH_ERROR_OK) {
+        ret = wh_Client_SendRequest(c, WH_MESSAGE_GROUP_KEY, WH_KEY_CACHE_DMA,
+                                    sizeof(*req), (uint8_t*)req);
+    }
+
+    (void)wh_Client_DmaProcessClientAddress(
+        c, (uintptr_t)keyAddr, (void**)&keyAddrPtr, keySz,
+        WH_DMA_OPER_CLIENT_READ_POST, (whDmaFlags){0});
+    return ret;
 }
 
 int wh_Client_KeyCacheDmaResponse(whClientContext* c, uint16_t* keyId)