Expanding static memory DMA offset feature (#191)

* 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

* add return value checks, free in benchmark buffer on error, add macro guards

* fix typo and add fix return value checks

* fix flag for read/write with DMA operations

Author: JacobBarthelmeh

benchmark/bench_modules/wh_bench_mod_cmac.c

@@ -24,6 +24,10 @@
 #if !defined(WOLFHSM_CFG_NO_CRYPTO) && defined(WOLFHSM_CFG_BENCH_ENABLE)
 #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_TEST_POSIX */
+
 #if defined(WOLFSSL_CMAC) && !defined(NO_AES) && defined(WOLFSSL_AES_DIRECT)
 
 static const uint8_t key128[] = {0x2b, 0x7e, 0x15, 0x16, 0x28, 0xae,
@@ -44,10 +48,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),
@@ -57,10 +62,32 @@ 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 defined(WOLFHSM_CFG_TEST_POSIX)
+        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");
+                XFREE(in, heap, DYNAMIC_TYPE_TMP_BUFFER);
+                return WH_ERROR_NOSPACE;
+            }
+        }
+        else {
+            in = WH_BENCH_DMA_BUFFER;
+        }
+#endif /* WOLFHSM_CFG_TEST_POSIX */
     }
     else
 #endif
@@ -101,7 +128,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);
 
@@ -131,6 +158,18 @@ int _benchCmacAes(whClientContext* client, whBenchOpContext* ctx, int id,
             ret = evictRet;
         }
     }
+#if defined(WOLFHSM_CFG_DMA)
+#if defined(WOLFHSM_CFG_TEST_POSIX)
+    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 /* WOLFHSM_CFG_TEST_POSIX */
+#endif
     (void)wc_CmacFree(cmac);
     return ret;
 }

benchmark/bench_modules/wh_bench_mod_sha2.c

@@ -52,7 +52,6 @@ int _benchSha256(whClientContext* client, whBenchOpContext* ctx, int id,
 #if defined(WOLFHSM_CFG_DMA)
     if (devId == WH_DEV_ID_DMA) {
         inLen = WOLFHSM_CFG_BENCH_DMA_BUFFER_SIZE;
-
 #if defined(WOLFHSM_CFG_TEST_POSIX)
         if (ctx->transportType == WH_BENCH_TRANSPORT_POSIX_DMA) {
             /* if static memory was used with DMA then use XMALLOC */
@@ -66,6 +65,7 @@ int _benchSha256(whClientContext* client, whBenchOpContext* ctx, int id,
             out = XMALLOC(WC_SHA256_DIGEST_SIZE, heap, DYNAMIC_TYPE_TMP_BUFFER);
             if (out == NULL) {
                 WH_BENCH_PRINTF("Failed to allocate memory for DMA\n");
+                XFREE((uint8_t*)in, heap, DYNAMIC_TYPE_TMP_BUFFER);
                 return WH_ERROR_NOSPACE;
             }
         }

examples/demo/client/wh_demo_client_crypto.c

@@ -1548,7 +1548,7 @@ int wh_DemoClient_CryptoCmacKdfExport(whClientContext* clientContext)
         (word32)sizeof(demoCmacKdfFixedInfo), derived, (word32)sizeof(derived),
         NULL, WH_DEV_ID);
     if (ret != 0) {
-        printf("Failed to wc_KDA_KDF_twostep_cmac %d\n", ret);
+        WOLFHSM_CFG_PRINTF("Failed to wc_KDA_KDF_twostep_cmac %d\n", ret);
     }
 
     /* The key has now been derived and is stored in the 'derived' array */
@@ -1576,7 +1576,7 @@ int wh_DemoClient_CryptoCmacKdfCache(whClientContext* clientContext)
         (const uint8_t*)label, (uint32_t)strlen(label),
         WH_DEMO_CMAC_KDF_OUT_SZ);
     if (ret != WH_ERROR_OK) {
-        printf("Failed to wh_Client_CmacKdfMakeCacheKey %d\n", ret);
+        WOLFHSM_CFG_PRINTF("Failed to wh_Client_CmacKdfMakeCacheKey %d\n", ret);
         return ret;
     }
 
@@ -1586,7 +1586,7 @@ int wh_DemoClient_CryptoCmacKdfCache(whClientContext* clientContext)
     /* Example: evict the key from cache once we are done with it */
     ret = wh_Client_KeyEvict(clientContext, keyId);
     if (ret != 0) {
-        printf("Failed to wh_Client_KeyEvict %d\n", evictRet);
+        WOLFHSM_CFG_PRINTF("Failed to wh_Client_KeyEvict %d\n", evictRet);
     }
 
     return ret;
@@ -1613,7 +1613,7 @@ int wh_DemoClient_CryptoCmacKdfCacheInputs(whClientContext* clientContext)
                              demoCmacKdfSalt, (uint32_t)sizeof(demoCmacKdfSalt),
                              &saltKeyId);
     if (ret != WH_ERROR_OK) {
-        printf("Failed to cache CMAC KDF salt %d\n", ret);
+        WOLFHSM_CFG_PRINTF("Failed to cache CMAC KDF salt %d\n", ret);
         return ret;
     }
 
@@ -1623,7 +1623,7 @@ int wh_DemoClient_CryptoCmacKdfCacheInputs(whClientContext* clientContext)
                              demoCmacKdfZ, (uint32_t)sizeof(demoCmacKdfZ),
                              &zKeyId);
     if (ret != WH_ERROR_OK) {
-        printf("Failed to cache CMAC KDF Z input %d\n", ret);
+        WOLFHSM_CFG_PRINTF("Failed to cache CMAC KDF Z input %d\n", ret);
         /* Optionally evict the salt key if not needed anymore */
         (void)wh_Client_KeyEvict(clientContext, saltKeyId);
         return ret;
@@ -1643,7 +1643,7 @@ int wh_DemoClient_CryptoCmacKdfCacheInputs(whClientContext* clientContext)
         WH_DEMO_CMAC_KDF_OUT_SZ);
 
     if (ret != WH_ERROR_OK) {
-        printf("Failed to CMAC KDF with cached inputs %d\n", ret);
+        WOLFHSM_CFG_PRINTF("Failed to CMAC KDF with cached inputs %d\n", ret);
     }
 
 

examples/posix/wh_posix_client/wh_posix_client.c

@@ -72,7 +72,7 @@ static int wh_ClientTask(void* cf, const char* type, int test)
     if (ret == 0) {
         ret = wh_Client_CommInit(client, NULL, NULL);
         if (ret != 0) {
-            printf("Failed to initialize client communication\n");
+            WOLFHSM_CFG_PRINTF("Failed to initialize client communication\n");
             return -1;
         }
     }
@@ -93,7 +93,7 @@ static int wh_ClientTask(void* cf, const char* type, int test)
 
     WOLFHSM_CFG_PRINTF("Client connecting to server...\n");
     if (ret == 0 && test) {
-        printf("Running client demos...\n");
+        WOLFHSM_CFG_PRINTF("Running client demos...\n");
         return wh_DemoClient_All(client);
     }
 

examples/posix/wh_posix_server/wh_posix_server.c

@@ -420,7 +420,7 @@ int main(int argc, char** argv)
     (void)clientId;
     rc = wh_ServerTask(s_conf, keyFilePath, keyId, clientId);
     if (rc != WH_ERROR_OK) {
-        printf("Server task failed: %d\n", rc);
+        WOLFHSM_CFG_PRINTF("Server task failed: %d\n", rc);
         return rc;
     }
 #endif

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)