wh_client_crypto.c

/*
 * Copyright (C) 2024 wolfSSL Inc.
 *
 * This file is part of wolfHSM.
 *
 * wolfHSM is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 3 of the License, or
 * (at your option) any later version.
 *
 * wolfHSM is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with wolfHSM.  If not, see <http://www.gnu.org/licenses/>.
 */
/*
 * src/wh_client_crypto.c
 *
 */

/* Pick up compile-time configuration */
#include "wolfhsm/wh_settings.h"

#if !defined(WOLFHSM_CFG_NO_CRYPTO) && defined(WOLFHSM_CFG_ENABLE_CLIENT)

/* System libraries */
#include <stdint.h>
#include <stddef.h> /* For NULL */
#include <string.h> /* For memset, memcpy */


/* Common WolfHSM types and defines shared with the server */
#include "wolfhsm/wh_common.h"
#include "wolfhsm/wh_error.h"
#include "wolfhsm/wh_crypto.h"
#include "wolfhsm/wh_utils.h"


/* Components */
#include "wolfhsm/wh_comm.h"
#if !defined(WOLFHSM_CFG_NO_CRYPTO)
#include "wolfssl/wolfcrypt/settings.h"
#include "wolfssl/wolfcrypt/types.h"
#include "wolfssl/wolfcrypt/error-crypt.h"
#include "wolfssl/wolfcrypt/wc_port.h"
#include "wolfssl/wolfcrypt/cryptocb.h"
#include "wolfssl/wolfcrypt/asn.h"
#include "wolfssl/wolfcrypt/aes.h"
#include "wolfssl/wolfcrypt/cmac.h"
#include "wolfssl/wolfcrypt/rsa.h"
#include "wolfssl/wolfcrypt/ecc.h"
#include "wolfssl/wolfcrypt/curve25519.h"
#include "wolfssl/wolfcrypt/ed25519.h"
#include "wolfssl/wolfcrypt/dilithium.h"
#include "wolfssl/wolfcrypt/sha256.h"
#include "wolfssl/wolfcrypt/sha512.h"
#endif

/* Message definitions */
#include "wolfhsm/wh_message.h"
#include "wolfhsm/wh_message_comm.h"
#include "wolfhsm/wh_message_customcb.h"
#include "wolfhsm/wh_message_crypto.h"

#include "wolfhsm/wh_client.h"
#include "wolfhsm/wh_client_crypto.h"

/** Forward declarations */
#ifdef HAVE_ECC
/* Server creates a key based on incoming flags */
static int _EccMakeKey(whClientContext* ctx, int size, int curveId,
                       whKeyId* inout_key_id, whNvmFlags flags,
                       uint16_t label_len, uint8_t* label, ecc_key* key);
#endif /* HAVE_ECC */

#ifdef HAVE_CURVE25519
/* Server creates a key based on incoming flags */
static int _Curve25519MakeKey(whClientContext* ctx, uint16_t size,
                              whKeyId* inout_key_id, whNvmFlags flags,
                              const uint8_t* label, uint16_t label_len,
                              curve25519_key* key);
#endif /* HAVE_CURVE25519 */

#ifndef NO_RSA
/* Make an RSA key on the server based on the flags */
static int _RsaMakeKey(whClientContext* ctx, uint32_t size, uint32_t e,
                       whNvmFlags flags, uint32_t label_len, uint8_t* label,
                       whKeyId* inout_key_id, RsaKey* rsa);
#endif

#ifdef HAVE_HKDF
/* Generate HKDF output on the server based on the flags */
static int _HkdfMakeKey(whClientContext* ctx, int hashType, whKeyId keyIdIn,
                        const uint8_t* inKey, uint32_t inKeySz,
                        const uint8_t* salt, uint32_t saltSz,
                        const uint8_t* info, uint32_t infoSz, whNvmFlags flags,
                        uint32_t label_len, const uint8_t* label,
                        whKeyId* inout_key_id, uint8_t* out, uint32_t outSz);
#endif

#if defined(HAVE_CMAC_KDF)
static int _CmacKdfMakeKey(whClientContext* ctx, whKeyId saltKeyId,
                           const uint8_t* salt, uint32_t saltSz, whKeyId zKeyId,
                           const uint8_t* z, uint32_t zSz,
                           const uint8_t* fixedInfo, uint32_t fixedInfoSz,
                           whNvmFlags flags, uint32_t label_len,
                           const uint8_t* label, whKeyId* inout_key_id,
                           uint8_t* out, uint32_t outSz);
#endif

#ifdef HAVE_DILITHIUM
/* Make a ML-DSA key on the server based on the flags */
static int _MlDsaMakeKey(whClientContext* ctx, int size, int level,
                         whKeyId* inout_key_id, whNvmFlags flags,
                         uint16_t label_len, uint8_t* label, MlDsaKey* key);

#ifdef WOLFHSM_CFG_DMA
static int _MlDsaMakeKeyDma(whClientContext* ctx, int level,
                            whKeyId* inout_key_id, whNvmFlags flags,
                            uint16_t label_len, uint8_t* label, MlDsaKey* key);
#endif /* WOLFHSM_CFG_DMA */
#endif /* HAVE_DILITHIUM */

#ifndef NO_SHA256
/* Helper function to transfer SHA256 block and update digest */
static int _xferSha256BlockAndUpdateDigest(whClientContext* ctx,
                                           wc_Sha256*       sha256,
                                           uint32_t         isLastBlock);
#endif /* !NO_SHA256 */

#if defined(WOLFSSL_SHA224)
/* Helper function to transfer SHA224 block and update digest */
static int _xferSha224BlockAndUpdateDigest(whClientContext* ctx,
                                           wc_Sha224*       sha224,
                                           uint32_t         isLastBlock);
#endif /* WOLFSSL_SHA224 */

static uint8_t* _createCryptoRequest(uint8_t* reqBuf, uint16_t type,
                                     uint32_t affinity);
static uint8_t* _createCryptoRequestWithSubtype(uint8_t* reqBuf, uint16_t type,
                                                uint16_t algoSubType,
                                                uint32_t affinity);
static int      _getCryptoResponse(uint8_t* respBuf, uint16_t type,
                                   uint8_t** outResponse);


/* Helper function to prepare a crypto request buffer with generic header */
static uint8_t* _createCryptoRequest(uint8_t* reqBuf, uint16_t type,
                                     uint32_t affinity)
{
    return _createCryptoRequestWithSubtype(
        reqBuf, type, WH_MESSAGE_CRYPTO_ALGO_SUBTYPE_NONE, affinity);
}

/* Helper function to prepare a crypto request buffer with generic header and
 * subtype */
static uint8_t* _createCryptoRequestWithSubtype(uint8_t* reqBuf, uint16_t type,
                                                uint16_t algoSubType,
                                                uint32_t affinity)
{
    whMessageCrypto_GenericRequestHeader* header =
        (whMessageCrypto_GenericRequestHeader*)reqBuf;
    header->algoType    = type;
    header->algoSubType = algoSubType;
    header->affinity    = affinity;
    return reqBuf + sizeof(whMessageCrypto_GenericRequestHeader);
}

/* Helper function to validate and extract crypto response */
/* TODO: add algoSubType checking */
static int _getCryptoResponse(uint8_t* respBuf, uint16_t type,
                              uint8_t** outResponse)
{
    whMessageCrypto_GenericResponseHeader* header =
        (whMessageCrypto_GenericResponseHeader*)respBuf;

    if (header->algoType != type) {
        return WH_ERROR_ABORTED;
    }

    if (outResponse != NULL) {
        *outResponse = respBuf + sizeof(whMessageCrypto_GenericResponseHeader);
    }

    return header->rc;
}

/** Implementations */
int wh_Client_RngGenerate(whClientContext* ctx, uint8_t* out, uint32_t size)
{
    int                          ret = WH_ERROR_OK;
    whMessageCrypto_RngRequest*  req;
    whMessageCrypto_RngResponse* res;
    uint8_t*                     dataPtr;
    uint8_t*                     reqData;

    if (ctx == NULL) {
        return WH_ERROR_BADARGS;
    }

    /* Get data buffer */
    dataPtr = wh_CommClient_GetDataPtr(ctx->comm);
    if (dataPtr == NULL) {
        return WH_ERROR_BADARGS;
    }

    /* Setup generic header and get pointer to request data */
    reqData =
        _createCryptoRequest(dataPtr, WC_ALGO_TYPE_RNG, ctx->cryptoAffinity);

    /* Setup request header */
    req = (whMessageCrypto_RngRequest*)reqData;

    /* Calculate maximum data size client can request (subtract headers) */
    const uint32_t client_max_data =
        WOLFHSM_CFG_COMM_DATA_LEN -
        sizeof(whMessageCrypto_GenericRequestHeader) -
        sizeof(whMessageCrypto_RngRequest);

    while ((size > 0) && (ret == WH_ERROR_OK)) {
        /* Request Message */
        uint16_t group   = WH_MESSAGE_GROUP_CRYPTO;
        uint16_t action  = WC_ALGO_TYPE_RNG;
        uint16_t req_len = sizeof(whMessageCrypto_GenericRequestHeader) +
                           sizeof(whMessageCrypto_RngRequest);
        uint16_t res_len;

        /* Request up to client max, but no more than remaining size */
        uint32_t chunk_size = (size < client_max_data) ? size : client_max_data;
        req->sz             = chunk_size;

        WH_DEBUG_CLIENT_VERBOSE("RNG: size:%u reqsz:%u remaining:%u\n",
               (unsigned int)chunk_size, (unsigned int)req_len,
               (unsigned int)size);
        WH_DEBUG_CLIENT_VERBOSE("RNG: req:%p\n", req);

        /* Send request and get response */
        ret = wh_Client_SendRequest(ctx, group, action, req_len, dataPtr);
        if (ret == 0) {
            do {
                ret = wh_Client_RecvResponse(ctx, &group, &action, &res_len,
                                             dataPtr);
            } while (ret == WH_ERROR_NOTREADY);
        }
        if (ret == WH_ERROR_OK) {
            /* Get response */
            ret =
                _getCryptoResponse(dataPtr, WC_ALGO_TYPE_RNG, (uint8_t**)&res);
            if (ret == WH_ERROR_OK) {
                /* Validate server didn't respond with more than requested */
                if (res->sz <= chunk_size) {
                    uint8_t* res_out = (uint8_t*)(res + 1);
                    if (out != NULL) {
                        memcpy(out, res_out, res->sz);
                        out += res->sz;
                    }
                    size -= res->sz;
                    WH_DEBUG_CLIENT_VERBOSE("out size:%u remaining:%u\n",
                           (unsigned int)res->sz, (unsigned int)size);
                    WH_DEBUG_VERBOSE_HEXDUMP("[client] res_out: \n", out - res->sz,
                                     res->sz);
                }
                else {
                    /* Server returned more than we can handle - error */
                    ret = WH_ERROR_ABORTED;
                }
            }
        }
    }
    return ret;
}

#ifdef WOLFHSM_CFG_DMA
int wh_Client_RngGenerateDma(whClientContext* ctx, uint8_t* out, uint32_t size)
{
    int                             ret     = WH_ERROR_OK;
    uint8_t*                        dataPtr = NULL;
    whMessageCrypto_RngDmaRequest*  req     = NULL;
    whMessageCrypto_RngDmaResponse* resp    = NULL;
    uint16_t                        respSz  = 0;
    uintptr_t                       outAddr = 0;

    if ((ctx == NULL) || (out == NULL) || (size == 0)) {
        return WH_ERROR_BADARGS;
    }

    /* Get data pointer from the context to use as request/response storage */
    dataPtr = (uint8_t*)wh_CommClient_GetDataPtr(ctx->comm);
    if (dataPtr == NULL) {
        return WH_ERROR_BADARGS;
    }

    /* Setup generic header and get pointer to request data */
    req = (whMessageCrypto_RngDmaRequest*)_createCryptoRequest(
        dataPtr, WC_ALGO_TYPE_RNG, ctx->cryptoAffinity);

    /* Set up output buffer address and size */
    req->output.sz = size;

    /* Perform address translation for output buffer (PRE operation) */
    ret = wh_Client_DmaProcessClientAddress(
        ctx, (uintptr_t)out, (void**)&outAddr, req->output.sz,
        WH_DMA_OPER_CLIENT_WRITE_PRE, (whDmaFlags){0});
    if (ret == WH_ERROR_OK) {
        req->output.addr = outAddr;
    }

    if (ret == WH_ERROR_OK) {
        /* Send the request to the server */
        ret = wh_Client_SendRequest(
            ctx, WH_MESSAGE_GROUP_CRYPTO_DMA, WC_ALGO_TYPE_RNG,
            sizeof(whMessageCrypto_GenericRequestHeader) + sizeof(*req),
            (uint8_t*)dataPtr);
    }

    if (ret == WH_ERROR_OK) {
        /* Wait for and receive the response */
        do {
            ret = wh_Client_RecvResponse(ctx, NULL, NULL, &respSz,
                                         (uint8_t*)dataPtr);
        } while (ret == WH_ERROR_NOTREADY);
    }

    if (ret == WH_ERROR_OK) {
        /* Get response structure pointer, validates generic header rc */
        ret = _getCryptoResponse(dataPtr, WC_ALGO_TYPE_RNG, (uint8_t**)&resp);
        /* Nothing more to do on success, as server will have written random
         * bytes directly to client memory */
    }

    /* Perform address translation cleanup (POST operation)
     * This is called regardless of successful operation to give the callback a
     * chance for cleanup */
    (void)wh_Client_DmaProcessClientAddress(
        ctx, (uintptr_t)out, (void**)&outAddr, size,
        WH_DMA_OPER_CLIENT_WRITE_POST, (whDmaFlags){0});

    return ret;
}
#endif /* WOLFHSM_CFG_DMA */

#ifndef NO_AES

#ifdef WOLFSSL_AES_COUNTER
int wh_Client_AesCtr(whClientContext* ctx, Aes* aes, int enc, const uint8_t* in,
                     uint32_t len, uint8_t* out)
{
    int                             ret = WH_ERROR_OK;
    whMessageCrypto_AesCtrRequest*  req;
    whMessageCrypto_AesCtrResponse* res;
    uint8_t*                        dataPtr;

    if ((ctx == NULL) || (aes == NULL) || (in == NULL) || (out == NULL)) {
        return WH_ERROR_BADARGS;
    }

    uint32_t       key_len = aes->keylen;
    const uint8_t* key     = (const uint8_t*)(aes->devKey);
    whKeyId        key_id  = WH_DEVCTX_TO_KEYID(aes->devCtx);
    uint8_t*       iv      = (uint8_t*)aes->reg;
    uint32_t       iv_len  = AES_IV_SIZE;
    uint32_t       left    = aes->left;
    uint8_t*       tmp     = (uint8_t*)aes->tmp;

    uint16_t group  = WH_MESSAGE_GROUP_CRYPTO;
    uint16_t action = WC_ALGO_TYPE_CIPHER;
    uint16_t type   = WC_CIPHER_AES_CTR;

    /* Get data buffer */
    dataPtr = wh_CommClient_GetDataPtr(ctx->comm);
    if (dataPtr == NULL) {
        return WH_ERROR_BADARGS;
    }
    /* Setup generic header and get pointer to request data */
    req = (whMessageCrypto_AesCtrRequest*)_createCryptoRequest(
        dataPtr, WC_CIPHER_AES_CTR, ctx->cryptoAffinity);
    uint8_t* req_in  = (uint8_t*)(req + 1);
    uint8_t* req_key = req_in + len;
    uint8_t* req_iv  = req_key + key_len;
    uint8_t* req_tmp = req_iv + iv_len;
    uint32_t req_len = sizeof(whMessageCrypto_GenericRequestHeader) +
                       sizeof(*req) + len + key_len + iv_len +
                       AES_BLOCK_SIZE;
    WH_DEBUG_CLIENT_VERBOSE("enc:%d keylen:%d ivsz:%d insz:%d reqsz:%u "
           "left:%d\n",
           enc, key_len, iv_len, len, req_len, left);
    if (req_len > WOLFHSM_CFG_COMM_DATA_LEN) {
        return WH_ERROR_BADARGS;
    }

    /* setup request packet */
    req->enc    = enc;
    req->keyLen = key_len;
    req->sz     = len;
    req->keyId  = key_id;
    req->left   = left;

    if ((in != NULL) && (len > 0)) {
        memcpy(req_in, in, len);
    }
    if ((key != NULL) && (key_len > 0)) {
        memcpy(req_key, key, key_len);
    }
    if ((iv != NULL) && (iv_len > 0)) {
        memcpy(req_iv, iv, iv_len);
    }
    if (tmp != NULL) {
        memcpy(req_tmp, tmp, AES_BLOCK_SIZE);
    }

    WH_DEBUG_VERBOSE_HEXDUMP("[client] in: \n", req_in, len);
    WH_DEBUG_VERBOSE_HEXDUMP("[client] key: \n", req_key, key_len);
    WH_DEBUG_VERBOSE_HEXDUMP("[client] iv: \n", req_iv, iv_len);
    WH_DEBUG_VERBOSE_HEXDUMP("[client] tmp: \n", req_tmp, AES_BLOCK_SIZE);
    WH_DEBUG_VERBOSE_HEXDUMP("[client] req packet: \n", (uint8_t*)req, req_len);
    ret = wh_Client_SendRequest(ctx, group, action, req_len, dataPtr);
    /* read response */
    if (ret == WH_ERROR_OK) {
        /* Response packet */
        uint16_t res_len = 0;
        do {
            ret =
                wh_Client_RecvResponse(ctx, &group, &action, &res_len, dataPtr);
        } while (ret == WH_ERROR_NOTREADY);
        if (ret == WH_ERROR_OK) {
            ret = _getCryptoResponse(dataPtr, type, (uint8_t**)&res);
            if (ret == WH_ERROR_OK) {
                /* Response packet */
                uint8_t* res_out = (uint8_t*)(res + 1);
                /* tmp buffer follows after the output data */
                uint8_t* res_reg = res_out + res->sz;
                uint8_t* res_tmp = res_reg + AES_BLOCK_SIZE;

                WH_DEBUG_CLIENT_VERBOSE("out size:%d res_len:%d\n", res->sz, res_len);
                WH_DEBUG_VERBOSE_HEXDUMP("[client] res_out: \n", res_out, res->sz);
                WH_DEBUG_VERBOSE_HEXDUMP("[client] res_tmp: \n", res_tmp,
                                 AES_BLOCK_SIZE);
                /* copy the response res_out */
                memcpy(out, res_out, res->sz);
                /* Update the CTR state */
                aes->left = res->left;
                /* Update the iv data */
                memcpy(iv, res_reg, AES_BLOCK_SIZE);
                /* Update the tmp data */
                memcpy(tmp, res_tmp, AES_BLOCK_SIZE);
            }
        }
    }
    return ret;
}

#ifdef WOLFHSM_CFG_DMA
int wh_Client_AesCtrDma(whClientContext* ctx, Aes* aes, int enc,
                        const uint8_t* in, uint32_t len, uint8_t* out)
{
    int                               ret     = WH_ERROR_OK;
    whMessageCrypto_AesCtrDmaRequest* req     = NULL;
    uint8_t*                          dataPtr = NULL;
    uintptr_t                         inAddr  = 0;
    uintptr_t                         outAddr = 0;

    uint16_t group  = WH_MESSAGE_GROUP_CRYPTO_DMA;
    uint16_t action = WC_ALGO_TYPE_CIPHER;
    uint16_t type   = WC_CIPHER_AES_CTR;

    const uint8_t* key     = NULL;
    uint8_t*       iv      = (uint8_t*)aes->reg;
    uint8_t*       tmp     = (uint8_t*)aes->tmp;

    if (ctx == NULL || aes == NULL || in == NULL || out == NULL ) {
        return WH_ERROR_BADARGS;
    }

    /* Get data buffer */
    dataPtr = wh_CommClient_GetDataPtr(ctx->comm);
    if (dataPtr == NULL) {
        return WH_ERROR_BADARGS;
    }

    /* Setup generic header and get pointer to request data */
    req = (whMessageCrypto_AesCtrDmaRequest*)_createCryptoRequest(
        dataPtr, WC_CIPHER_AES_CTR, ctx->cryptoAffinity);
    uint8_t* req_iv = (uint8_t*)req + sizeof(whMessageCrypto_AesCtrDmaRequest);
    uint8_t* req_tmp = req_iv + AES_IV_SIZE;
    uint8_t* req_key = req_tmp + AES_BLOCK_SIZE;
    uint32_t req_len = sizeof(whMessageCrypto_GenericRequestHeader) +
                       sizeof(*req) + AES_IV_SIZE + AES_BLOCK_SIZE;

    /* Setup request packet */
    memset(req, 0, sizeof(*req));
    req->enc  = enc;
    req->left = aes->left;

    req->keyId = WH_DEVCTX_TO_KEYID(aes->devCtx);
    if (req->keyId != WH_KEYID_ERASED) {
        /* Using keyId-based key, server will load it from keystore */
        key        = NULL;
        req->keySz = 0;
    }
    else {
        /* Using direct key */
        key        = (const uint8_t*)(aes->devKey);
        req->keySz = aes->keylen;
        req_len    += req->keySz;
    }

    /* Copy request data not handled by DMA */
    memcpy(req_iv, iv, AES_IV_SIZE);
    memcpy(req_tmp, tmp, AES_BLOCK_SIZE);
    if (key != NULL && req->keySz > 0) {
        memcpy(req_key, key, req->keySz);
    }

    if (ret == WH_ERROR_OK && in != NULL) {
        req->input.sz = len;
        ret           = wh_Client_DmaProcessClientAddress(
            ctx, (uintptr_t)in, (void**)&inAddr, req->input.sz,
            WH_DMA_OPER_CLIENT_READ_PRE, (whDmaFlags){0});
        if (ret == WH_ERROR_OK) {
            req->input.addr = inAddr;
        }
    }

    if (ret == WH_ERROR_OK && out != NULL) {
        req->output.sz = len;
        ret            = wh_Client_DmaProcessClientAddress(
            ctx, (uintptr_t)out, (void**)&outAddr, req->output.sz,
            WH_DMA_OPER_CLIENT_WRITE_PRE, (whDmaFlags){0});
        if (ret == WH_ERROR_OK) {
            req->output.addr = outAddr;
        }
    }

    WH_DEBUG_VERBOSE_HEXDUMP("[client] in: \n", in, len);
    WH_DEBUG_VERBOSE_HEXDUMP("[client] key: \n", req_key, req->keySz);
    WH_DEBUG_VERBOSE_HEXDUMP("[client] iv: \n", req_iv, AES_IV_SIZE);
    WH_DEBUG_VERBOSE_HEXDUMP("[client] tmp: \n", req_tmp, AES_BLOCK_SIZE);

    /* Send request and receive response */
    WH_DEBUG_VERBOSE_HEXDUMP("[client] AESCTR DMA req packet: \n",
                             dataPtr, req_len);
    if (ret == WH_ERROR_OK) {
        ret = wh_Client_SendRequest(ctx, group, action, req_len, dataPtr);
    }
    if (ret == WH_ERROR_OK) {
        uint16_t resLen = 0;
        do {
            ret =
                wh_Client_RecvResponse(ctx, &group, &action, &resLen, dataPtr);
        } while (ret == WH_ERROR_NOTREADY);

        if (ret == WH_ERROR_OK) {
            /* Get response */
            whMessageCrypto_AesCtrDmaResponse* res;
            ret = _getCryptoResponse(dataPtr, type, (uint8_t**)&res);
            /* wolfCrypt allows positive error codes on success in some
             * scenarios */
            if (ret >= WH_ERROR_OK) {
                uint8_t* res_iv = (uint8_t*)res +
                                   sizeof(whMessageCrypto_AesCtrDmaResponse);
                uint8_t* res_tmp = res_iv + AES_IV_SIZE;
                WH_DEBUG_VERBOSE_HEXDUMP("[client] res_iv: \n", res_iv, AES_IV_SIZE);
                WH_DEBUG_VERBOSE_HEXDUMP("[client] res_tmp: \n", res_tmp,
                                         AES_BLOCK_SIZE);

                aes->left = res->left;
                memcpy(iv, res_iv, AES_IV_SIZE);
                memcpy(tmp, res_tmp, AES_BLOCK_SIZE);
                ret = WH_ERROR_OK; /* Success */
            }
        }
    }

    /* post address translation callbacks (for cleanup) */
    if (in != NULL) {
        (void)wh_Client_DmaProcessClientAddress(
            ctx, (uintptr_t)in, (void**)&inAddr, len,
            WH_DMA_OPER_CLIENT_READ_POST, (whDmaFlags){0});
    }
    if (out != NULL) {
        (void)wh_Client_DmaProcessClientAddress(
            ctx, (uintptr_t)out, (void**)&outAddr, len,
            WH_DMA_OPER_CLIENT_WRITE_POST, (whDmaFlags){0});
    }

    return ret;
}
#endif /* WOLFHSM_CFG_DMA */
#endif /* WOLFSSL_AES_COUNTER */

#ifdef HAVE_AES_ECB
int wh_Client_AesEcb(whClientContext* ctx, Aes* aes, int enc, const uint8_t* in,
                     uint32_t len, uint8_t* out)
{
    int                             ret    = WH_ERROR_OK;
    uint16_t                        blocks = len / AES_BLOCK_SIZE;
    whMessageCrypto_AesEcbRequest*  req;
    whMessageCrypto_AesEcbResponse* res;
    uint8_t*                        dataPtr;

    if (blocks == 0) {
        /* Nothing to do. */
        return WH_ERROR_OK;
    }

    if ((ctx == NULL) || (aes == NULL) || ((len % AES_BLOCK_SIZE) != 0) ||
        (in == NULL) || (out == NULL)) {
        return WH_ERROR_BADARGS;
    }

    uint32_t       key_len = aes->keylen;
    const uint8_t* key     = (const uint8_t*)(aes->devKey);
    whKeyId        key_id  = WH_DEVCTX_TO_KEYID(aes->devCtx);

    uint16_t group  = WH_MESSAGE_GROUP_CRYPTO;
    uint16_t action = WC_ALGO_TYPE_CIPHER;
    uint16_t type   = WC_CIPHER_AES_ECB;

    /* Get data buffer */
    dataPtr = wh_CommClient_GetDataPtr(ctx->comm);
    if (dataPtr == NULL) {
        return WH_ERROR_BADARGS;
    }
    /* Setup generic header and get pointer to request data */
    req = (whMessageCrypto_AesEcbRequest*)_createCryptoRequest(
        dataPtr, WC_CIPHER_AES_ECB, ctx->cryptoAffinity);
    uint8_t* req_in  = (uint8_t*)(req + 1);
    uint8_t* req_key = req_in + len;
    uint32_t req_len = sizeof(whMessageCrypto_GenericRequestHeader) +
                       sizeof(*req) + len + key_len;


    WH_DEBUG_CLIENT_VERBOSE("enc:%d keylen:%d insz:%d reqsz:%u blocks:%u \n",
           enc, (int)key_len, (int)len, (unsigned int)req_len,
           (unsigned int)blocks);

    if (req_len > WOLFHSM_CFG_COMM_DATA_LEN) {
        return WH_ERROR_BADARGS;
    }

    /* setup request packet */
    req->enc    = enc;
    req->keyLen = key_len;
    req->sz     = len;
    req->keyId  = key_id;
    if ((in != NULL) && (len > 0)) {
        memcpy(req_in, in, len);
    }
    if ((key != NULL) && (key_len > 0)) {
        memcpy(req_key, key, key_len);
    }

    WH_DEBUG_VERBOSE_HEXDUMP("[client] in: \n", req_in, len);
    WH_DEBUG_VERBOSE_HEXDUMP("[client] key: \n", req_key, key_len);
    WH_DEBUG_VERBOSE_HEXDUMP("[client] req packet: \n", (uint8_t*)req, req_len);
    ret = wh_Client_SendRequest(ctx, group, action, req_len, dataPtr);
    /* read response */
    if (ret == WH_ERROR_OK) {
        /* Response packet */
        uint16_t res_len = 0;
        do {
            ret =
                wh_Client_RecvResponse(ctx, &group, &action, &res_len, dataPtr);
        } while (ret == WH_ERROR_NOTREADY);
        if (ret == WH_ERROR_OK) {
            ret = _getCryptoResponse(dataPtr, type, (uint8_t**)&res);
            if (ret == WH_ERROR_OK) {
                /* Response packet */
                uint8_t* res_out = (uint8_t*)(res + 1);
                WH_DEBUG_CLIENT_VERBOSE("out size:%d res_len:%d\n", (int)res->sz,
                       (int)res_len);
                WH_DEBUG_VERBOSE_HEXDUMP("[client] res_out: \n", out, res->sz);
                /* copy the response res_out */
                memcpy(out, res_out, res->sz);
            }
        }
    }
    return ret;
}

#ifdef WOLFHSM_CFG_DMA
int wh_Client_AesEcbDma(whClientContext* ctx, Aes* aes, int enc,
                        const uint8_t* in, uint32_t len, uint8_t* out)
{
    int                               ret     = WH_ERROR_OK;
    whMessageCrypto_AesEcbDmaRequest* req     = NULL;
    uint8_t*                          dataPtr = NULL;
    uintptr_t                         inAddr  = 0;
    uintptr_t                         outAddr = 0;

    uint16_t       group  = WH_MESSAGE_GROUP_CRYPTO_DMA;
    uint16_t       action = WC_ALGO_TYPE_CIPHER;
    uint16_t       type   = WC_CIPHER_AES_ECB;

    const uint8_t* key    = NULL;

    if (ctx == NULL || aes == NULL || in == NULL || out == NULL) {
        return WH_ERROR_BADARGS;
    }

    if ((len % AES_BLOCK_SIZE) != 0) {
        return WH_ERROR_BADARGS;
    }

    /* Get data buffer */
    dataPtr = wh_CommClient_GetDataPtr(ctx->comm);
    if (dataPtr == NULL) {
        return WH_ERROR_BADARGS;
    }

    /* Setup generic header and get pointer to request data */
    req = (whMessageCrypto_AesEcbDmaRequest*)_createCryptoRequest(
        dataPtr, WC_CIPHER_AES_ECB, ctx->cryptoAffinity);
    uint8_t* req_key = (uint8_t*)req + sizeof(whMessageCrypto_AesEcbDmaRequest);
    uint32_t req_len = sizeof(whMessageCrypto_GenericRequestHeader) +
                       sizeof(*req);

    /* Setup request packet */
    memset(req, 0, sizeof(*req));
    req->enc  = enc;

    req->keyId = WH_DEVCTX_TO_KEYID(aes->devCtx);
    if (req->keyId != WH_KEYID_ERASED) {
        /* Using keyId-based key, server will load it from keystore */
        key        = NULL;
        req->keySz = 0;
    }
    else {
        /* Using direct key */
        key        = (const uint8_t*)(aes->devKey);
        req->keySz = aes->keylen;
        req_len    += req->keySz;
        memcpy(req_key, key, req->keySz);
    }

    if (ret == WH_ERROR_OK && in != NULL) {
        req->input.sz = len;
        ret           = wh_Client_DmaProcessClientAddress(
            ctx, (uintptr_t)in, (void**)&inAddr, req->input.sz,
            WH_DMA_OPER_CLIENT_READ_PRE, (whDmaFlags){0});
        if (ret == WH_ERROR_OK) {
            req->input.addr = inAddr;
        }
    }

    if (ret == WH_ERROR_OK && out != NULL) {
        req->output.sz = len;
        ret            = wh_Client_DmaProcessClientAddress(
            ctx, (uintptr_t)out, (void**)&outAddr, req->output.sz,
            WH_DMA_OPER_CLIENT_WRITE_PRE, (whDmaFlags){0});
        if (ret == WH_ERROR_OK) {
            req->output.addr = outAddr;
        }
    }

    WH_DEBUG_VERBOSE_HEXDUMP("[client] in: \n", in, len);
    WH_DEBUG_VERBOSE_HEXDUMP("[client] key: \n", req_key, req->keySz);

    /* Send request and receive response */
    WH_DEBUG_VERBOSE_HEXDUMP("[client] AESECB DMA req packet: \n",
                            dataPtr, req_len);
    if (ret == WH_ERROR_OK) {
        ret = wh_Client_SendRequest(ctx, group, action, req_len, dataPtr);
    }
    if (ret == WH_ERROR_OK) {
        uint16_t resLen = 0;
        do {
            ret =
                wh_Client_RecvResponse(ctx, &group, &action, &resLen, dataPtr);
        } while (ret == WH_ERROR_NOTREADY);

        if (ret == WH_ERROR_OK) {
            /* Get response */
            whMessageCrypto_AesEcbDmaResponse* res;
            ret = _getCryptoResponse(dataPtr, type, (uint8_t**)&res);
            /* wolfCrypt allows positive error codes on success in some
             * scenarios */
            if (ret >= 0) {
                /* For DMA operations, data is already in client memory,
                 * no need to copy it back */
                ret = WH_ERROR_OK; /* Success */
            }
        }
    }

    /* post address translation callbacks (for cleanup) */
    if (in != NULL) {
        (void)wh_Client_DmaProcessClientAddress(
            ctx, (uintptr_t)in, (void**)&inAddr, len,
            WH_DMA_OPER_CLIENT_READ_POST, (whDmaFlags){0});
    }
    if (out != NULL) {
        (void)wh_Client_DmaProcessClientAddress(
            ctx, (uintptr_t)out, (void**)&outAddr, len,
            WH_DMA_OPER_CLIENT_WRITE_POST, (whDmaFlags){0});
    }

    return ret;
}
#endif /* WOLFHSM_CFG_DMA */
#endif /* HAVE_AES_ECB */

#ifdef HAVE_AES_CBC
int wh_Client_AesCbc(whClientContext* ctx, Aes* aes, int enc, const uint8_t* in,
                     uint32_t len, uint8_t* out)
{
    int                             ret    = WH_ERROR_OK;
    uint16_t                        blocks = len / AES_BLOCK_SIZE;
    whMessageCrypto_AesCbcRequest*  req;
    whMessageCrypto_AesCbcResponse* res;
    uint8_t*                        dataPtr;

    if (blocks == 0) {
        /* Nothing to do. */
        return WH_ERROR_OK;
    }

    if ((ctx == NULL) || (aes == NULL) || ((len % AES_BLOCK_SIZE) != 0) ||
        (in == NULL) || (out == NULL)) {
        return WH_ERROR_BADARGS;
    }

    uint32_t       key_len     = aes->keylen;
    const uint8_t* key         = (const uint8_t*)(aes->devKey);
    whKeyId        key_id      = WH_DEVCTX_TO_KEYID(aes->devCtx);
    uint8_t*       iv          = (uint8_t*)aes->reg;
    uint32_t       iv_len      = AES_IV_SIZE;

    uint16_t group  = WH_MESSAGE_GROUP_CRYPTO;
    uint16_t action = WC_ALGO_TYPE_CIPHER;
    uint16_t type   = WC_CIPHER_AES_CBC;

    /* Get data buffer */
    dataPtr = wh_CommClient_GetDataPtr(ctx->comm);
    if (dataPtr == NULL) {
        return WH_ERROR_BADARGS;
    }
    /* Setup generic header and get pointer to request data */
    req = (whMessageCrypto_AesCbcRequest*)_createCryptoRequest(
        dataPtr, WC_CIPHER_AES_CBC, ctx->cryptoAffinity);
    uint8_t* req_in  = (uint8_t*)(req + 1);
    uint8_t* req_key = req_in + len;
    uint8_t* req_iv  = req_key + key_len;
    uint32_t req_len = sizeof(whMessageCrypto_GenericRequestHeader) +
                       sizeof(*req) + len + key_len + iv_len;

    WH_DEBUG_CLIENT_VERBOSE("enc:%d keylen:%d ivsz:%d insz:%d reqsz:%u "
           "blocks:%u\n",
           enc, (int)key_len, (int)iv_len, (int)len,
           (unsigned int)req_len, (unsigned int)blocks);

    if (req_len > WOLFHSM_CFG_COMM_DATA_LEN) {
        return WH_ERROR_BADARGS;
    }

    /* setup request packet */
    req->enc    = enc;
    req->keyLen = key_len;
    req->sz     = len;
    req->keyId  = key_id;
    if ((in != NULL) && (len > 0)) {
        memcpy(req_in, in, len);
    }
    if ((key != NULL) && (key_len > 0)) {
        memcpy(req_key, key, key_len);
    }
    if ((iv != NULL) && (iv_len > 0)) {
        memcpy(req_iv, iv, iv_len);
    }

    WH_DEBUG_VERBOSE_HEXDUMP("[client] in: \n", req_in, len);
    WH_DEBUG_VERBOSE_HEXDUMP("[client] key: \n", req_key, key_len);
    WH_DEBUG_VERBOSE_HEXDUMP("[client] iv: \n", req_iv, iv_len);
    WH_DEBUG_VERBOSE_HEXDUMP("[client] req packet: \n", (uint8_t*)req, req_len);
    ret = wh_Client_SendRequest(ctx, group, action, req_len, dataPtr);
    /* read response */
    if (ret == WH_ERROR_OK) {
        /* Response packet */
        uint16_t res_len = 0;
        do {
            ret =
                wh_Client_RecvResponse(ctx, &group, &action, &res_len, dataPtr);
        } while (ret == WH_ERROR_NOTREADY);
        if (ret == WH_ERROR_OK) {
            ret = _getCryptoResponse(dataPtr, type, (uint8_t**)&res);
            if (ret == WH_ERROR_OK) {
                /* Response packet */
                uint8_t* res_out = (uint8_t*)(res + 1);
                uint8_t* res_iv = res_out + res->sz;
                WH_DEBUG_CLIENT_VERBOSE("out size:%d res_len:%d\n", (int)res->sz,
                       (int)res_len);
                WH_DEBUG_VERBOSE_HEXDUMP("[client] res_out: \n", out, res->sz);
                WH_DEBUG_VERBOSE_HEXDUMP("[client] res_iv: \n", res_iv, AES_IV_SIZE);
                /* copy the response res_out */
                memcpy(out, res_out, res->sz);
                /* Update the CBC state with the last cipher text block */
                memcpy(iv, res_iv, AES_IV_SIZE);
            }
        }
    }
    return ret;
}

#ifdef WOLFHSM_CFG_DMA
int wh_Client_AesCbcDma(whClientContext* ctx, Aes* aes, int enc,
                        const uint8_t* in, uint32_t len, uint8_t* out)
{
    int                               ret     = WH_ERROR_OK;
    whMessageCrypto_AesCbcDmaRequest* req     = NULL;
    uint8_t*                          dataPtr = NULL;
    uintptr_t                         inAddr  = 0;
    uintptr_t                         outAddr = 0;

    uint16_t       group  = WH_MESSAGE_GROUP_CRYPTO_DMA;
    uint16_t       action = WC_ALGO_TYPE_CIPHER;
    uint16_t       type   = WC_CIPHER_AES_CBC;

    const uint8_t* key    = NULL;
    uint8_t*       iv     = (uint8_t*)aes->reg;

    if (ctx == NULL || aes == NULL || in == NULL || out == NULL) {
        return WH_ERROR_BADARGS;
    }

    if ((len % AES_BLOCK_SIZE) != 0) {
        return WH_ERROR_BADARGS;
    }

    /* Get data buffer */
    dataPtr = wh_CommClient_GetDataPtr(ctx->comm);
    if (dataPtr == NULL) {
        return WH_ERROR_BADARGS;
    }

    /* Setup generic header and get pointer to request data */
    req = (whMessageCrypto_AesCbcDmaRequest*)_createCryptoRequest(
        dataPtr, WC_CIPHER_AES_CBC, ctx->cryptoAffinity);
    uint8_t* req_iv = (uint8_t*)req + sizeof(whMessageCrypto_AesCbcDmaRequest);
    uint8_t* req_key = req_iv + AES_IV_SIZE;
    uint32_t req_len = sizeof(whMessageCrypto_GenericRequestHeader) +
                       sizeof(*req) + AES_IV_SIZE;

    /* Setup request packet */
    memset(req, 0, sizeof(*req));
    req->enc  = enc;

    req->keyId = WH_DEVCTX_TO_KEYID(aes->devCtx);
    if (req->keyId != WH_KEYID_ERASED) {
        /* Using keyId-based key, server will load it from keystore */
        key        = NULL;
        req->keySz = 0;
    }
    else {
        /* Using direct key */
        key    = (const uint8_t*)(aes->devKey);
        req->keySz = aes->keylen;
        req_len    += req->keySz;
    }

    /* Copy request data not handled by DMA */
    memcpy(req_iv, iv, AES_IV_SIZE);
    if (key != NULL && req->keySz > 0) {
        memcpy(req_key, key, req->keySz);
    }

    if (ret == WH_ERROR_OK && in != NULL) {
        req->input.sz = len;
        ret           = wh_Client_DmaProcessClientAddress(
            ctx, (uintptr_t)in, (void**)&inAddr, req->input.sz,
            WH_DMA_OPER_CLIENT_READ_PRE, (whDmaFlags){0});
        if (ret == WH_ERROR_OK) {
            req->input.addr = inAddr;
        }
    }

    if (ret == WH_ERROR_OK && out != NULL) {
        req->output.sz = len;
        ret            = wh_Client_DmaProcessClientAddress(
            ctx, (uintptr_t)out, (void**)&outAddr, req->output.sz,
            WH_DMA_OPER_CLIENT_WRITE_PRE, (whDmaFlags){0});
        if (ret == WH_ERROR_OK) {
            req->output.addr = outAddr;
        }
    }

    WH_DEBUG_VERBOSE_HEXDUMP("[client] key: \n", req_key, req->keySz);
    WH_DEBUG_VERBOSE_HEXDUMP("[client] iv: \n", req_iv, AES_IV_SIZE);

    /* Send request and receive response */
    WH_DEBUG_VERBOSE_HEXDUMP("[client] AESCBC DMA req packet: \n",
                            dataPtr, req_len);
    if (ret == WH_ERROR_OK) {
        ret = wh_Client_SendRequest(ctx, group, action, req_len, dataPtr);
    }
    if (ret == WH_ERROR_OK) {
        uint16_t resLen = 0;
        do {
            ret =
                wh_Client_RecvResponse(ctx, &group, &action, &resLen, dataPtr);
        } while (ret == WH_ERROR_NOTREADY);

        if (ret == WH_ERROR_OK) {
            /* Get response */
            whMessageCrypto_AesCbcDmaResponse* res;
            ret = _getCryptoResponse(dataPtr, type, (uint8_t**)&res);
            /* wolfCrypt allows positive error codes on success in some
             * scenarios */
            if (ret >= WH_ERROR_OK) {
                uint8_t* res_iv = (uint8_t*)res +
                                   sizeof(whMessageCrypto_AesCbcDmaResponse);
                WH_DEBUG_VERBOSE_HEXDUMP("[client] res_iv: \n", res_iv,
                                         AES_IV_SIZE);
                memcpy(iv, res_iv, AES_IV_SIZE);
                ret = WH_ERROR_OK; /* Success */
            }
        }
    }

    /* post address translation callbacks (for cleanup) */
    if (in != NULL) {
        (void)wh_Client_DmaProcessClientAddress(
            ctx, (uintptr_t)in, (void**)&inAddr, len,
            WH_DMA_OPER_CLIENT_READ_POST, (whDmaFlags){0});
    }
    if (out != NULL) {
        (void)wh_Client_DmaProcessClientAddress(
            ctx, (uintptr_t)out, (void**)&outAddr, len,
            WH_DMA_OPER_CLIENT_WRITE_POST, (whDmaFlags){0});
    }

    return ret;
}
#endif /* WOLFHSM_CFG_DMA */

int wh_Client_AesCbcRequest(whClientContext* ctx, Aes* aes, int enc,
                            const uint8_t* in, uint32_t len)
{
    whMessageCrypto_AesCbcRequest* req;
    uint8_t*                       dataPtr;
    uint16_t                       blocks;
    uint32_t                       key_len;
    const uint8_t*                 key;
    whKeyId                        key_id;
    uint8_t*                       iv;
    uint32_t                       iv_len;
    uint8_t*                       req_in;
    uint8_t*                       req_key;
    uint8_t*                       req_iv;
    uint32_t                       req_len;

    if ((ctx == NULL) || (aes == NULL) || ((len % AES_BLOCK_SIZE) != 0) ||
        (in == NULL)) {
        return WH_ERROR_BADARGS;
    }

    blocks = len / AES_BLOCK_SIZE;

    if (blocks == 0) {
        return WH_ERROR_OK;
    }

    key_len = aes->keylen;
    key     = (const uint8_t*)(aes->devKey);
    key_id  = WH_DEVCTX_TO_KEYID(aes->devCtx);
    iv      = (uint8_t*)aes->reg;
    iv_len  = AES_IV_SIZE;

    dataPtr = wh_CommClient_GetDataPtr(ctx->comm);
    if (dataPtr == NULL) {
        return WH_ERROR_BADARGS;
    }

    req = (whMessageCrypto_AesCbcRequest*)_createCryptoRequest(
        dataPtr, WC_CIPHER_AES_CBC, ctx->cryptoAffinity);
    req_in  = (uint8_t*)(req + 1);
    req_key = req_in + len;
    req_iv  = req_key + key_len;
    req_len = sizeof(whMessageCrypto_GenericRequestHeader) +
              sizeof(*req) + len + key_len + iv_len;

    if (req_len > WOLFHSM_CFG_COMM_DATA_LEN) {
        return WH_ERROR_BADARGS;
    }

    req->enc    = enc;
    req->keyLen = key_len;
    req->sz     = len;
    req->keyId  = key_id;
    if ((in != NULL) && (len > 0)) {
        memcpy(req_in, in, len);
    }
    if ((key != NULL) && (key_len > 0)) {
        memcpy(req_key, key, key_len);
    }
    if ((iv != NULL) && (iv_len > 0)) {
        memcpy(req_iv, iv, iv_len);
    }

    /* For decryption, update the IV with the last ciphertext block before
     * sending, since the input buffer may be reused for output (in-place) */
    if (enc == 0) {
        uint32_t last_offset = (blocks - 1) * AES_BLOCK_SIZE;
        memcpy(iv, in + last_offset, iv_len);
    }

    return wh_Client_SendRequest(ctx, WH_MESSAGE_GROUP_CRYPTO,
                                 WC_ALGO_TYPE_CIPHER, req_len, dataPtr);
}

int wh_Client_AesCbcResponse(whClientContext* ctx, Aes* aes, uint8_t* out,
                             uint32_t* out_size)
{
    int                             ret;
    uint8_t*                        dataPtr;
    uint16_t                        group   = 0;
    uint16_t                        action  = 0;
    uint16_t                        res_len = 0;
    whMessageCrypto_AesCbcResponse* res;

    if ((ctx == NULL) || (aes == NULL) || (out == NULL)) {
        return WH_ERROR_BADARGS;
    }

    dataPtr = wh_CommClient_GetDataPtr(ctx->comm);
    if (dataPtr == NULL) {
        return WH_ERROR_BADARGS;
    }

    ret = wh_Client_RecvResponse(ctx, &group, &action, &res_len, dataPtr);
    if (ret == WH_ERROR_OK) {
        ret = _getCryptoResponse(dataPtr, WC_CIPHER_AES_CBC, (uint8_t**)&res);
        if (ret == WH_ERROR_OK) {
            uint8_t* res_out = (uint8_t*)(res + 1);
            uint8_t* res_iv  = res_out + res->sz;
            memcpy(out, res_out, res->sz);
            /* Update the IV from the server response for CBC chaining.
             * The server provides the updated IV after the output data. */
            memcpy((uint8_t*)aes->reg, res_iv, AES_IV_SIZE);
            if (out_size != NULL) {
                *out_size = res->sz;
            }
        }
    }

    return ret;
}
#endif /* HAVE_AES_CBC */

#ifdef HAVE_AESGCM
int wh_Client_AesGcm(whClientContext* ctx, Aes* aes, int enc, const uint8_t* in,
                     uint32_t len, const uint8_t* iv, uint32_t iv_len,
                     const uint8_t* authin, uint32_t authin_len,
                     const uint8_t* dec_tag, uint8_t* enc_tag, uint32_t tag_len,
                     uint8_t* out)
{
    int ret = WH_ERROR_OK;

    if ((ctx == NULL) || (aes == NULL) || ((in == NULL) && (len > 0)) ||
        ((iv == NULL) && (iv_len > 0)) ||
        ((authin == NULL) && (authin_len > 0)) ||
        ((enc == 0) && (dec_tag == NULL))) {
        return WH_ERROR_BADARGS;
    }

    uint16_t group  = WH_MESSAGE_GROUP_CRYPTO;
    uint16_t action = WC_ALGO_TYPE_CIPHER;
    uint16_t type   = WC_CIPHER_AES_GCM;

    uint32_t       key_len = aes->keylen;
    const uint8_t* key     = (const uint8_t*)(aes->devKey);
    whKeyId        key_id  = WH_DEVCTX_TO_KEYID(aes->devCtx);


    /* Get data buffer */
    uint8_t* dataPtr = wh_CommClient_GetDataPtr(ctx->comm);
    if (dataPtr == NULL) {
        return WH_ERROR_BADARGS;
    }

    /* Setup generic header and get pointer to request data */
    whMessageCrypto_AesGcmRequest* req =
        (whMessageCrypto_AesGcmRequest*)_createCryptoRequest(
            dataPtr, WC_CIPHER_AES_GCM, ctx->cryptoAffinity);

    uint8_t* req_in     = (uint8_t*)(req + 1);
    uint8_t* req_key    = req_in + len;
    uint8_t* req_iv     = req_key + key_len;
    uint8_t* req_authin = req_iv + iv_len;
    uint8_t* req_tag    = req_authin + authin_len;

    uint32_t req_len = sizeof(whMessageCrypto_GenericRequestHeader) +
                       sizeof(*req) + len + key_len + iv_len + authin_len +
                       ((enc == 0) ? tag_len : 0);

    WH_DEBUG_CLIENT_VERBOSE("AESGCM: enc:%d keylen:%d ivsz:%d insz:%d authinsz:%d "
           "authtagsz:%d reqsz:%u\n",
           enc, (int)key_len, (int)iv_len, (int)len, (int)authin_len,
           (int)tag_len, (unsigned int)req_len);
    WH_DEBUG_CLIENT_VERBOSE("AESGCM: req:%p in:%p key:%p iv:%p authin:%p tag:%p\n", req,
           req_in, req_key, req_iv, req_authin, req_tag);
    if (req_len > WOLFHSM_CFG_COMM_DATA_LEN) {
        return WH_ERROR_BADARGS;
    }

    /* setup request packet */
    req->enc       = enc;
    req->keyLen    = key_len;
    req->sz        = len;
    req->ivSz      = iv_len;
    req->authInSz  = authin_len;
    req->authTagSz = tag_len;
    req->keyId     = key_id;

    if (in != NULL && len > 0) {
        memcpy(req_in, in, len);
    }
    if (key != NULL && key_len > 0) {
        memcpy(req_key, key, key_len);
    }
    if (iv != NULL && iv_len > 0) {
        memcpy(req_iv, iv, iv_len);
    }
    if (authin != NULL && authin_len > 0) {
        memcpy(req_authin, authin, authin_len);
    }

    WH_DEBUG_VERBOSE_HEXDUMP("[client] in: \n", req_in, len);
    WH_DEBUG_VERBOSE_HEXDUMP("[client] key: \n", req_key, key_len);
    WH_DEBUG_VERBOSE_HEXDUMP("[client] iv: \n", req_iv, iv_len);
    WH_DEBUG_VERBOSE_HEXDUMP("[client] authin: \n", req_authin, authin_len);

    /* set auth tag by direction */
    if (enc == 0 && dec_tag != NULL && tag_len > 0) {
        memcpy(req_tag, dec_tag, tag_len);
        WH_DEBUG_VERBOSE_HEXDUMP("[client] dec tag: \n", req_tag, tag_len);
    }

    WH_DEBUG_VERBOSE_HEXDUMP("[client] AESGCM req packet: \n", dataPtr, req_len);

    /* Send request and receive response */
    ret = wh_Client_SendRequest(ctx, group, action, req_len, dataPtr);
    if (ret == WH_ERROR_OK) {
        uint16_t res_len = 0;
        do {
            ret =
                wh_Client_RecvResponse(ctx, &group, &action, &res_len, dataPtr);
        } while (ret == WH_ERROR_NOTREADY);

        if (ret == WH_ERROR_OK) {
            /* Get response */
            whMessageCrypto_AesGcmResponse* res;
            ret = _getCryptoResponse(dataPtr, type, (uint8_t**)&res);
            /* wolfCrypt allows positive error codes on success in some
             * scenarios */
            if (ret >= WH_ERROR_OK) {
                /* The encrypted/decrypted data follows directly after the
                 * response struct */
                uint8_t* res_out = (uint8_t*)(res + 1);
                /* The auth tag follows after the output data */
                uint8_t* res_tag = res_out + res->sz;

                WH_DEBUG_CLIENT_VERBOSE("out size:%d datasz:%d tag_len:%d\n",
                       (int)res->sz, (int)res_len, (int)res->authTagSz);
                WH_DEBUG_VERBOSE_HEXDUMP("[client] res_out: \n", res_out, res->sz);
                if (enc != 0 && res->authTagSz > 0) {
                    WH_DEBUG_VERBOSE_HEXDUMP("[client] res_tag: \n", res_tag,
                                     res->authTagSz);
                }
                /* copy the response result if present */
                if (out != NULL && res->sz == len) {
                    memcpy(out, res_out, res->sz);
                }

                /* write the authTag if applicable */
                if (enc != 0 && enc_tag != NULL && res->authTagSz > 0 &&
                    res->authTagSz <= tag_len) {
                    memcpy(enc_tag, res_tag, res->authTagSz);
                    WH_DEBUG_CLIENT_VERBOSE("res tag_len:%d exp tag_len:%u",
                           (int)res->authTagSz, (unsigned int)tag_len);
                    WH_DEBUG_VERBOSE_HEXDUMP("[client] enc authtag: ", enc_tag,
                                     res->authTagSz);
                }
            }
        }
    }

    return ret;
}

#ifdef WOLFHSM_CFG_DMA
int wh_Client_AesGcmDma(whClientContext* ctx, Aes* aes, int enc,
                        const uint8_t* in, uint32_t len, const uint8_t* iv,
                        uint32_t iv_len, const uint8_t* authin,
                        uint32_t authin_len, const uint8_t* dec_tag,
                        uint8_t* enc_tag, uint32_t tag_len, uint8_t* out)
{
    int                               ret         = WH_ERROR_OK;
    whMessageCrypto_AesGcmDmaRequest* req         = NULL;
    uint8_t*                          dataPtr     = NULL;
    uintptr_t                         inAddr      = 0;
    uintptr_t                         outAddr     = 0;
    uintptr_t                         aadAddr     = 0;

    uint16_t group  = WH_MESSAGE_GROUP_CRYPTO_DMA;
    uint16_t action = WC_ALGO_TYPE_CIPHER;
    uint16_t type   =  WC_CIPHER_AES_GCM;

    const uint8_t* key    = NULL;

    if (ctx == NULL || aes == NULL) {
        return WH_ERROR_BADARGS;
    }

    if ((in == NULL) && (len > 0)) {
        return WH_ERROR_BADARGS;
    }

    if ((iv == NULL) && (iv_len > 0)) {
        return WH_ERROR_BADARGS;
    }

    if ((authin == NULL) && (authin_len > 0)) {
        return WH_ERROR_BADARGS;
    }

    if ((enc == 0) && (dec_tag == NULL)) {
        return WH_ERROR_BADARGS;
    }

    /* Get data buffer */
    dataPtr = wh_CommClient_GetDataPtr(ctx->comm);
    if (dataPtr == NULL) {
        return WH_ERROR_BADARGS;
    }

    /* Setup generic header and get pointer to request data */
    req = (whMessageCrypto_AesGcmDmaRequest*)_createCryptoRequest(
        dataPtr, WC_CIPHER_AES_GCM, ctx->cryptoAffinity);
    uint8_t* req_iv = (uint8_t*)req + sizeof(whMessageCrypto_AesGcmDmaRequest);
    uint8_t* req_tag = req_iv + iv_len;
    uint8_t* req_key = req_tag + (enc != 0 ? 0 : tag_len);
    uint32_t req_len = sizeof(whMessageCrypto_GenericRequestHeader) +
                       sizeof(*req) + iv_len + (enc != 0 ? 0 : tag_len);

    /* Setup request packet */
    memset(req, 0, sizeof(*req));
    req->enc  = enc;
    req->ivSz = iv_len;
    req->authTagSz = tag_len;

    req->keyId = WH_DEVCTX_TO_KEYID(aes->devCtx);
    if (req->keyId != WH_KEYID_ERASED) {
        /* Using keyId-based key, server will load it from keystore */
        key        = NULL;
        req->keySz = 0;
    }
    else {
        /* Using direct key */
        key        = (const uint8_t*)(aes->devKey);
        req->keySz = aes->keylen;
        req_len    += req->keySz;
    }

    if (req_len > WOLFHSM_CFG_COMM_DATA_LEN) {
        return WH_ERROR_BADARGS;
    }

    /* Copy request data not handled by DMA */
    memcpy(req_iv, iv, iv_len);
    if (enc == 0 && tag_len > 0) {
        memcpy(req_tag, dec_tag, tag_len);
        WH_DEBUG_VERBOSE_HEXDUMP("[client] dec tag: \n", dec_tag, tag_len);
    }
    if (key != NULL && req->keySz > 0) {
        memcpy(req_key, key, req->keySz);
    }

    if (ret == WH_ERROR_OK && in != NULL) {
        req->input.sz = len;
        ret           = wh_Client_DmaProcessClientAddress(
            ctx, (uintptr_t)in, (void**)&inAddr, req->input.sz,
            WH_DMA_OPER_CLIENT_READ_PRE, (whDmaFlags){0});
        if (ret == WH_ERROR_OK) {
            req->input.addr = inAddr;
        }
    }

    if (ret == WH_ERROR_OK && out != NULL) {
        req->output.sz = len;
        ret            = wh_Client_DmaProcessClientAddress(
            ctx, (uintptr_t)out, (void**)&outAddr, req->output.sz,
            WH_DMA_OPER_CLIENT_WRITE_PRE, (whDmaFlags){0});
        if (ret == WH_ERROR_OK) {
            req->output.addr = outAddr;
        }
    }

    if (ret == WH_ERROR_OK && authin != NULL) {
        req->aad.sz = authin_len;
        ret         = wh_Client_DmaProcessClientAddress(
            ctx, (uintptr_t)authin, (void**)&aadAddr, req->aad.sz,
            WH_DMA_OPER_CLIENT_READ_PRE, (whDmaFlags){0});
        if (ret == WH_ERROR_OK) {
            req->aad.addr = aadAddr;
        }
    }

    WH_DEBUG_VERBOSE_HEXDUMP("[client] key: \n", req_key, req->keySz);
    WH_DEBUG_VERBOSE_HEXDUMP("[client] iv: \n", req_iv, iv_len);
    WH_DEBUG_VERBOSE_HEXDUMP("[client] authin: \n", authin, authin_len);

    /* Send request and receive response */
    WH_DEBUG_VERBOSE_HEXDUMP("[client] AESGCM DMA req packet: \n", dataPtr, req_len);
    if (ret == WH_ERROR_OK) {
        ret = wh_Client_SendRequest(ctx, group, action, req_len, dataPtr);
    }
    if (ret == WH_ERROR_OK) {
        uint16_t resLen = 0;
        do {
            ret =
                wh_Client_RecvResponse(ctx, &group, &action, &resLen, dataPtr);
        } while (ret == WH_ERROR_NOTREADY);

        if (ret == WH_ERROR_OK) {
            /* Get response */
            whMessageCrypto_AesGcmDmaResponse* res;
            ret = _getCryptoResponse(dataPtr, type, (uint8_t**)&res);
            /* wolfCrypt allows positive error codes on success in some
             * scenarios */
            if (ret >= WH_ERROR_OK) {
                /* Write the authTag is applicable */
                if (enc != 0 && enc_tag != NULL && res->authTagSz > 0 &&
                    res->authTagSz <= tag_len) {
                    uint8_t* res_tag = (uint8_t*)res +
                                       sizeof(whMessageCrypto_AesGcmDmaResponse);
                    memcpy(enc_tag, res_tag, res->authTagSz);
                    WH_DEBUG_CLIENT_VERBOSE("res tag_len:%d exp tag_len:%u",
                            (int)res->authTagSz, (unsigned int)tag_len);
                    WH_DEBUG_VERBOSE_HEXDUMP("[client] enc authtag: ", enc_tag,
                                             res->authTagSz);
                }
                ret = WH_ERROR_OK; /* Success */
            }
        }
    }

    /* post address translation callbacks (for cleanup) */
    if (in != NULL) {
        (void)wh_Client_DmaProcessClientAddress(
            ctx, (uintptr_t)in, (void**)&inAddr, len,
            WH_DMA_OPER_CLIENT_READ_POST, (whDmaFlags){0});
    }
    if (out != NULL) {
        (void)wh_Client_DmaProcessClientAddress(
            ctx, (uintptr_t)out, (void**)&outAddr, len,
            WH_DMA_OPER_CLIENT_WRITE_POST, (whDmaFlags){0});
    }
    if (authin != NULL) {
        (void)wh_Client_DmaProcessClientAddress(
            ctx, (uintptr_t)authin, (void**)&aadAddr, authin_len,
            WH_DMA_OPER_CLIENT_READ_POST, (whDmaFlags){0});
    }

    return ret;
}
#endif /* WOLFHSM_CFG_DMA */
#endif /* HAVE_AESGCM */

#endif /* !NO_AES */

#ifdef HAVE_ECC
int wh_Client_EccSetKeyId(ecc_key* key, whKeyId keyId)
{
    if (key == NULL) {
        return WH_ERROR_BADARGS;
    }
    key->devCtx = WH_KEYID_TO_DEVCTX(keyId);
    return WH_ERROR_OK;
}

int wh_Client_EccGetKeyId(ecc_key* key, whKeyId* outId)
{
    if ((key == NULL) || (outId == NULL)) {
        return WH_ERROR_BADARGS;
    }
    *outId = WH_DEVCTX_TO_KEYID(key->devCtx);
    return WH_ERROR_OK;
}

int wh_Client_EccImportKey(whClientContext* ctx, ecc_key* key,
                           whKeyId* inout_keyId, whNvmFlags flags,
                           uint16_t label_len, uint8_t* label)
{
    int      ret                 = WH_ERROR_OK;
    whKeyId  key_id              = WH_KEYID_ERASED;
    byte     buffer[ECC_BUFSIZE] = {0};
    uint16_t buffer_len          = 0;

    if ((ctx == NULL) || (key == NULL) ||
        ((label_len != 0) && (label == NULL))) {
        return WH_ERROR_BADARGS;
    }

    if (inout_keyId != NULL) {
        key_id = *inout_keyId;
    }

    ret =
        wh_Crypto_EccSerializeKeyDer(key, sizeof(buffer), buffer, &buffer_len);
    WH_DEBUG_CLIENT_VERBOSE("serialize ret:%d, key:%p, max_size:%u, buffer:%p, "
           "outlen:%u\n",
           ret, key, (unsigned int)sizeof(buffer), buffer,
           buffer_len);
    if (ret == WH_ERROR_OK) {
        /* Cache the key and get the keyID */
        ret = wh_Client_KeyCache(ctx, flags, label, label_len, buffer,
                                 buffer_len, &key_id);
        if ((ret == WH_ERROR_OK) && (inout_keyId != NULL)) {
            *inout_keyId = key_id;
        }
    }

    WH_DEBUG_CLIENT_VERBOSE("label:%.*s ret:%d keyid:%u\n", label_len,
           label, ret, key_id);
    return ret;
}

int wh_Client_EccExportKey(whClientContext* ctx, whKeyId keyId, ecc_key* key,
                           uint16_t label_len, uint8_t* label)
{
    int ret = WH_ERROR_OK;
    /* buffer cannot be larger than MTU */
    byte     buffer[ECC_BUFSIZE] = {0};
    uint16_t buffer_len          = sizeof(buffer);

    if ((ctx == NULL) || WH_KEYID_ISERASED(keyId) || (key == NULL)) {
        return WH_ERROR_BADARGS;
    }

    /* Now export the key from the server */
    ret =
        wh_Client_KeyExport(ctx, keyId, label, label_len, buffer, &buffer_len);
    if (ret == WH_ERROR_OK) {
        /* Update the key structure */
        ret = wh_Crypto_EccDeserializeKeyDer(buffer, buffer_len, key);
    }

    WH_DEBUG_CLIENT_VERBOSE("keyid:%x key:%p ret:%d label:%.*s\n", keyId,
           key, ret, (int)label_len, label);
    return ret;
}

static int _EccMakeKey(whClientContext* ctx, int size, int curveId,
                       whKeyId* inout_key_id, whNvmFlags flags,
                       uint16_t label_len, uint8_t* label, ecc_key* key)
{
    int                                ret     = WH_ERROR_OK;
    whKeyId                            key_id  = WH_KEYID_ERASED;
    uint8_t*                           dataPtr = NULL;
    whMessageCrypto_EccKeyGenRequest*  req     = NULL;
    whMessageCrypto_EccKeyGenResponse* res     = NULL;

    if (ctx == NULL) {
        return WH_ERROR_BADARGS;
    }

    /* Get data pointer from the context to use as request/response storage */
    dataPtr = wh_CommClient_GetDataPtr(ctx->comm);
    if (dataPtr == NULL) {
        return WH_ERROR_BADARGS;
    }

    /* Setup generic header and get pointer to request data */
    req = (whMessageCrypto_EccKeyGenRequest*)_createCryptoRequest(
        dataPtr, WC_PK_TYPE_EC_KEYGEN, ctx->cryptoAffinity);

    /* Use the supplied key id if provided */
    if (inout_key_id != NULL) {
        key_id = *inout_key_id;
    }

    /* No other calls before here, so this is always true */
    if (ret == WH_ERROR_OK) {
        /* Request Message */
        uint16_t group  = WH_MESSAGE_GROUP_CRYPTO;
        uint16_t action = WC_ALGO_TYPE_PK;

        uint16_t req_len =
            sizeof(whMessageCrypto_GenericRequestHeader) + sizeof(*req);

        if (req_len <= WOLFHSM_CFG_COMM_DATA_LEN) {
            memset(req, 0, sizeof(*req));
            req->sz      = size;
            req->curveId = curveId;
            req->flags   = flags;
            req->keyId   = key_id;
            if ((label != NULL) && (label_len > 0)) {
                if (label_len > WH_NVM_LABEL_LEN) {
                    label_len = WH_NVM_LABEL_LEN;
                }
                memcpy(req->label, label, label_len);
            }

            ret = wh_Client_SendRequest(ctx, group, action, req_len,
                                        (uint8_t*)dataPtr);
            WH_DEBUG_CLIENT_VERBOSE("Req sent:size:%u, ret:%d\n",
                   (unsigned int)req->sz, ret);
            if (ret == WH_ERROR_OK) {
                /* Response Message */
                uint16_t res_len;
                do {
                    ret = wh_Client_RecvResponse(ctx, &group, &action, &res_len,
                                                 (uint8_t*)dataPtr);
                } while (ret == WH_ERROR_NOTREADY);

                if (ret == WH_ERROR_OK) {
                    /* Get response structure pointer, validates generic header
                     * rc */
                    ret = _getCryptoResponse(dataPtr, WC_PK_TYPE_EC_KEYGEN,
                                             (uint8_t**)&res);
                    WH_DEBUG_CLIENT_VERBOSE("Res recv:keyid:%u, len:%u, ret:%d\n",
                           (unsigned int)res->keyId,
                           (unsigned int)res->len, ret);
                    /* wolfCrypt allows positive error codes on success in some
                     * scenarios */
                    if (ret >= 0) {
                        /* Key is cached on server or is ephemeral */
                        key_id = (whKeyId)(res->keyId);

                        /* Update output variable if requested */
                        if (inout_key_id != NULL) {
                            *inout_key_id = key_id;
                        }

                        /* Update the context if provided */
                        if (key != NULL) {
                            /* Set the key_id.  Should be ERASED if EPHEMERAL */
                            wh_Client_EccSetKeyId(key, key_id);

                            if (flags & WH_NVM_FLAGS_EPHEMERAL) {
                                uint8_t* key_der  = (uint8_t*)(res + 1);
                                uint16_t der_size = (uint16_t)(res->len);
                                /* Response has the exported key */
                                ret = wh_Crypto_EccDeserializeKeyDer(
                                    key_der, der_size, key);
                                WH_DEBUG_VERBOSE_HEXDUMP("[client] KeyGen export:",
                                                 key_der, der_size);
                            }
                        }
                    }
                }
            }
        }
        else {
            ret = WH_ERROR_BADARGS;
        }
    }
    return ret;
}

int wh_Client_EccMakeCacheKey(whClientContext* ctx, int size, int curveId,
                              whKeyId* inout_key_id, whNvmFlags flags,
                              uint16_t label_len, uint8_t* label)
{
    if (inout_key_id == NULL) {
        return WH_ERROR_BADARGS;
    }

    return _EccMakeKey(ctx, size, curveId, inout_key_id, flags, label_len,
                       label, NULL);
}

int wh_Client_EccMakeExportKey(whClientContext* ctx, int size, int curveId,
                               ecc_key* key)
{
    if (key == NULL) {
        return WH_ERROR_BADARGS;
    }

    return _EccMakeKey(ctx, size, curveId, NULL, WH_NVM_FLAGS_EPHEMERAL, 0,
                       NULL, key);
}

int wh_Client_EccSharedSecret(whClientContext* ctx, ecc_key* priv_key,
                              ecc_key* pub_key, uint8_t* out,
                              uint16_t* out_size)
{
    int                           ret     = WH_ERROR_OK;
    uint8_t*                      dataPtr = NULL;
    whMessageCrypto_EcdhRequest*  req     = NULL;
    whMessageCrypto_EcdhResponse* res     = NULL;

    /* Transaction state */
    whKeyId prv_key_id;
    int     prv_evict = 0;
    whKeyId pub_key_id;
    int     pub_evict = 0;

    if ((ctx == NULL) || (pub_key == NULL) || (priv_key == NULL)) {
        return WH_ERROR_BADARGS;
    }

    pub_key_id = WH_DEVCTX_TO_KEYID(pub_key->devCtx);
    if ((ret == WH_ERROR_OK) && WH_KEYID_ISERASED(pub_key_id)) {
        /* Must import the key to the server and evict it afterwards */
        uint8_t    keyLabel[] = "TempEccDh-pub";
        whNvmFlags flags      = WH_NVM_FLAGS_USAGE_DERIVE;

        ret = wh_Client_EccImportKey(ctx, pub_key, &pub_key_id, flags,
                                     sizeof(keyLabel), keyLabel);
        if (ret == WH_ERROR_OK) {
            pub_evict = 1;
        }
    }

    prv_key_id = WH_DEVCTX_TO_KEYID(priv_key->devCtx);
    if ((ret == WH_ERROR_OK) && WH_KEYID_ISERASED(prv_key_id)) {
        /* Must import the key to the server and evict it afterwards */
        uint8_t    keyLabel[] = "TempEccDh-prv";
        whNvmFlags flags      = WH_NVM_FLAGS_USAGE_DERIVE;

        ret = wh_Client_EccImportKey(ctx, priv_key, &prv_key_id, flags,
                                     sizeof(keyLabel), keyLabel);
        if (ret == WH_ERROR_OK) {
            prv_evict = 1;
        }
    }

    if (ret == WH_ERROR_OK) {
        /* Request Message*/
        uint16_t group  = WH_MESSAGE_GROUP_CRYPTO;
        uint16_t action = WC_ALGO_TYPE_PK;
        uint16_t req_len =
            sizeof(whMessageCrypto_GenericRequestHeader) + sizeof(*req);
        uint32_t options = 0;

        /* Get data pointer from the context to use as request/response storage
         */
        dataPtr = wh_CommClient_GetDataPtr(ctx->comm);
        if (dataPtr == NULL) {
            return WH_ERROR_BADARGS;
        }

        /* Setup generic header and get pointer to request data */
        req = (whMessageCrypto_EcdhRequest*)_createCryptoRequest(
            dataPtr, WC_PK_TYPE_ECDH, ctx->cryptoAffinity);

        if (req_len <= WOLFHSM_CFG_COMM_DATA_LEN) {
            if (pub_evict != 0) {
                options |= WH_MESSAGE_CRYPTO_ECDH_OPTIONS_EVICTPUB;
            }
            if (prv_evict != 0) {
                options |= WH_MESSAGE_CRYPTO_ECDH_OPTIONS_EVICTPRV;
            }

            memset(req, 0, sizeof(*req));
            req->options      = options;
            req->privateKeyId = prv_key_id;
            req->publicKeyId  = pub_key_id;

            /* Send Request */
            ret = wh_Client_SendRequest(ctx, group, action, req_len,
                                        (uint8_t*)dataPtr);
            WH_DEBUG_CLIENT_VERBOSE("req sent. priv:%u pub:%u\n",
                   (unsigned int)req->privateKeyId,
                   (unsigned int)req->publicKeyId);
            if (ret == WH_ERROR_OK) {
                /* Server will evict.  Reset our flags */
                pub_evict = prv_evict = 0;

                /* Response Message */
                uint16_t res_len;

                /* Recv Response */
                do {
                    ret = wh_Client_RecvResponse(ctx, &group, &action, &res_len,
                                                 (uint8_t*)dataPtr);
                } while (ret == WH_ERROR_NOTREADY);
                WH_DEBUG_CLIENT_VERBOSE("resp packet recv. ret:%d\n", ret);
                if (ret == WH_ERROR_OK) {
                    /* Get response structure pointer, validates generic header
                     * rc */
                    ret = _getCryptoResponse(dataPtr, WC_PK_TYPE_ECDH,
                                             (uint8_t**)&res);
                    /* wolfCrypt allows positive error codes on success in some
                     * scenarios */
                    if (ret >= 0) {
                        uint8_t* res_out = (uint8_t*)(res + 1);
                        /* TODO: should we sanity check res->sz? */
                        if (out_size != NULL) {
                            *out_size = res->sz;
                        }
                        if (out != NULL) {
                            memcpy(out, res_out, res->sz);
                        }
                        WH_DEBUG_VERBOSE_HEXDUMP("[client] Eccdh:", res_out, res->sz);
                    }
                }
            }
        }
        else {
            ret = WH_ERROR_BADARGS;
        }
    }

    /* Evict the keys manually on error */
    if (pub_evict != 0) {
        (void)wh_Client_KeyEvict(ctx, pub_key_id);
    }
    if (prv_evict != 0) {
        (void)wh_Client_KeyEvict(ctx, prv_key_id);
    }
    WH_DEBUG_CLIENT_VERBOSE("ret:%d\n", ret);
    return ret;
}


int wh_Client_EccSign(whClientContext* ctx, ecc_key* key, const uint8_t* hash,
                      uint16_t hash_len, uint8_t* sig, uint16_t* inout_sig_len)
{
    int                              ret     = 0;
    whMessageCrypto_EccSignRequest*  req     = NULL;
    whMessageCrypto_EccSignResponse* res     = NULL;
    uint8_t*                         dataPtr = NULL;

    /* Transaction state */
    whKeyId key_id;
    int     evict = 0;

    WH_DEBUG_CLIENT_VERBOSE("ctx:%p key:%p, in:%p in_len:%u, out:%p inout_len:%p\n",
           ctx, key, hash, (unsigned)hash_len, sig, inout_sig_len);

    if ((ctx == NULL) || (key == NULL) || ((hash == NULL) && (hash_len > 0)) ||
        ((sig != NULL) && (inout_sig_len == NULL))) {
        return WH_ERROR_BADARGS;
    }

    key_id = WH_DEVCTX_TO_KEYID(key->devCtx);

    WH_DEBUG_CLIENT_VERBOSE("keyid:%x, in_len:%u, inout_len:%p\n", key_id,
           hash_len, inout_sig_len);

    /* Import key if necessary */
    if (WH_KEYID_ISERASED(key_id)) {
        /* Must import the key to the server and evict it afterwards */
        uint8_t    keyLabel[] = "TempEccSign";
        whNvmFlags flags      = WH_NVM_FLAGS_USAGE_SIGN;

        ret = wh_Client_EccImportKey(ctx, key, &key_id, flags, sizeof(keyLabel),
                                     keyLabel);
        if (ret == WH_ERROR_OK) {
            evict = 1;
        }
    }

    if (ret == WH_ERROR_OK) {
        /* Request Message */
        uint16_t group  = WH_MESSAGE_GROUP_CRYPTO;
        uint16_t action = WC_ALGO_TYPE_PK;

        uint16_t req_len = sizeof(whMessageCrypto_GenericRequestHeader) +
                           sizeof(*req) + hash_len;
        uint32_t options = 0;

        /* Get data pointer from the context to use as request/response storage
         */
        dataPtr = wh_CommClient_GetDataPtr(ctx->comm);
        if (dataPtr == NULL) {
            return WH_ERROR_BADARGS;
        }

        /* Setup generic header and get pointer to request data */
        req = (whMessageCrypto_EccSignRequest*)_createCryptoRequest(
            dataPtr, WC_PK_TYPE_ECDSA_SIGN, ctx->cryptoAffinity);

        if (req_len <= WOLFHSM_CFG_COMM_DATA_LEN) {
            uint8_t* req_hash = (uint8_t*)(req + 1);

            if (evict != 0) {
                options |= WH_MESSAGE_CRYPTO_ECCSIGN_OPTIONS_EVICT;
            }

            memset(req, 0, sizeof(*req));
            req->options = options;
            req->keyId   = key_id;
            req->sz      = hash_len;
            if ((hash != NULL) && (hash_len > 0)) {
                memcpy(req_hash, hash, hash_len);
            }
            /* Dump the request and hash for debugging */
            WH_DEBUG_CLIENT_VERBOSE("EccSign: key_id=%x, hash_len=%u, options=%u\n",
                   key_id, (unsigned)hash_len, (unsigned)options);
            WH_DEBUG_VERBOSE_HEXDUMP("[client] EccSign req:", (uint8_t*)req,
                             sizeof(*req));
            if ((hash != NULL) && (hash_len > 0)) {
                WH_DEBUG_VERBOSE_HEXDUMP("[client] EccSign hash:", (uint8_t*)hash,
                                 hash_len);
            }

            /* Send Request */
            ret = wh_Client_SendRequest(ctx, group, action, req_len,
                                        (uint8_t*)dataPtr);
            if (ret == WH_ERROR_OK) {
                /* Server will evict at this point. Reset evict */
                evict = 0;

                /* Response Message */
                uint16_t res_len = 0;

                /* Recv Response */
                do {
                    ret = wh_Client_RecvResponse(ctx, &group, &action, &res_len,
                                                 (uint8_t*)dataPtr);
                } while (ret == WH_ERROR_NOTREADY);

                if (ret == WH_ERROR_OK) {
                    /* Get response structure pointer, validates generic header
                     * rc */
                    ret = _getCryptoResponse(dataPtr, WC_PK_TYPE_ECDSA_SIGN,
                                             (uint8_t**)&res);
                    /* wolfCrypt allows positive error codes on success in some
                     * scenarios */
                    if (ret >= 0) {
                        uint8_t* res_sig = (uint8_t*)(res + 1);
                        uint16_t sig_len = res->sz;
                        /* check inoutlen and read out */
                        if (inout_sig_len != NULL) {
                            if (sig_len > *inout_sig_len) {
                                /* Silently truncate the signature */
                                sig_len = *inout_sig_len;
                            }
                            *inout_sig_len = sig_len;
                            if ((sig != NULL) && (sig_len > 0)) {
                                memcpy(sig, res_sig, sig_len);
                            }
                            WH_DEBUG_VERBOSE_HEXDUMP("[client] EccSign:", res_sig,
                                             sig_len);
                        }
                    }
                }
            }
        }
        else {
            /* Request length is too long */
            ret = WH_ERROR_BADARGS;
        }
    }
    /* Evict the key manually on error */
    if (evict != 0) {
        (void)wh_Client_KeyEvict(ctx, key_id);
    }
    WH_DEBUG_CLIENT_VERBOSE("ret:%d\n", ret);
    return ret;
}

int wh_Client_EccVerify(whClientContext* ctx, ecc_key* key, const uint8_t* sig,
                        uint16_t sig_len, const uint8_t* hash,
                        uint16_t hash_len, int* out_res)
{
    int                                ret     = 0;
    whMessageCrypto_EccVerifyRequest*  req     = NULL;
    whMessageCrypto_EccVerifyResponse* res     = NULL;
    uint8_t*                           dataPtr = NULL;

    /* Transaction state */
    whKeyId key_id;
    int     evict          = 0;
    int     export_pub_key = 0;


    WH_DEBUG_CLIENT_VERBOSE("ctx:%p key:%p, sig:%p sig_len:%u, hash:%p hash_len:%u "
           "out_res:%p\n",
           ctx, key, sig, sig_len, hash, hash_len, out_res);

    if ((ctx == NULL) || (key == NULL) || ((sig == NULL) && (sig_len > 0)) ||
        ((hash == NULL) && (hash_len > 0))) {
        return WH_ERROR_BADARGS;
    }

    key_id = WH_DEVCTX_TO_KEYID(key->devCtx);
    if (key->type == ECC_PRIVATEKEY_ONLY) {
        export_pub_key = 1;
    }
    /* Import key if necessary */
    if (WH_KEYID_ISERASED(key_id)) {
        /* Must import the key to the server and evict it afterwards */
        uint8_t    keyLabel[] = "TempEccVerify";
        whNvmFlags flags      = WH_NVM_FLAGS_USAGE_VERIFY;

        ret = wh_Client_EccImportKey(ctx, key, &key_id, flags, sizeof(keyLabel),
                                     keyLabel);
        if (ret == 0) {
            evict = 1;
        }
    }

    if (ret == WH_ERROR_OK) {
        /* Request Message */
        uint16_t group   = WH_MESSAGE_GROUP_CRYPTO;
        uint16_t action  = WC_ALGO_TYPE_PK;
        uint32_t options = 0;

        uint16_t req_len = sizeof(whMessageCrypto_GenericRequestHeader) +
                           sizeof(whMessageCrypto_EccVerifyRequest) + sig_len +
                           hash_len;

        /* Get data pointer from the context to use as request/response storage
         */
        dataPtr = wh_CommClient_GetDataPtr(ctx->comm);
        if (dataPtr == NULL) {
            return WH_ERROR_BADARGS;
        }

        /* Setup generic header and get pointer to request data */
        req = (whMessageCrypto_EccVerifyRequest*)_createCryptoRequest(
            dataPtr, WC_PK_TYPE_ECDSA_VERIFY, ctx->cryptoAffinity);

        if (req_len <= WOLFHSM_CFG_COMM_DATA_LEN) {
            uint8_t* req_sig  = (uint8_t*)(req + 1);
            uint8_t* req_hash = req_sig + sig_len;

            /* Set request packet members */
            if (evict != 0) {
                options |= WH_MESSAGE_CRYPTO_ECCVERIFY_OPTIONS_EVICT;
            }
            if (export_pub_key != 0) {
                options |= WH_MESSAGE_CRYPTO_ECCVERIFY_OPTIONS_EXPORTPUB;
            }

            memset(req, 0, sizeof(*req));
            req->options = options;
            req->keyId   = key_id;
            req->sigSz   = sig_len;
            if ((sig != NULL) && (sig_len > 0)) {
                memcpy(req_sig, sig, sig_len);
            }
            req->hashSz = hash_len;
            if ((hash != NULL) && (hash_len > 0)) {
                memcpy(req_hash, hash, hash_len);
            }

            WH_DEBUG_CLIENT_VERBOSE("EccVerify req: key_id=%x, sig_len=%u, "
                   "hash_len=%u, options=%u\n",
                   key_id, (unsigned int)sig_len, (unsigned int)hash_len,
                   (unsigned int)options);
            WH_DEBUG_VERBOSE_HEXDUMP("[client] EccVerify req:", (uint8_t*)req, req_len);
            if ((sig != NULL) && (sig_len > 0)) {
                WH_DEBUG_VERBOSE_HEXDUMP("[client] EccVerify sig:", sig, sig_len);
            }
            if ((hash != NULL) && (hash_len > 0)) {
                WH_DEBUG_VERBOSE_HEXDUMP("[client] EccVerify hash:", hash, hash_len);
            }

            /* write request */
            ret = wh_Client_SendRequest(ctx, group, action, req_len,
                                        (uint8_t*)dataPtr);

            if (ret == WH_ERROR_OK) {
                /* Server will evict at this point. Reset evict */
                evict = 0;
                /* Response Message */
                uint16_t res_len = 0;

                /* Recv Response */
                do {
                    ret = wh_Client_RecvResponse(ctx, &group, &action, &res_len,
                                                 (uint8_t*)dataPtr);
                } while (ret == WH_ERROR_NOTREADY);
                if (ret == WH_ERROR_OK) {
                    /* Get response structure pointer, validates generic header
                     * rc */
                    ret = _getCryptoResponse(dataPtr, WC_PK_TYPE_ECDSA_VERIFY,
                                             (uint8_t**)&res);
                    /* wolfCrypt allows positive error codes on success in some
                     * scenarios */
                    if (ret >= 0) {
                        uint32_t res_der_size = 0;
                        *out_res              = res->res;
                        res_der_size          = res->pubSz;
                        if (res_der_size > 0) {
                            uint8_t* res_pub_der = (uint8_t*)(res + 1);
                            /* Update the key with the generated public key */
                            ret = wh_Crypto_EccUpdatePrivateOnlyKeyDer(
                                key, res_der_size, res_pub_der);
                        }
                    }
                }
            }
        }
        else {
            /* Request length is too long */
            ret = WH_ERROR_BADARGS;
        }
    }
    /* Evict the key manually on error */
    if (evict != 0) {
        (void)wh_Client_KeyEvict(ctx, key_id);
    }
    WH_DEBUG_CLIENT_VERBOSE("ret:%d\n", ret);
    return ret;
}

#if 0
int wh_Client_EccCheckPubKey(whClientContext* ctx, ecc_key* key,
        const uint8_t* pub_key, uint16_t pub_key_len)
{
/* TODO: Check if keyid is set on incoming key.
 *      if not, import private key to server
 *      send request with pub key der
 *      server creates new key with private and public.  check
 *      evict temp key
 */
    int ret;

    if (    (ctx == NULL) ||
            (key == NULL) ||
            (pub_key == NULL) ||
            (pub_key_len == 0) ) {
        return WH_ERROR_BADARGS;
    }
    int curve_id = wc_ecc_get_curve_id(key->idx);
    whKeyId key_id = WH_DEVCTX_TO_KEYID(key->devCtx);

    /* Request packet */
    wh_Packet_pk_ecc_check_req* req = &packet->pkEccCheckReq;
    uint8_t* req_pub_key = (uint8_t*)(req + 1);

    req->type = WC_PK_TYPE_EC_CHECK_PRIV_KEY;
    req->keyId = key_id;
    req->curveId = curve_id;

    /* Response packet */
    wh_Packet_pk_ecc_check_res* res = &packet->pkEccCheckRes;


    /* write request */
    ret = wh_Client_SendRequest(ctx, group,
        WC_ALGO_TYPE_PK,
        WH_PACKET_STUB_SIZE + sizeof(packet->pkEccCheckReq),
        (uint8_t*)packet);
    /* read response */
    if (ret == 0) {
        do {
            ret = wh_Client_RecvResponse(ctx, &group, &action, &dataSz,
                (uint8_t*)packet);
        } while (ret == WH_ERROR_NOTREADY);
    }
    if (ret == 0) {
        if (packet->rc != 0)
            ret = packet->rc;
    }
}
#endif /* 0 */

#endif /* HAVE_ECC */

#ifdef HAVE_CURVE25519
int wh_Client_Curve25519SetKeyId(curve25519_key* key, whKeyId keyId)
{
    if (key == NULL) {
        return WH_ERROR_BADARGS;
    }
    key->devCtx = WH_KEYID_TO_DEVCTX(keyId);
    /* TODO: Eliminate this and handle remote keys cleaner */
    key->pubSet  = 1;
    key->privSet = 1;
    return WH_ERROR_OK;
}

int wh_Client_Curve25519GetKeyId(curve25519_key* key, whKeyId* outId)
{
    if ((key == NULL) || (outId == NULL)) {
        return WH_ERROR_BADARGS;
    }
    *outId = WH_DEVCTX_TO_KEYID(key->devCtx);
    return WH_ERROR_OK;
}

int wh_Client_Curve25519ImportKey(whClientContext* ctx, curve25519_key* key,
                                  whKeyId* inout_keyId, whNvmFlags flags,
                                  uint16_t label_len, uint8_t* label)

{
    int      ret                               = 0;
    whKeyId  key_id                            = WH_KEYID_ERASED;
    byte     buffer[WOLFHSM_CFG_COMM_DATA_LEN] = {0};
    uint16_t buffer_len                        = 0;

    if ((ctx == NULL) || (key == NULL) ||
        ((label_len != 0) && (label == NULL))) {
        return WH_ERROR_BADARGS;
    }

    if (inout_keyId != NULL) {
        key_id = *inout_keyId;
    }

    buffer_len = sizeof(buffer);
    ret        = wh_Crypto_Curve25519SerializeKey(key, buffer, &buffer_len);
    if (ret == 0) {
        /* Cache the key and get the keyID */
        ret = wh_Client_KeyCache(ctx, flags, label, label_len, buffer,
                                 buffer_len, &key_id);
        if (inout_keyId != NULL) {
            *inout_keyId = key_id;
        }
        WH_DEBUG_CLIENT_VERBOSE("importKey: cached keyid=%u\n", key_id);
        WH_DEBUG_VERBOSE_HEXDUMP("[client] importKey: key=", buffer, buffer_len);
    }
    return ret;
}

int wh_Client_Curve25519ExportKey(whClientContext* ctx, whKeyId keyId,
                                  curve25519_key* key, uint16_t label_len,
                                  uint8_t* label)
{
    int ret = 0;
    /* buffer cannot be larger than MTU */
    byte     buffer[WOLFHSM_CFG_COMM_DATA_LEN] = {0};
    uint16_t buffer_len                        = sizeof(buffer);

    if ((ctx == NULL) || WH_KEYID_ISERASED(keyId) || (key == NULL)) {
        return WH_ERROR_BADARGS;
    }

    /* Now export the key from the server */
    ret =
        wh_Client_KeyExport(ctx, keyId, label, label_len, buffer, &buffer_len);
    if (ret == 0) {
        /* Update the key structure */
        ret = wh_Crypto_Curve25519DeserializeKey(buffer, buffer_len, key);
    }

    return ret;
}

static int _Curve25519MakeKey(whClientContext* ctx, uint16_t size,
                              whKeyId* inout_key_id, whNvmFlags flags,
                              const uint8_t* label, uint16_t label_len,
                              curve25519_key* key)
{
    int                                       ret    = 0;
    uint16_t                                  group  = WH_MESSAGE_GROUP_CRYPTO;
    uint16_t                                  action = WC_ALGO_TYPE_PK;
    uint16_t                                  data_len = 0;
    whMessageCrypto_Curve25519KeyGenRequest*  req      = NULL;
    whMessageCrypto_Curve25519KeyGenResponse* res      = NULL;
    uint8_t*                                  dataPtr  = NULL;
    whKeyId                                   key_id   = WH_KEYID_ERASED;

    if (ctx == NULL) {
        return WH_ERROR_BADARGS;
    }

    /* Get data pointer from the context to use as request/response storage */
    dataPtr = wh_CommClient_GetDataPtr(ctx->comm);
    if (dataPtr == NULL) {
        return WH_ERROR_BADARGS;
    }
    memset((uint8_t*)dataPtr, 0, WOLFHSM_CFG_COMM_DATA_LEN);

    /* Setup generic header and get pointer to request data */
    req = (whMessageCrypto_Curve25519KeyGenRequest*)_createCryptoRequest(
        dataPtr, WC_PK_TYPE_CURVE25519_KEYGEN, ctx->cryptoAffinity);

    /* Use the supplied key id if provided */
    if (inout_key_id != NULL) {
        key_id = *inout_key_id;
    }

    /* Set up the request packet */
    req->sz    = size;
    req->flags = flags;
    req->keyId = key_id;
    if ((label != NULL) && (label_len > 0)) {
        if (label_len > WH_NVM_LABEL_LEN) {
            label_len = WH_NVM_LABEL_LEN;
        }
        memcpy(req->label, label, label_len);
    }
    data_len = sizeof(whMessageCrypto_GenericRequestHeader) + sizeof(*req);

    ret =
        wh_Client_SendRequest(ctx, group, action, data_len, (uint8_t*)dataPtr);
    WH_DEBUG_CLIENT_VERBOSE("Curve25519 KeyGen Req sent:size:%u, ret:%d\n",
           (unsigned int)req->sz, ret);
    if (ret == 0) {
        do {
            ret = wh_Client_RecvResponse(ctx, &group, &action, &data_len,
                                         (uint8_t*)dataPtr);
        } while (ret == WH_ERROR_NOTREADY);
    }


    if (ret == 0) {
        /* Get response structure pointer, validates generic header */
        ret = _getCryptoResponse(dataPtr, WC_PK_TYPE_CURVE25519_KEYGEN,
                                 (uint8_t**)&res);
        /* wolfCrypt allows positive error codes on success in some scenarios */
        if (ret >= 0) {
            WH_DEBUG_CLIENT_VERBOSE("Curve25519 KeyGen Res recv:keyid:%u, len:%u, "
                   "ret:%d\n",
                   (unsigned int)res->keyId, (unsigned int)res->len, ret);
            /* Key is cached on server or is ephemeral */
            key_id = (whKeyId)(res->keyId);

            /* Update output variable if requested */
            if (inout_key_id != NULL) {
                *inout_key_id = key_id;
            }

            /* Update the context if provided */
            if (key != NULL) {
                uint16_t der_size = (uint16_t)(res->len);
                uint8_t* key_der  = (uint8_t*)(res + 1);
                /* Set the key_id.  Should be ERASED if EPHEMERAL */
                wh_Client_Curve25519SetKeyId(key, key_id);

                if (flags & WH_NVM_FLAGS_EPHEMERAL) {
                    /* Response has the exported key */
                    ret = wh_Crypto_Curve25519DeserializeKey(key_der, der_size,
                                                             key);
                    WH_DEBUG_VERBOSE_HEXDUMP("[client] KeyGen export:", key_der,
                                     der_size);
                }
            }
        }
    }
    return ret;
}

int wh_Client_Curve25519MakeCacheKey(whClientContext* ctx, uint16_t size,
                                     whKeyId* inout_key_id, whNvmFlags flags,
                                     const uint8_t* label, uint16_t label_len)
{
    if (inout_key_id == NULL) {
        return WH_ERROR_BADARGS;
    }

    return _Curve25519MakeKey(ctx, size, inout_key_id, flags, label, label_len,
                              NULL);
}

int wh_Client_Curve25519MakeExportKey(whClientContext* ctx, uint16_t size,
                                      curve25519_key* key)
{
    if (key == NULL) {
        return WH_ERROR_BADARGS;
    }

    return _Curve25519MakeKey(ctx, size, NULL, WH_NVM_FLAGS_EPHEMERAL, NULL, 0,
                              key);
}

int wh_Client_Curve25519SharedSecret(whClientContext* ctx,
                                     curve25519_key*  priv_key,
                                     curve25519_key* pub_key, int endian,
                                     uint8_t* out, uint16_t* out_size)
{
    int ret = WH_ERROR_OK;

    /* Transaction state */
    whKeyId prv_key_id;
    int     prv_evict = 0;
    whKeyId pub_key_id;
    int     pub_evict = 0;

    if ((ctx == NULL) || (pub_key == NULL) || (priv_key == NULL)) {
        return WH_ERROR_BADARGS;
    }

    pub_key_id = WH_DEVCTX_TO_KEYID(pub_key->devCtx);
    if ((ret == WH_ERROR_OK) && WH_KEYID_ISERASED(pub_key_id)) {
        /* Must import the key to the server and evict it afterwards */
        uint8_t    keyLabel[] = "TempX25519-pub";
        whNvmFlags flags      = WH_NVM_FLAGS_USAGE_DERIVE;

        ret = wh_Client_Curve25519ImportKey(ctx, pub_key, &pub_key_id, flags,
                                            sizeof(keyLabel), keyLabel);
        if (ret == WH_ERROR_OK) {
            pub_evict = 1;
        }
    }

    prv_key_id = WH_DEVCTX_TO_KEYID(priv_key->devCtx);
    if ((ret == WH_ERROR_OK) && WH_KEYID_ISERASED(prv_key_id)) {
        /* Must import the key to the server and evict it afterwards */
        uint8_t    keyLabel[] = "TempX25519-prv";
        whNvmFlags flags      = WH_NVM_FLAGS_USAGE_DERIVE;

        ret = wh_Client_Curve25519ImportKey(ctx, priv_key, &prv_key_id, flags,
                                            sizeof(keyLabel), keyLabel);
        if (ret == WH_ERROR_OK) {
            prv_evict = 1;
        }
    }

    if (ret == WH_ERROR_OK) {
        whMessageCrypto_Curve25519Request* req     = NULL;
        uint8_t*                           dataPtr = NULL;
        uint16_t                           group   = WH_MESSAGE_GROUP_CRYPTO;
        uint16_t                           action  = WC_ALGO_TYPE_PK;
        uint32_t                           options = 0;

        uint16_t req_len =
            sizeof(whMessageCrypto_GenericRequestHeader) + sizeof(*req);

        /* Get data pointer from the context to use as request/response storage
         */
        dataPtr = wh_CommClient_GetDataPtr(ctx->comm);
        if (dataPtr == NULL) {
            return WH_ERROR_BADARGS;
        }
        memset((uint8_t*)dataPtr, 0, WOLFHSM_CFG_COMM_DATA_LEN);

        /* Setup generic header and get pointer to request data */
        req = (whMessageCrypto_Curve25519Request*)_createCryptoRequest(
            dataPtr, WC_PK_TYPE_CURVE25519, ctx->cryptoAffinity);

        if (req_len <= WOLFHSM_CFG_COMM_DATA_LEN) {
            if (pub_evict != 0) {
                options |= WH_MESSAGE_CRYPTO_CURVE25519_OPTIONS_EVICTPUB;
            }
            if (prv_evict != 0) {
                options |= WH_MESSAGE_CRYPTO_CURVE25519_OPTIONS_EVICTPRV;
            }

            memset(req, 0, sizeof(*req));
            req->options      = options;
            req->privateKeyId = prv_key_id;
            req->publicKeyId  = pub_key_id;
            req->endian       = endian;

            /* Send Request */
            ret = wh_Client_SendRequest(ctx, group, action, req_len,
                                        (uint8_t*)dataPtr);
            WH_DEBUG_CLIENT_VERBOSE("req sent. priv:%u pub:%u\n",
                   (unsigned int)req->privateKeyId,
                   (unsigned int)req->publicKeyId);
            if (ret == WH_ERROR_OK) {
                whMessageCrypto_Curve25519Response* res = NULL;
                uint16_t                            res_len;
                /* Server will evict.  Reset our flags */
                pub_evict = prv_evict = 0;

                /* Recv Response */
                do {
                    ret = wh_Client_RecvResponse(ctx, &group, &action, &res_len,
                                                 (uint8_t*)dataPtr);
                } while (ret == WH_ERROR_NOTREADY);
                WH_DEBUG_CLIENT_VERBOSE("resp packet recv. ret:%d\n",
                       ret);
                if (ret == WH_ERROR_OK) {
                    /* Get response structure pointer, validates generic header
                     * rc */
                    ret = _getCryptoResponse(dataPtr, WC_PK_TYPE_CURVE25519,
                                             (uint8_t**)&res);
                    /* wolfCrypt allows positive error codes on success in some
                     * scenarios */
                    if (ret >= 0) {
                        if (out_size != NULL) {
                            *out_size = res->sz;
                        }
                        if (out != NULL) {
                            uint8_t* res_out = (uint8_t*)(res + 1);
                            memcpy(out, res_out, res->sz);
                            WH_DEBUG_VERBOSE_HEXDUMP("[client] X25519:", res_out,
                                             res->sz);
                        }
                    }
                }
            }
        }
        else {
            ret = WH_ERROR_BADARGS;
        }
    }

    /* Evict the keys manually on error */
    if (pub_evict != 0) {
        (void)wh_Client_KeyEvict(ctx, pub_key_id);
    }
    if (prv_evict != 0) {
        (void)wh_Client_KeyEvict(ctx, prv_key_id);
    }
    WH_DEBUG_CLIENT_VERBOSE("ret:%d\n", ret);
    return ret;
}
#endif /* HAVE_CURVE25519 */

#ifdef HAVE_ED25519
int wh_Client_Ed25519SetKeyId(ed25519_key* key, whKeyId keyId)
{
    if (key == NULL) {
        return WH_ERROR_BADARGS;
    }
    key->devCtx = WH_KEYID_TO_DEVCTX(keyId);
    return WH_ERROR_OK;
}

int wh_Client_Ed25519GetKeyId(ed25519_key* key, whKeyId* outId)
{
    if ((key == NULL) || (outId == NULL)) {
        return WH_ERROR_BADARGS;
    }
    *outId = WH_DEVCTX_TO_KEYID(key->devCtx);
    return WH_ERROR_OK;
}

int wh_Client_Ed25519ImportKey(whClientContext* ctx, ed25519_key* key,
                               whKeyId* inout_keyId, whNvmFlags flags,
                               uint16_t label_len, uint8_t* label)
{
    int      ret         = WH_ERROR_OK;
    whKeyId  key_id      = WH_KEYID_ERASED;
    uint8_t  buffer[128] = {0};
    uint16_t buffer_len  = sizeof(buffer);

    if ((ctx == NULL) || (key == NULL) ||
        ((label_len != 0) && (label == NULL))) {
        return WH_ERROR_BADARGS;
    }

    if (inout_keyId != NULL) {
        key_id = *inout_keyId;
    }

    ret =
        wh_Crypto_Ed25519SerializeKeyDer(key, buffer_len, buffer, &buffer_len);
    if (ret == WH_ERROR_OK) {
        ret = wh_Client_KeyCache(ctx, flags, label, label_len, buffer,
                                 buffer_len, &key_id);
        if ((ret == WH_ERROR_OK) && (inout_keyId != NULL)) {
            *inout_keyId = key_id;
        }
    }

    return ret;
}

int wh_Client_Ed25519ExportKey(whClientContext* ctx, whKeyId keyId,
                               ed25519_key* key, uint16_t label_len,
                               uint8_t* label)
{
    int      ret         = WH_ERROR_OK;
    uint8_t  buffer[128] = {0};
    uint16_t buffer_len  = sizeof(buffer);

    if ((ctx == NULL) || WH_KEYID_ISERASED(keyId) || (key == NULL)) {
        return WH_ERROR_BADARGS;
    }

    ret =
        wh_Client_KeyExport(ctx, keyId, label, label_len, buffer, &buffer_len);
    if (ret == WH_ERROR_OK) {
        ret = wh_Crypto_Ed25519DeserializeKeyDer(buffer, buffer_len, key);
        if (ret == 0) {
            wh_Client_Ed25519SetKeyId(key, keyId);
        }
    }

    return ret;
}

static int _Ed25519MakeKey(whClientContext* ctx, whKeyId* inout_key_id,
                           whNvmFlags flags, uint16_t label_len, uint8_t* label,
                           ed25519_key* key)
{
    int                                    ret     = WH_ERROR_OK;
    whKeyId                                key_id  = WH_KEYID_ERASED;
    uint8_t*                               dataPtr = NULL;
    whMessageCrypto_Ed25519KeyGenRequest*  req     = NULL;
    whMessageCrypto_Ed25519KeyGenResponse* res     = NULL;

    if (ctx == NULL || ((label_len != 0) && (label == NULL))) {
        return WH_ERROR_BADARGS;
    }

    if (inout_key_id != NULL) {
        key_id = *inout_key_id;
    }

    dataPtr = wh_CommClient_GetDataPtr(ctx->comm);
    if (dataPtr == NULL) {
        return WH_ERROR_BADARGS;
    }

    req = (whMessageCrypto_Ed25519KeyGenRequest*)_createCryptoRequest(
        dataPtr, WC_PK_TYPE_ED25519_KEYGEN, ctx->cryptoAffinity);

    uint16_t group  = WH_MESSAGE_GROUP_CRYPTO;
    uint16_t action = WC_ALGO_TYPE_PK;
    uint16_t req_len =
        sizeof(whMessageCrypto_GenericRequestHeader) + sizeof(*req);

    if (req_len > WOLFHSM_CFG_COMM_DATA_LEN) {
        return WH_ERROR_BADARGS;
    }

    memset(req, 0, sizeof(*req));
    req->flags  = flags;
    req->keyId  = key_id;
    req->access = WH_NVM_ACCESS_ANY;
    if ((label != NULL) && (label_len > 0)) {
        if (label_len > WH_NVM_LABEL_LEN) {
            label_len = WH_NVM_LABEL_LEN;
        }
        memcpy(req->label, label, label_len);
    }

    ret = wh_Client_SendRequest(ctx, group, action, req_len, (uint8_t*)dataPtr);
    if (ret != WH_ERROR_OK) {
        return ret;
    }
    uint16_t res_len = 0;
    do {
        ret = wh_Client_RecvResponse(ctx, &group, &action, &res_len,
                                     (uint8_t*)dataPtr);
    } while (ret == WH_ERROR_NOTREADY);

    if (ret != WH_ERROR_OK) {
        return ret;
    }

    if (group != WH_MESSAGE_GROUP_CRYPTO || action != WC_ALGO_TYPE_PK) {
        return WH_ERROR_ABORTED;
    }

    ret =
        _getCryptoResponse(dataPtr, WC_PK_TYPE_ED25519_KEYGEN, (uint8_t**)&res);
    if (ret >= 0) {
        key_id = (whKeyId)res->keyId;
        if (inout_key_id != NULL) {
            *inout_key_id = key_id;
        }
        if (key != NULL) {
            wh_Client_Ed25519SetKeyId(key, key_id);
            if (flags & WH_NVM_FLAGS_EPHEMERAL) {
                uint8_t* out   = (uint8_t*)(res + 1);
                uint16_t outSz = (uint16_t)res->outSz;
                if (outSz + sizeof(whMessageCrypto_GenericResponseHeader) +
                        sizeof(*res) >
                    WOLFHSM_CFG_COMM_DATA_LEN) {
                    return WH_ERROR_ABORTED;
                }
                ret = wh_Crypto_Ed25519DeserializeKeyDer(out, outSz, key);
            }
        }
    }

    return ret;
}

int wh_Client_Ed25519MakeExportKey(whClientContext* ctx, ed25519_key* key)
{
    if (key == NULL) {
        return WH_ERROR_BADARGS;
    }

    return _Ed25519MakeKey(ctx, NULL, WH_NVM_FLAGS_EPHEMERAL, 0, NULL, key);
}

int wh_Client_Ed25519MakeCacheKey(whClientContext* ctx, whKeyId* inout_key_id,
                                  whNvmFlags flags, uint16_t label_len,
                                  uint8_t* label)
{
    if (inout_key_id == NULL) {
        return WH_ERROR_BADARGS;
    }

    return _Ed25519MakeKey(ctx, inout_key_id, flags, label_len, label, NULL);
}

int wh_Client_Ed25519Sign(whClientContext* ctx, ed25519_key* key,
                          const uint8_t* msg, uint32_t msgLen, uint8_t type,
                          const uint8_t* context, uint32_t contextLen,
                          uint8_t* sig, uint32_t* inout_sig_len)
{
    int                                  ret     = 0;
    whMessageCrypto_Ed25519SignRequest*  req     = NULL;
    whMessageCrypto_Ed25519SignResponse* res     = NULL;
    uint8_t*                             dataPtr = NULL;

    whKeyId key_id = WH_DEVCTX_TO_KEYID(key->devCtx);
    int     evict  = 0;

    if ((ctx == NULL) || (key == NULL) || ((msg == NULL) && (msgLen > 0)) ||
        ((sig != NULL) && (inout_sig_len == NULL)) ||
        ((context == NULL) && (contextLen > 0))) {
        return WH_ERROR_BADARGS;
    }

    if ((type != (byte)Ed25519) && (type != (byte)Ed25519ctx) &&
        (type != (byte)Ed25519ph)) {
        return WH_ERROR_BADARGS;
    }
    if ((type == (byte)Ed25519) && (contextLen != 0 || context != NULL)) {
        return WH_ERROR_BADARGS;
    }
    if (contextLen > WH_CRYPTO_ED25519_MAX_CTX_LEN) {
        return WH_ERROR_BADARGS;
    }

    uint16_t req_len = sizeof(whMessageCrypto_GenericRequestHeader) +
                       sizeof(*req) + msgLen + contextLen;
    if (req_len > WOLFHSM_CFG_COMM_DATA_LEN) {
        return WH_ERROR_BADARGS;
    }

    if (WH_KEYID_ISERASED(key_id)) {
        uint8_t    keyLabel[] = "TempEd25519Sign";
        whNvmFlags flags      = WH_NVM_FLAGS_USAGE_SIGN;

        ret = wh_Client_Ed25519ImportKey(ctx, key, &key_id, flags,
                                         sizeof(keyLabel), keyLabel);
        if (ret == WH_ERROR_OK) {
            evict = 1;
        }
    }

    if (ret == WH_ERROR_OK) {
        uint16_t group   = WH_MESSAGE_GROUP_CRYPTO;
        uint16_t action  = WC_ALGO_TYPE_PK;
        uint32_t options = 0;

        dataPtr = wh_CommClient_GetDataPtr(ctx->comm);
        if (dataPtr == NULL) {
            return WH_ERROR_BADARGS;
        }

        req = (whMessageCrypto_Ed25519SignRequest*)_createCryptoRequest(
            dataPtr, WC_PK_TYPE_ED25519_SIGN, ctx->cryptoAffinity);

        uint8_t* req_msg = (uint8_t*)(req + 1);
        uint8_t* req_ctx = req_msg + msgLen;

        if (evict != 0) {
            options |= WH_MESSAGE_CRYPTO_ED25519_SIGN_OPTIONS_EVICT;
        }

        memset(req, 0, sizeof(*req));
        req->options = options;
        req->keyId   = key_id;
        req->msgSz   = msgLen;
        req->type    = type;
        req->ctxSz   = contextLen;
        if ((msg != NULL) && (msgLen > 0)) {
            memcpy(req_msg, msg, msgLen);
        }
        if ((context != NULL) && (contextLen > 0)) {
            memcpy(req_ctx, context, contextLen);
        }

        ret = wh_Client_SendRequest(ctx, group, action, req_len,
                                    (uint8_t*)dataPtr);
        if (ret == WH_ERROR_OK) {
            /* Server will evict at this point. Reset evict */
            evict = 0;

            uint16_t res_len = 0;
            do {
                ret = wh_Client_RecvResponse(ctx, &group, &action, &res_len,
                                             (uint8_t*)dataPtr);
            } while (ret == WH_ERROR_NOTREADY);

            if (group != WH_MESSAGE_GROUP_CRYPTO || action != WC_ALGO_TYPE_PK) {
                ret = WH_ERROR_ABORTED;
            }

            if (ret == WH_ERROR_OK) {
                ret = _getCryptoResponse(dataPtr, WC_PK_TYPE_ED25519_SIGN,
                                         (uint8_t**)&res);
                if (ret >= 0) {
                    uint32_t res_total =
                        sizeof(whMessageCrypto_GenericResponseHeader) +
                        sizeof(*res) + res->sigSz;
                    if (res_total > res_len) {
                        ret = WH_ERROR_ABORTED;
                    }
                }
                if (ret >= 0) {
                    uint8_t* res_sig = (uint8_t*)(res + 1);
                    uint32_t sig_len = res->sigSz;
                    if (inout_sig_len != NULL) {
                        if (sig_len > *inout_sig_len) {
                            sig_len = *inout_sig_len;
                        }
                        *inout_sig_len = sig_len;
                    }
                    if ((sig != NULL) && (sig_len > 0)) {
                        memcpy(sig, res_sig, sig_len);
                    }
                }
            }
        }
    }

    if (evict != 0) {
        (void)wh_Client_KeyEvict(ctx, key_id);
    }

    /* map ASN key decoding errors to WH_ERROR_BADARGS */
    if (ret == ASN_PARSE_E)
        ret = WH_ERROR_BADARGS;

    return ret;
}

int wh_Client_Ed25519Verify(whClientContext* ctx, ed25519_key* key,
                            const uint8_t* sig, uint32_t sigLen,
                            const uint8_t* msg, uint32_t msgLen, uint8_t type,
                            const uint8_t* context, uint32_t contextLen,
                            int* out_res)
{
    int                                    ret     = 0;
    whMessageCrypto_Ed25519VerifyRequest*  req     = NULL;
    whMessageCrypto_Ed25519VerifyResponse* res     = NULL;
    uint8_t*                               dataPtr = NULL;
    whKeyId  key_id  = WH_DEVCTX_TO_KEYID(key->devCtx);
    int      evict   = 0;
    uint16_t req_len = sizeof(whMessageCrypto_GenericRequestHeader) +
                       sizeof(*req) + sigLen + msgLen + contextLen;

    if ((ctx == NULL) || (key == NULL) || (sig == NULL) || (msg == NULL) ||
        (out_res == NULL) || ((context == NULL) && (contextLen > 0))) {
        return WH_ERROR_BADARGS;
    }

    if ((type != (byte)Ed25519) && (type != (byte)Ed25519ctx) &&
        (type != (byte)Ed25519ph)) {
        return WH_ERROR_BADARGS;
    }
    if ((type == (byte)Ed25519) && (contextLen != 0 || context != NULL)) {
        return WH_ERROR_BADARGS;
    }
    if (contextLen > WH_CRYPTO_ED25519_MAX_CTX_LEN) {
        return WH_ERROR_BADARGS;
    }

    if (req_len > WOLFHSM_CFG_COMM_DATA_LEN) {
        return WH_ERROR_BADARGS;
    }

    *out_res = 0;

    if (WH_KEYID_ISERASED(key_id)) {
        uint8_t    keyLabel[] = "TempEd25519Verify";
        whNvmFlags flags      = WH_NVM_FLAGS_USAGE_VERIFY;

        ret = wh_Client_Ed25519ImportKey(ctx, key, &key_id, flags,
                                         sizeof(keyLabel), keyLabel);
        if (ret == WH_ERROR_OK) {
            evict = 1;
        }
    }

    if (ret == WH_ERROR_OK) {
        uint16_t group   = WH_MESSAGE_GROUP_CRYPTO;
        uint16_t action  = WC_ALGO_TYPE_PK;
        uint32_t options = 0;

        dataPtr = wh_CommClient_GetDataPtr(ctx->comm);
        if (dataPtr == NULL) {
            return WH_ERROR_BADARGS;
        }

        req = (whMessageCrypto_Ed25519VerifyRequest*)_createCryptoRequest(
            dataPtr, WC_PK_TYPE_ED25519_VERIFY, ctx->cryptoAffinity);

        uint8_t* req_sig = (uint8_t*)(req + 1);
        uint8_t* req_msg = req_sig + sigLen;
        uint8_t* req_ctx = req_msg + msgLen;

        if (evict != 0) {
            options |= WH_MESSAGE_CRYPTO_ED25519_VERIFY_OPTIONS_EVICT;
        }

        memset(req, 0, sizeof(*req));
        req->options = options;
        req->keyId   = key_id;
        req->sigSz   = sigLen;
        req->msgSz   = msgLen;
        req->type    = type;
        req->ctxSz   = contextLen;

        memcpy(req_sig, sig, sigLen);
        memcpy(req_msg, msg, msgLen);
        if ((context != NULL) && (contextLen > 0)) {
            memcpy(req_ctx, context, contextLen);
        }

        ret = wh_Client_SendRequest(ctx, group, action, req_len,
                                    (uint8_t*)dataPtr);
        if (ret == WH_ERROR_OK) {
            /* Server will evict at this point. Reset evict */
            evict = 0;

            uint16_t res_len = 0;
            do {
                ret = wh_Client_RecvResponse(ctx, &group, &action, &res_len,
                                             (uint8_t*)dataPtr);
            } while (ret == WH_ERROR_NOTREADY);

            if (group != WH_MESSAGE_GROUP_CRYPTO || action != WC_ALGO_TYPE_PK) {
                ret = WH_ERROR_ABORTED;
            }

            if (ret == WH_ERROR_OK) {
                ret = _getCryptoResponse(dataPtr, WC_PK_TYPE_ED25519_VERIFY,
                                         (uint8_t**)&res);
                if (ret >= 0 && res != NULL) {
                    uint32_t res_total =
                        sizeof(whMessageCrypto_GenericResponseHeader) +
                        sizeof(*res);
                    if (res_total > res_len) {
                        ret = WH_ERROR_ABORTED;
                    }
                    *out_res = res->res;
                }
            }
        }
    }

    if (evict != 0) {
        (void)wh_Client_KeyEvict(ctx, key_id);
    }

    /* map ASN key decoding errors to WH_ERROR_BADARGS */
    if (ret == ASN_PARSE_E)
        ret = WH_ERROR_BADARGS;

    return ret;
}

#ifdef WOLFHSM_CFG_DMA
int wh_Client_Ed25519SignDma(whClientContext* ctx, ed25519_key* key,
                             const uint8_t* msg, uint32_t msgLen, uint8_t type,
                             const uint8_t* context, uint32_t contextLen,
                             uint8_t* sig, uint32_t* inout_sig_len)
{
    int                                     ret     = 0;
    whMessageCrypto_Ed25519SignDmaRequest*  req     = NULL;
    whMessageCrypto_Ed25519SignDmaResponse* res     = NULL;
    uint8_t*                                dataPtr = NULL;
    uintptr_t                               msgAddr = 0;
    uintptr_t                               sigAddr = 0;

    whKeyId  key_id   = WH_DEVCTX_TO_KEYID(key->devCtx);
    int      evict    = 0;
    uint32_t inSigLen = (inout_sig_len != NULL) ? *inout_sig_len : 0;

    if ((ctx == NULL) || (key == NULL) || ((msg == NULL) && (msgLen > 0)) ||
        (sig == NULL) || (inout_sig_len == NULL) ||
        ((context == NULL) && (contextLen > 0))) {
        return WH_ERROR_BADARGS;
    }

    if ((type != (byte)Ed25519) && (type != (byte)Ed25519ctx) &&
        (type != (byte)Ed25519ph)) {
        return WH_ERROR_BADARGS;
    }
    if ((type == (byte)Ed25519) && (contextLen != 0 || context != NULL)) {
        return WH_ERROR_BADARGS;
    }
    if (contextLen > WH_CRYPTO_ED25519_MAX_CTX_LEN) {
        return WH_ERROR_BADARGS;
    }

    uint16_t req_len = sizeof(whMessageCrypto_GenericRequestHeader) +
                       sizeof(*req) + contextLen;
    if (req_len > WOLFHSM_CFG_COMM_DATA_LEN) {
        return WH_ERROR_BADARGS;
    }

    if (WH_KEYID_ISERASED(key_id)) {
        uint8_t    keyLabel[] = "TempEd25519SignDma";
        whNvmFlags flags = WH_NVM_FLAGS_USAGE_SIGN | WH_NVM_FLAGS_USAGE_VERIFY;

        ret = wh_Client_Ed25519ImportKey(ctx, key, &key_id, flags,
                                         sizeof(keyLabel), keyLabel);
        if (ret == WH_ERROR_OK) {
            evict = 1;
        }
    }

    if (ret == WH_ERROR_OK) {
        uint16_t group   = WH_MESSAGE_GROUP_CRYPTO_DMA;
        uint16_t action  = WC_ALGO_TYPE_PK;
        uint32_t options = 0;

        dataPtr = wh_CommClient_GetDataPtr(ctx->comm);
        if (dataPtr == NULL) {
            return WH_ERROR_BADARGS;
        }

        req = (whMessageCrypto_Ed25519SignDmaRequest*)_createCryptoRequest(
            dataPtr, WC_PK_TYPE_ED25519_SIGN, ctx->cryptoAffinity);

        uint8_t* req_ctx = (uint8_t*)(req + 1);

        if (evict != 0) {
            options |= WH_MESSAGE_CRYPTO_ED25519_SIGN_OPTIONS_EVICT;
        }

        memset(req, 0, sizeof(*req));
        req->options = options;
        req->keyId   = key_id;
        req->type    = type;
        req->ctxSz   = contextLen;
        req->msg.sz  = msgLen;
        req->sig.sz  = inSigLen;
        if ((context != NULL) && (contextLen > 0)) {
            memcpy(req_ctx, context, contextLen);
        }

        ret = wh_Client_DmaProcessClientAddress(
            ctx, (uintptr_t)msg, (void**)&msgAddr, req->msg.sz,
            WH_DMA_OPER_CLIENT_READ_PRE, (whDmaFlags){0});
        if (ret == WH_ERROR_OK) {
            req->msg.addr = msgAddr;
            ret           = wh_Client_DmaProcessClientAddress(
                ctx, (uintptr_t)sig, (void**)&sigAddr, req->sig.sz,
                WH_DMA_OPER_CLIENT_WRITE_PRE, (whDmaFlags){0});
        }
        if (ret == WH_ERROR_OK) {
            req->sig.addr = sigAddr;

            ret = wh_Client_SendRequest(ctx, group, action, req_len,
                                        (uint8_t*)dataPtr);
        }
        if (ret == WH_ERROR_OK) {
            evict = 0;

            uint16_t res_len = 0;
            do {
                ret = wh_Client_RecvResponse(ctx, &group, &action, &res_len,
                                             (uint8_t*)dataPtr);
            } while (ret == WH_ERROR_NOTREADY);

            if (group != WH_MESSAGE_GROUP_CRYPTO_DMA ||
                action != WC_ALGO_TYPE_PK) {
                ret = WH_ERROR_ABORTED;
            }

            if (ret == WH_ERROR_OK) {
                ret = _getCryptoResponse(dataPtr, WC_PK_TYPE_ED25519_SIGN,
                                         (uint8_t**)&res);
                if (ret >= 0 && res != NULL) {
                    uint32_t res_total =
                        sizeof(whMessageCrypto_GenericResponseHeader) +
                        sizeof(*res);
                    if (res_total > res_len) {
                        ret = WH_ERROR_ABORTED;
                    }
                }
                if (ret >= 0) {
                    if (inout_sig_len != NULL) {
                        *inout_sig_len = res->sigSz;
                    }
                }
            }
        }

        (void)wh_Client_DmaProcessClientAddress(
            ctx, (uintptr_t)sig, (void**)&sigAddr, inSigLen,
            WH_DMA_OPER_CLIENT_WRITE_POST, (whDmaFlags){0});
        (void)wh_Client_DmaProcessClientAddress(
            ctx, (uintptr_t)msg, (void**)&msgAddr, msgLen,
            WH_DMA_OPER_CLIENT_READ_POST, (whDmaFlags){0});
    }

    if (evict != 0) {
        (void)wh_Client_KeyEvict(ctx, key_id);
    }

    /* map ASN key decoding errors to WH_ERROR_BADARGS */
    if (ret == ASN_PARSE_E)
        ret = WH_ERROR_BADARGS;

    return ret;
}

int wh_Client_Ed25519VerifyDma(whClientContext* ctx, ed25519_key* key,
                               const uint8_t* sig, uint32_t sigLen,
                               const uint8_t* msg, uint32_t msgLen,
                               uint8_t type, const uint8_t* context,
                               uint32_t contextLen, int* out_res)
{
    int                                       ret     = 0;
    whMessageCrypto_Ed25519VerifyDmaRequest*  req     = NULL;
    whMessageCrypto_Ed25519VerifyDmaResponse* res     = NULL;
    uint8_t*                                  dataPtr = NULL;
    uintptr_t                                 sigAddr = 0;
    uintptr_t                                 msgAddr = 0;
    uint16_t req_len = sizeof(whMessageCrypto_GenericRequestHeader) +
                       sizeof(*req) + contextLen;
    whKeyId key_id = WH_DEVCTX_TO_KEYID(key->devCtx);
    int     evict  = 0;

    if ((ctx == NULL) || (key == NULL) || (sig == NULL) || (msg == NULL) ||
        (out_res == NULL) || ((context == NULL) && (contextLen > 0))) {
        return WH_ERROR_BADARGS;
    }

    if ((type != (byte)Ed25519) && (type != (byte)Ed25519ctx) &&
        (type != (byte)Ed25519ph)) {
        return WH_ERROR_BADARGS;
    }
    if ((type == (byte)Ed25519) && (contextLen != 0 || context != NULL)) {
        return WH_ERROR_BADARGS;
    }
    if (contextLen > WH_CRYPTO_ED25519_MAX_CTX_LEN) {
        return WH_ERROR_BADARGS;
    }

    if (req_len > WOLFHSM_CFG_COMM_DATA_LEN) {
        return WH_ERROR_BADARGS;
    }

    *out_res = 0;

    if (WH_KEYID_ISERASED(key_id)) {
        uint8_t    keyLabel[] = "TempEd25519VerifyDma";
        whNvmFlags flags = WH_NVM_FLAGS_USAGE_SIGN | WH_NVM_FLAGS_USAGE_VERIFY;

        ret = wh_Client_Ed25519ImportKey(ctx, key, &key_id, flags,
                                         sizeof(keyLabel), keyLabel);
        if (ret == WH_ERROR_OK) {
            evict = 1;
        }
    }

    if (ret == WH_ERROR_OK) {
        uint16_t group   = WH_MESSAGE_GROUP_CRYPTO_DMA;
        uint16_t action  = WC_ALGO_TYPE_PK;
        uint32_t options = 0;

        dataPtr = wh_CommClient_GetDataPtr(ctx->comm);
        if (dataPtr == NULL) {
            return WH_ERROR_BADARGS;
        }

        req = (whMessageCrypto_Ed25519VerifyDmaRequest*)_createCryptoRequest(
            dataPtr, WC_PK_TYPE_ED25519_VERIFY, ctx->cryptoAffinity);

        uint8_t* req_ctx = (uint8_t*)(req + 1);

        if (evict != 0) {
            options |= WH_MESSAGE_CRYPTO_ED25519_VERIFY_OPTIONS_EVICT;
        }

        memset(req, 0, sizeof(*req));
        req->options = options;
        req->keyId   = key_id;
        req->type    = type;
        req->ctxSz   = contextLen;
        req->sig.sz  = sigLen;
        req->msg.sz  = msgLen;
        if ((context != NULL) && (contextLen > 0)) {
            memcpy(req_ctx, context, contextLen);
        }

        ret = wh_Client_DmaProcessClientAddress(
            ctx, (uintptr_t)sig, (void**)&sigAddr, req->sig.sz,
            WH_DMA_OPER_CLIENT_READ_PRE, (whDmaFlags){0});
        if (ret == WH_ERROR_OK) {
            req->sig.addr = sigAddr;
            ret           = wh_Client_DmaProcessClientAddress(
                ctx, (uintptr_t)msg, (void**)&msgAddr, req->msg.sz,
                WH_DMA_OPER_CLIENT_READ_PRE, (whDmaFlags){0});
        }
        if (ret == WH_ERROR_OK) {
            req->msg.addr = msgAddr;

            ret = wh_Client_SendRequest(ctx, group, action, req_len,
                                        (uint8_t*)dataPtr);
        }
        if (ret == WH_ERROR_OK) {
            evict = 0;

            uint16_t res_len = 0;
            do {
                ret = wh_Client_RecvResponse(ctx, &group, &action, &res_len,
                                             (uint8_t*)dataPtr);
            } while (ret == WH_ERROR_NOTREADY);

            if (group != WH_MESSAGE_GROUP_CRYPTO_DMA ||
                action != WC_ALGO_TYPE_PK) {
                ret = WH_ERROR_ABORTED;
            }

            if (ret == WH_ERROR_OK) {
                ret = _getCryptoResponse(dataPtr, WC_PK_TYPE_ED25519_VERIFY,
                                         (uint8_t**)&res);
                if (ret >= 0 && res != NULL) {
                    uint32_t res_total =
                        sizeof(whMessageCrypto_GenericResponseHeader) +
                        sizeof(*res);
                    if (res_total > res_len) {
                        ret = WH_ERROR_ABORTED;
                    }
                }
                if (ret >= 0) {
                    *out_res = res->verifyResult;
                }
            }
        }

        (void)wh_Client_DmaProcessClientAddress(
            ctx, (uintptr_t)msg, (void**)&msgAddr, msgLen,
            WH_DMA_OPER_CLIENT_READ_POST, (whDmaFlags){0});
        (void)wh_Client_DmaProcessClientAddress(
            ctx, (uintptr_t)sig, (void**)&sigAddr, sigLen,
            WH_DMA_OPER_CLIENT_READ_POST, (whDmaFlags){0});
    }

    if (evict != 0) {
        (void)wh_Client_KeyEvict(ctx, key_id);
    }

    /* map ASN key decoding errors to WH_ERROR_BADARGS */
    if (ret == ASN_PARSE_E)
        ret = WH_ERROR_BADARGS;

    return ret;
}
#endif /* WOLFHSM_CFG_DMA */
#endif /* HAVE_ED25519 */

#ifndef NO_RSA
int wh_Client_RsaSetKeyId(RsaKey* key, whNvmId keyId)
{
    if (key == NULL)
        return WH_ERROR_BADARGS;
    key->devCtx = WH_KEYID_TO_DEVCTX(keyId);
    return WH_ERROR_OK;
}

int wh_Client_RsaGetKeyId(RsaKey* key, whNvmId* outId)
{
    if (key == NULL || outId == NULL)
        return WH_ERROR_BADARGS;
    *outId = WH_DEVCTX_TO_KEYID(key->devCtx);
    return WH_ERROR_OK;
}


int wh_Client_RsaImportKey(whClientContext* ctx, const RsaKey* key,
                           whKeyId* inout_keyId, whNvmFlags flags,
                           uint32_t label_len, uint8_t* label)
{
    int      ret                               = 0;
    whKeyId  key_id                            = WH_KEYID_ERASED;
    byte     keyDer[WOLFHSM_CFG_COMM_DATA_LEN] = {0};
    uint16_t derSize                           = 0;

    if ((ctx == NULL) || (key == NULL) ||
        ((label_len != 0) && (label == NULL))) {
        return WH_ERROR_BADARGS;
    }

    if (inout_keyId != NULL) {
        key_id = *inout_keyId;
    }
    /* Convert RSA key to DER format */
    ret = wh_Crypto_RsaSerializeKeyDer(key, sizeof(keyDer), keyDer, &derSize);
    if (ret == WH_ERROR_OK) {
        /* Cache the key and get the keyID */
        ret = wh_Client_KeyCache(ctx, flags, label, label_len, keyDer, derSize,
                                 &key_id);
        if (inout_keyId != NULL) {
            *inout_keyId = key_id;
        }
    }
    return ret;
}

int wh_Client_RsaExportKey(whClientContext* ctx, whKeyId keyId, RsaKey* key,
                           uint32_t label_len, uint8_t* label)
{
    int ret = 0;
    /* DER cannot be larger than MTU */
    byte     keyDer[WOLFHSM_CFG_COMM_DATA_LEN] = {0};
    uint16_t derSize                           = sizeof(keyDer);
    uint8_t  keyLabel[WH_NVM_LABEL_LEN]        = {0};

    if ((ctx == NULL) || (keyId == WH_KEYID_ERASED) || (key == NULL)) {
        return WH_ERROR_BADARGS;
    }

    /* Now export the key from the server */
    ret = wh_Client_KeyExport(ctx, keyId, keyLabel, sizeof(keyLabel), keyDer,
                              &derSize);
    if (ret == WH_ERROR_OK) {
        ret = wh_Crypto_RsaDeserializeKeyDer(derSize, keyDer, key);
        if (ret == 0) {
            /* Successful parsing of RSA key.  Update the label */
            if ((label_len > 0) && (label != NULL)) {
                if (label_len > WH_NVM_LABEL_LEN) {
                    label_len = WH_NVM_LABEL_LEN;
                }
                memcpy(label, keyLabel, label_len);
            }
        }
    }

    return ret;
}

static int _RsaMakeKey(whClientContext* ctx, uint32_t size, uint32_t e,
                       whNvmFlags flags, uint32_t label_len, uint8_t* label,
                       whKeyId* inout_key_id, RsaKey* rsa)
{
    int                                ret     = WH_ERROR_OK;
    uint8_t*                           dataPtr = NULL;
    whMessageCrypto_RsaKeyGenRequest*  req     = NULL;
    whMessageCrypto_RsaKeyGenResponse* res     = NULL;
    uint16_t                           group   = WH_MESSAGE_GROUP_CRYPTO;
    uint16_t                           action  = WC_ALGO_TYPE_PK;
    whKeyId                            key_id  = WH_KEYID_ERASED;

    if (ctx == NULL) {
        return WH_ERROR_BADARGS;
    }

    /* Get data pointer from the context to use as request/response storage */
    dataPtr = wh_CommClient_GetDataPtr(ctx->comm);
    if (dataPtr == NULL) {
        return WH_ERROR_BADARGS;
    }

    /* Setup generic header and get pointer to request data */
    req = (whMessageCrypto_RsaKeyGenRequest*)_createCryptoRequest(
        dataPtr, WC_PK_TYPE_RSA_KEYGEN, ctx->cryptoAffinity);

    uint16_t req_len =
        sizeof(whMessageCrypto_GenericRequestHeader) + sizeof(*req);

    /* Use the supplied key id if provided */
    if (inout_key_id != NULL) {
        key_id = *inout_key_id;
    }

    /* Populate request body directly */
    req->size  = size;
    req->e     = e;
    req->flags = flags;
    req->keyId = key_id; /* Use key_id from inout_key_id or ERASED */
    if ((label != NULL) && (label_len > 0)) {
        if (label_len > WH_NVM_LABEL_LEN) {
            label_len = WH_NVM_LABEL_LEN;
        }
        memcpy(req->label, label, label_len);
        /* Ensure null termination if space allows, though protocol doesn't
         * require */
        if (label_len < WH_NVM_LABEL_LEN) {
            req->label[label_len] = '\0';
        }
    }
    else {
        memset(req->label, 0, WH_NVM_LABEL_LEN);
    }

    /* Send Request */
    ret = wh_Client_SendRequest(ctx, group, action, req_len, dataPtr);
    WH_DEBUG_CLIENT_VERBOSE("RSA KeyGen Req sent:size:%u, e:%u, ret:%d\n",
           (unsigned int)req->size, (unsigned int)req->e, ret);
    if (ret == 0) {
        uint16_t res_len = 0;
        do {
            ret =
                wh_Client_RecvResponse(ctx, &group, &action, &res_len, dataPtr);
        } while (ret == WH_ERROR_NOTREADY);

        WH_DEBUG_CLIENT_VERBOSE("RSA KeyGen Res recv: ret:%d, res_len: %u\n", ret,
               (unsigned int)res_len);

        if (ret == WH_ERROR_OK) {
            /* Get response structure pointer, validates generic header rc */
            ret = _getCryptoResponse(dataPtr, WC_PK_TYPE_RSA_KEYGEN,
                                     (uint8_t**)&res);
        }

        if (ret == WH_ERROR_OK) {
            /* Key is cached on server or is ephemeral */
            key_id = (whKeyId)(res->keyId);

            /* Update output variable if requested */
            if (inout_key_id != NULL) {
                *inout_key_id = key_id;
            }

            /* Update the RSA context if provided */
            if (rsa != NULL) {
                word32   der_size = (word32)(res->len);
                uint8_t* rsa_der  = (uint8_t*)(res + 1);

                /* Set the rsa key_id.  Should be ERASED if EPHEMERAL */
                wh_Client_RsaSetKeyId(rsa, key_id);

                WH_DEBUG_CLIENT_VERBOSE("Set key_id:%x with flags:%x\n",
                       key_id, flags);
                if (flags & WH_NVM_FLAGS_EPHEMERAL) {
                    /* Response has the exported key */
                    ret =
                        wh_Crypto_RsaDeserializeKeyDer(der_size, rsa_der, rsa);
                }
            }
        }
    }
    return ret;
}

int wh_Client_RsaMakeCacheKey(whClientContext* ctx, uint32_t size, uint32_t e,
                              whKeyId* inout_key_id, whNvmFlags flags,
                              uint32_t label_len, uint8_t* label)
{
    if ((ctx == NULL) || (inout_key_id == NULL)) {
        return WH_ERROR_BADARGS;
    }

    return _RsaMakeKey(ctx, size, e, flags, label_len, label, inout_key_id,
                       NULL);
}

int wh_Client_RsaMakeExportKey(whClientContext* ctx, uint32_t size, uint32_t e,
                               RsaKey* rsa)
{
    if ((ctx == NULL) || (rsa == NULL)) {
        return WH_ERROR_BADARGS;
    }

    return _RsaMakeKey(ctx, size, e, WH_NVM_FLAGS_EPHEMERAL, 0, NULL, NULL,
                       rsa);
}

int wh_Client_RsaFunction(whClientContext* ctx, RsaKey* key, int rsa_type,
                          const uint8_t* in, uint16_t in_len, uint8_t* out,
                          uint16_t* inout_out_len)
{
    int                          ret     = WH_ERROR_OK;
    whMessageCrypto_RsaRequest*  req     = NULL;
    whMessageCrypto_RsaResponse* res     = NULL;
    uint8_t*                     dataPtr = NULL;

    /* Transaction state */
    whKeyId key_id;
    int     evict = 0;

    WH_DEBUG_CLIENT_VERBOSE("ctx:%p key:%p, rsa_type:%d in:%p in_len:%u, out:%p "
           "inout_out_len:%p\n",
           ctx, key, rsa_type, in, (unsigned)in_len, out,
           inout_out_len);

    if ((ctx == NULL) || (key == NULL) || ((in == NULL) && (in_len > 0)) ||
        ((out != NULL) && (inout_out_len == NULL))) {
        return WH_ERROR_BADARGS;
    }

    key_id = WH_DEVCTX_TO_KEYID(key->devCtx);

    WH_DEBUG_CLIENT_VERBOSE("key_id:%x\n", key_id);

    /* Import key if necessary */
    if (WH_KEYID_ISERASED(key_id)) {
        /* Must import the key to the server and evict it afterwards */
        uint8_t    keyLabel[] = "TempRsaFunction";
        /* Set usage flags based on requested RSA operation */
        whNvmFlags flags = WH_NVM_FLAGS_NONE;
        switch (rsa_type) {
            case RSA_PUBLIC_ENCRYPT:
            case RSA_PRIVATE_ENCRYPT:
                flags = WH_NVM_FLAGS_USAGE_ENCRYPT;
                break;
            case RSA_PUBLIC_DECRYPT:
            case RSA_PRIVATE_DECRYPT:
                flags = WH_NVM_FLAGS_USAGE_DECRYPT;
                break;
            default:
                flags = WH_NVM_FLAGS_ANY;
                break;
        }

        ret = wh_Client_RsaImportKey(ctx, key, &key_id, flags, sizeof(keyLabel),
                                     keyLabel);
        if (ret == WH_ERROR_OK) {
            evict = 1;
        }
    }

    if (ret == WH_ERROR_OK) {
        /* Get data pointer */
        dataPtr = (uint8_t*)wh_CommClient_GetDataPtr(ctx->comm);
        if (dataPtr == NULL) {
            return WH_ERROR_BADARGS;
        }

        req = (whMessageCrypto_RsaRequest*)_createCryptoRequest(
            dataPtr, WC_PK_TYPE_RSA, ctx->cryptoAffinity);

        uint16_t group  = WH_MESSAGE_GROUP_CRYPTO;
        uint16_t action = WC_ALGO_TYPE_PK;

        uint8_t* req_in  = (uint8_t*)(req + 1);
        uint16_t req_len = sizeof(whMessageCrypto_GenericRequestHeader) +
                           sizeof(*req) + in_len;
        uint32_t options = 0;

        if (req_len <= WOLFHSM_CFG_COMM_DATA_LEN) {
            if (evict != 0) {
                options |= WH_MESSAGE_CRYPTO_RSA_OPTIONS_EVICT;
            }

            memset(req, 0, sizeof(*req));
            req->opType  = rsa_type;
            req->options = options;
            req->keyId   = key_id;
            req->inLen   = in_len;
            if ((in != NULL) && (in_len > 0)) {
                memcpy(req_in, in, in_len);
            }
            /* Set output length only when provided to avoid NULL dereference */
            req->outLen = (inout_out_len != NULL) ? *inout_out_len : 0;

            /* Send Request */
            ret = wh_Client_SendRequest(ctx, group, action, req_len,
                                        (uint8_t*)dataPtr);
            if (ret == WH_ERROR_OK) {
                /* Server will evict at this point. Reset evict */
                evict            = 0;
                uint16_t res_len = 0;

                /* Recv Response */
                do {
                    ret = wh_Client_RecvResponse(ctx, &group, &action, &res_len,
                                                 (uint8_t*)dataPtr);
                } while (ret == WH_ERROR_NOTREADY);

                if (ret == WH_ERROR_OK) {
                    /* Get response */
                    ret = _getCryptoResponse(dataPtr, WC_PK_TYPE_RSA,
                                             (uint8_t**)&res);
                    /* wolfCrypt allows positive error codes on success in some
                     * scenarios */
                    if (ret >= 0) {
                        /* Get response output pointer */
                        uint8_t* res_out = (uint8_t*)(res + 1);
                        uint16_t out_len = res->outLen;
                        /* check inoutlen and read out */
                        if (inout_out_len != NULL) {
                            if (out_len > *inout_out_len) {
                                /* Silently truncate the response */
                                out_len = *inout_out_len;
                            }
                            *inout_out_len = out_len;
                            if ((out != NULL) && (out_len > 0)) {
                                memcpy(out, res_out, out_len);
                            }
                        }
                    }
                }
            }
        }
        else {
            /* Request length is too long */
            ret = WH_ERROR_BADARGS;
        }
    }
    /* Evict the key manually on error */
    if (evict != 0) {
        (void)wh_Client_KeyEvict(ctx, key_id);
    }
    WH_DEBUG_CLIENT_VERBOSE("ret:%d\n", ret);
    return ret;
}

int wh_Client_RsaGetSize(whClientContext* ctx, const RsaKey* key, int* out_size)
{
    int ret = WH_ERROR_OK;

    /* Transaction state */
    whKeyId key_id;
    int     evict = 0;

    WH_DEBUG_CLIENT_VERBOSE("ctx:%p key:%p, out_size:%p \n", ctx, key,
           out_size);

    if ((ctx == NULL) || (key == NULL) || (out_size == NULL)) {
        return WH_ERROR_BADARGS;
    }

    key_id = WH_DEVCTX_TO_KEYID(key->devCtx);

    /* Import key if necessary */
    if (WH_KEYID_ISERASED(key_id)) {
        /* Must import the key to the server and evict it afterwards */
        uint8_t    keyLabel[] = "TempRsaGetSize";
        whNvmFlags flags      = WH_NVM_FLAGS_NONE;

        WH_DEBUG_CLIENT_VERBOSE("Importing temp key\n");
        ret = wh_Client_RsaImportKey(ctx, key, &key_id, flags, sizeof(keyLabel),
                                     keyLabel);
        if (ret == WH_ERROR_OK) {
            evict = 1;
        }
    }

    if (ret == WH_ERROR_OK) {
        uint8_t*                            dataPtr = NULL;
        whMessageCrypto_RsaGetSizeRequest*  req     = NULL;
        whMessageCrypto_RsaGetSizeResponse* res     = NULL;
        uint16_t                            group   = WH_MESSAGE_GROUP_CRYPTO;
        uint16_t                            action  = WC_ALGO_TYPE_PK;

        uint16_t req_len =
            sizeof(whMessageCrypto_GenericRequestHeader) + sizeof(*req);
        uint32_t options = 0;

        /* Get data pointer */
        dataPtr = (uint8_t*)wh_CommClient_GetDataPtr(ctx->comm);
        if (dataPtr == NULL) {
            return WH_ERROR_BADARGS;
        }

        req = (whMessageCrypto_RsaGetSizeRequest*)_createCryptoRequest(
            dataPtr, WC_PK_TYPE_RSA_GET_SIZE, ctx->cryptoAffinity);

        if (req_len <= WOLFHSM_CFG_COMM_DATA_LEN) {
            if (evict != 0) {
                options |= WH_MESSAGE_CRYPTO_RSA_GET_SIZE_OPTIONS_EVICT;
            }

            memset(req, 0, sizeof(*req));
            req->options = options;
            req->keyId   = key_id;

            /* Send Request */
            ret = wh_Client_SendRequest(ctx, group, action, req_len,
                                        (uint8_t*)dataPtr);
            if (ret == WH_ERROR_OK) {
                /* Server will evict at this point. Reset evict */
                evict            = 0;
                uint16_t res_len = 0;

                /* Recv Response */
                do {
                    ret = wh_Client_RecvResponse(ctx, &group, &action, &res_len,
                                                 (uint8_t*)dataPtr);
                } while (ret == WH_ERROR_NOTREADY);

                if (ret == WH_ERROR_OK) {
                    /* Get response */
                    ret = _getCryptoResponse(dataPtr, WC_PK_TYPE_RSA_GET_SIZE,
                                             (uint8_t**)&res);
                    /* wolfCrypt allows positive error codes on success in some
                     * scenarios */
                    if (ret >= 0) {
                        *out_size = res->keySize;
                    }
                }
            }
        }
        else {
            /* Request length is too long */
            ret = WH_ERROR_BADARGS;
        }
    }
    /* Evict the key manually on error */
    if (evict != 0) {
        WH_DEBUG_CLIENT_VERBOSE("Evicting temp key %x\n", key_id);
        (void)wh_Client_KeyEvict(ctx, key_id);
    }
    WH_DEBUG_CLIENT_VERBOSE("ret:%d\n", ret);
    return ret;
}


#endif /* !NO_RSA */

#ifdef HAVE_HKDF
/* Internal helper function to generate HKDF output on the server */
static int _HkdfMakeKey(whClientContext* ctx, int hashType, whKeyId keyIdIn,
                        const uint8_t* inKey, uint32_t inKeySz,
                        const uint8_t* salt, uint32_t saltSz,
                        const uint8_t* info, uint32_t infoSz, whNvmFlags flags,
                        uint32_t label_len, const uint8_t* label,
                        whKeyId* inout_key_id, uint8_t* out, uint32_t outSz)
{
    int                           ret     = WH_ERROR_OK;
    uint8_t*                      dataPtr = NULL;
    whMessageCrypto_HkdfRequest*  req     = NULL;
    whMessageCrypto_HkdfResponse* res     = NULL;
    uint16_t                      group   = WH_MESSAGE_GROUP_CRYPTO;
    uint16_t                      action  = WC_ALGO_TYPE_KDF;
    whKeyId                       key_id  = WH_KEYID_ERASED;

    if ((ctx == NULL) || ((inKey == NULL) && (inKeySz != 0))) {
        return WH_ERROR_BADARGS;
    }

    /* Get data pointer from the context to use as request/response storage */
    dataPtr = wh_CommClient_GetDataPtr(ctx->comm);
    if (dataPtr == NULL) {
        return WH_ERROR_BADARGS;
    }

    /* Setup generic header and get pointer to request data */
    req = (whMessageCrypto_HkdfRequest*)_createCryptoRequestWithSubtype(
        dataPtr, WC_ALGO_TYPE_KDF, WC_KDF_TYPE_HKDF, ctx->cryptoAffinity);

    /* Calculate request length including variable-length data */
    uint16_t req_len = sizeof(whMessageCrypto_GenericRequestHeader) +
                       sizeof(*req) + inKeySz + saltSz + infoSz;

    /* Use the supplied key id if provided */
    if (inout_key_id != NULL) {
        key_id = *inout_key_id;
    }

    /* Populate request body */
    req->flags    = flags;
    req->keyIdIn  = keyIdIn;
    req->keyIdOut = key_id;
    req->hashType = hashType;
    req->inKeySz  = inKeySz;
    req->saltSz   = saltSz;
    req->infoSz   = infoSz;
    req->outSz    = outSz;

    /* Copy label if provided */
    memset(req->label, 0, WH_NVM_LABEL_LEN);
    if ((label != NULL) && (label_len > 0)) {
        if (label_len > WH_NVM_LABEL_LEN) {
            label_len = WH_NVM_LABEL_LEN;
        }
        memcpy(req->label, label, label_len);
    }

    /* Copy variable-length data after the request structure */
    uint8_t* data_ptr = (uint8_t*)(req + 1);

    /* Copy input key material */
    if ((inKey != NULL) && (inKeySz > 0)) {
        memcpy(data_ptr, inKey, inKeySz);
        data_ptr += inKeySz;
    }

    /* Copy salt if provided */
    if (salt != NULL && saltSz > 0) {
        memcpy(data_ptr, salt, saltSz);
        data_ptr += saltSz;
    }

    /* Copy info if provided */
    if (info != NULL && infoSz > 0) {
        memcpy(data_ptr, info, infoSz);
    }

    /* Send Request */
    ret = wh_Client_SendRequest(ctx, group, action, req_len, dataPtr);

    WH_DEBUG_CLIENT_VERBOSE("HKDF Req sent: hashType:%d inKeySz:%u saltSz:%u infoSz:%u outSz:%u "
           "ret:%d\n",
           (int)req->hashType, (unsigned int)req->inKeySz,
           (unsigned int)req->saltSz, (unsigned int)req->infoSz,
           (unsigned int)req->outSz, ret);

    if (ret == 0) {
        uint16_t res_len = 0;
        do {
            ret =
                wh_Client_RecvResponse(ctx, &group, &action, &res_len, dataPtr);
        } while (ret == WH_ERROR_NOTREADY);

        WH_DEBUG_CLIENT_VERBOSE("HKDF Res recv: ret:%d, res_len: %u\n", ret,
               (unsigned int)res_len);

        if (ret == WH_ERROR_OK) {
            /* Get response structure pointer, validates generic header rc */
            ret =
                _getCryptoResponse(dataPtr, WC_ALGO_TYPE_KDF, (uint8_t**)&res);
        }

        if (ret == WH_ERROR_OK) {
            /* Key is cached on server or is ephemeral */
            key_id = (whKeyId)(res->keyIdOut);

            /* Update output variable if requested */
            if (inout_key_id != NULL) {
                *inout_key_id = key_id;
            }

            /* Copy output key material if output buffer provided */
            if (out != NULL) {
                if (res->outSz <= outSz) {
                    uint8_t* hkdf_out = (uint8_t*)(res + 1);
                    memcpy(out, hkdf_out, res->outSz);

                    WH_DEBUG_CLIENT_VERBOSE("Set key_id:%x with flags:%x outSz:%u\n",
                           key_id, flags, (unsigned int)res->outSz);
                }
                else {
                    /* Server returned more than we can handle - error */
                    ret = WH_ERROR_ABORTED;
                }
            }
        }
    }
    return ret;
}

int wh_Client_HkdfMakeCacheKey(whClientContext* ctx, int hashType,
                               whKeyId keyIdIn, const uint8_t* inKey,
                               uint32_t inKeySz, const uint8_t* salt,
                               uint32_t saltSz, const uint8_t* info,
                               uint32_t infoSz, whKeyId* inout_key_id,
                               whNvmFlags flags, const uint8_t* label,
                               uint32_t label_len, uint32_t outSz)
{
    if ((ctx == NULL) || (inout_key_id == NULL)) {
        return WH_ERROR_BADARGS;
    }

    return _HkdfMakeKey(ctx, hashType, keyIdIn, inKey, inKeySz, salt, saltSz,
                        info, infoSz, flags, label_len, label, inout_key_id,
                        NULL, outSz);
}

int wh_Client_HkdfMakeExportKey(whClientContext* ctx, int hashType,
                                whKeyId keyIdIn, const uint8_t* inKey,
                                uint32_t inKeySz, const uint8_t* salt,
                                uint32_t saltSz, const uint8_t* info,
                                uint32_t infoSz, uint8_t* out, uint32_t outSz)
{
    if ((ctx == NULL) || (out == NULL)) {
        return WH_ERROR_BADARGS;
    }

    return _HkdfMakeKey(ctx, hashType, keyIdIn, inKey, inKeySz, salt, saltSz,
                        info, infoSz, WH_NVM_FLAGS_EPHEMERAL, 0, NULL, NULL,
                        out, outSz);
}

#endif /* HAVE_HKDF */

#ifdef HAVE_CMAC_KDF
static int _CmacKdfMakeKey(whClientContext* ctx, whKeyId saltKeyId,
                           const uint8_t* salt, uint32_t saltSz, whKeyId zKeyId,
                           const uint8_t* z, uint32_t zSz,
                           const uint8_t* fixedInfo, uint32_t fixedInfoSz,
                           whNvmFlags flags, uint32_t label_len,
                           const uint8_t* label, whKeyId* inout_key_id,
                           uint8_t* out, uint32_t outSz)
{
    int                              ret     = WH_ERROR_OK;
    uint8_t*                         dataPtr = NULL;
    whMessageCrypto_CmacKdfRequest*  req     = NULL;
    whMessageCrypto_CmacKdfResponse* res     = NULL;
    uint16_t                         group   = WH_MESSAGE_GROUP_CRYPTO;
    uint16_t                         action  = WC_ALGO_TYPE_KDF;
    whKeyId                          key_id  = WH_KEYID_ERASED;

    if ((ctx == NULL) || (outSz == 0)) {
        return WH_ERROR_BADARGS;
    }

    if ((saltSz > 0 && salt == NULL) || (zSz > 0 && z == NULL) ||
        (fixedInfoSz > 0 && fixedInfo == NULL)) {
        return WH_ERROR_BADARGS;
    }

    /* Retrieve the shared communication buffer */
    dataPtr = wh_CommClient_GetDataPtr(ctx->comm);
    if (dataPtr == NULL) {
        return WH_ERROR_BADARGS;
    }

    /* Prepare request structure with subtype information */
    req = (whMessageCrypto_CmacKdfRequest*)_createCryptoRequestWithSubtype(
        dataPtr, WC_ALGO_TYPE_KDF, WC_KDF_TYPE_TWOSTEP_CMAC,
        ctx->cryptoAffinity);

    uint32_t total_len = sizeof(whMessageCrypto_GenericRequestHeader) +
                         sizeof(*req) + saltSz + zSz + fixedInfoSz;

    if (total_len > WOLFHSM_CFG_COMM_DATA_LEN) {
        return WH_ERROR_BADARGS;
    }
    uint16_t req_len = (uint16_t)total_len;

    if (inout_key_id != NULL) {
        key_id = *inout_key_id;
    }

    req->flags       = flags;
    req->keyIdSalt   = saltKeyId;
    req->keyIdZ      = zKeyId;
    req->keyIdOut    = key_id;
    req->saltSz      = saltSz;
    req->zSz         = zSz;
    req->fixedInfoSz = fixedInfoSz;
    req->outSz       = outSz;

    memset(req->label, 0, WH_NVM_LABEL_LEN);
    if ((label != NULL) && (label_len > 0)) {
        if (label_len > WH_NVM_LABEL_LEN) {
            label_len = WH_NVM_LABEL_LEN;
        }
        memcpy(req->label, label, label_len);
    }

    uint8_t* payload = (uint8_t*)(req + 1);

    if (saltSz > 0 && salt != NULL) {
        memcpy(payload, salt, saltSz);
        payload += saltSz;
    }

    if (zSz > 0 && z != NULL) {
        memcpy(payload, z, zSz);
        payload += zSz;
    }

    if (fixedInfoSz > 0 && fixedInfo != NULL) {
        memcpy(payload, fixedInfo, fixedInfoSz);
        payload += fixedInfoSz;
    }

    /* squash unused warning */
    (void)payload;

    ret = wh_Client_SendRequest(ctx, group, action, req_len, dataPtr);
    if (ret != WH_ERROR_OK) {
        return ret;
    }

    uint16_t res_len = 0;
    do {
        ret = wh_Client_RecvResponse(ctx, &group, &action, &res_len, dataPtr);
    } while (ret == WH_ERROR_NOTREADY);

    if (ret == WH_ERROR_OK) {
        ret = _getCryptoResponse(dataPtr, WC_ALGO_TYPE_KDF, (uint8_t**)&res);
    }

    if (ret == WH_ERROR_OK) {
        key_id = (whKeyId)(res->keyIdOut);

        if (inout_key_id != NULL) {
            *inout_key_id = key_id;
        }

        if (out != NULL) {
            if (res->outSz <= outSz) {
                uint8_t* out_data = (uint8_t*)(res + 1);
                memcpy(out, out_data, res->outSz);
            }
            else {
                ret = WH_ERROR_ABORTED;
            }
        }
    }

    return ret;
}

int wh_Client_CmacKdfMakeCacheKey(whClientContext* ctx, whKeyId saltKeyId,
                                  const uint8_t* salt, uint32_t saltSz,
                                  whKeyId zKeyId, const uint8_t* z,
                                  uint32_t zSz, const uint8_t* fixedInfo,
                                  uint32_t fixedInfoSz, whKeyId* inout_key_id,
                                  whNvmFlags flags, const uint8_t* label,
                                  uint32_t label_len, uint32_t outSz)
{
    if ((ctx == NULL) || (inout_key_id == NULL)) {
        return WH_ERROR_BADARGS;
    }

    return _CmacKdfMakeKey(ctx, saltKeyId, salt, saltSz, zKeyId, z, zSz,
                           fixedInfo, fixedInfoSz, flags, label_len, label,
                           inout_key_id, NULL, outSz);
}

int wh_Client_CmacKdfMakeExportKey(whClientContext* ctx, whKeyId saltKeyId,
                                   const uint8_t* salt, uint32_t saltSz,
                                   whKeyId zKeyId, const uint8_t* z,
                                   uint32_t zSz, const uint8_t* fixedInfo,
                                   uint32_t fixedInfoSz, uint8_t* out,
                                   uint32_t outSz)
{
    if ((ctx == NULL) || (out == NULL)) {
        return WH_ERROR_BADARGS;
    }

    return _CmacKdfMakeKey(ctx, saltKeyId, salt, saltSz, zKeyId, z, zSz,
                           fixedInfo, fixedInfoSz, WH_NVM_FLAGS_EPHEMERAL, 0,
                           NULL, NULL, out, outSz);
}
#endif /* HAVE_CMAC_KDF */

#ifndef NO_AES
int wh_Client_AesSetKeyId(Aes* key, whNvmId keyId)
{
    if (key == NULL)
        return WH_ERROR_BADARGS;
    key->devCtx = WH_KEYID_TO_DEVCTX(keyId);
    return WH_ERROR_OK;
}

int wh_Client_AesGetKeyId(Aes* key, whNvmId* outId)
{
    if (key == NULL || outId == NULL)
        return WH_ERROR_BADARGS;
    *outId = WH_DEVCTX_TO_KEYID(key->devCtx);
    return WH_ERROR_OK;
}
#endif /* !NO_AES */

#ifdef WOLFSSL_CMAC
int wh_Client_CmacSetKeyId(Cmac* key, whNvmId keyId)
{
    if (key == NULL)
        return WH_ERROR_BADARGS;
    key->devCtx = WH_KEYID_TO_DEVCTX(keyId);
    return WH_ERROR_OK;
}

int wh_Client_CmacGetKeyId(Cmac* key, whNvmId* outId)
{
    if (key == NULL || outId == NULL)
        return WH_ERROR_BADARGS;
    *outId = WH_DEVCTX_TO_KEYID(key->devCtx);
    return WH_ERROR_OK;
}

#ifndef NO_AES

int wh_Client_Cmac(whClientContext* ctx, Cmac* cmac, CmacType type,
                   const uint8_t* key, uint32_t keyLen, const uint8_t* in,
                   uint32_t inLen, uint8_t* outMac, uint32_t* outMacLen)
{
    int                              ret     = WH_ERROR_OK;
    uint16_t                         group   = WH_MESSAGE_GROUP_CRYPTO;
    uint16_t                         action  = WC_ALGO_TYPE_CMAC;
    whMessageCrypto_CmacAesRequest*  req     = NULL;
    whMessageCrypto_CmacAesResponse* res     = NULL;
    uint8_t*                         dataPtr = NULL;

    if (ctx == NULL || cmac == NULL) {
        return WH_ERROR_BADARGS;
    }

    whKeyId  key_id = WH_DEVCTX_TO_KEYID(cmac->devCtx);
    uint32_t mac_len =
        ((outMac == NULL) || (outMacLen == NULL)) ? 0 : *outMacLen;

    /* For non-HSM keys on incremental calls (update/final with no key argument
     * provided), send the stored key bytes so the server can reconstruct the
     * CMAC context */
    if (key == NULL && keyLen == 0 && WH_KEYID_ISERASED(key_id) &&
        (inLen != 0 || mac_len != 0)) {
        key    = (const uint8_t*)cmac->aes.devKey;
        keyLen = cmac->aes.keylen;
    }

    /* Update type and return success for 0 length data, nothing else to do */
    if ((inLen == 0) && (keyLen == 0) && (mac_len == 0)) {
        /* Update the type */
        cmac->type = type;
        return WH_ERROR_OK;
    }

    WH_DEBUG_CLIENT_VERBOSE(
        "cmac key:%p key_len:%d in:%p in_len:%d out:%p out_len:%d "
        "keyId:%x\n",
        key, (int)keyLen, in, (int)inLen, outMac, (int)mac_len, key_id);

    /* Get data pointer */
    dataPtr = (uint8_t*)wh_CommClient_GetDataPtr(ctx->comm);
    if (dataPtr == NULL) {
        return WH_ERROR_BADARGS;
    }

    /* Setup generic header and get pointer to request data */
    req = (whMessageCrypto_CmacAesRequest*)_createCryptoRequest(
        dataPtr, WC_ALGO_TYPE_CMAC, ctx->cryptoAffinity);

    uint8_t* req_in  = (uint8_t*)(req + 1);
    uint8_t* req_key = req_in + inLen;
    uint32_t hdr_sz =
        sizeof(whMessageCrypto_GenericRequestHeader) + sizeof(*req);

    if (inLen > WOLFHSM_CFG_COMM_DATA_LEN - hdr_sz ||
        keyLen > WOLFHSM_CFG_COMM_DATA_LEN - hdr_sz - inLen) {
        return WH_ERROR_BADARGS;
    }
    uint16_t req_len = hdr_sz + inLen + keyLen;

    /* Setup request packet */
    req->inSz  = inLen;
    req->keyId = key_id;
    req->keySz = keyLen;
    req->outSz = mac_len;

    /* Pack non-sensitive CMAC state into request */
    wh_Crypto_CmacAesSaveStateToMsg(&req->resumeState, cmac);

    /* copy input data to request, if relevant */
    if ((in != NULL) && (inLen > 0)) {
        memcpy(req_in, in, inLen);
    }
    if ((key != NULL) && (keyLen > 0)) {
        memcpy(req_key, key, keyLen);
    }

    /* Send request */
    ret = wh_Client_SendRequest(ctx, group, action, req_len, (uint8_t*)dataPtr);
    if (ret == WH_ERROR_OK) {
        /* Update the local type since call succeeded */
        cmac->type = type;

        /* If using non-HSM keys, store key bytes locally for future calls */
        if (key != NULL && keyLen > 0 && WH_KEYID_ISERASED(key_id)) {
            memcpy((void*)cmac->aes.devKey, key, keyLen);
            cmac->aes.keylen = keyLen;
        }


        uint16_t res_len = 0;
        do {
            ret = wh_Client_RecvResponse(ctx, &group, &action, &res_len,
                                         (uint8_t*)dataPtr);
        } while (ret == WH_ERROR_NOTREADY);
        if (ret == WH_ERROR_OK) {
            /* Get response */
            ret =
                _getCryptoResponse(dataPtr, WC_ALGO_TYPE_CMAC, (uint8_t**)&res);
            /* wolfCrypt allows positive error codes on success in some
             * scenarios */
            if (ret >= 0) {
                /* Restore non-sensitive state from server response */
                ret = wh_Crypto_CmacAesRestoreStateFromMsg(cmac,
                                                           &res->resumeState);

                /* Copy out finalized CMAC if present */
                if (ret == 0 && outMac != NULL && outMacLen != NULL) {
                    if (res->outSz < *outMacLen) {
                        *outMacLen = res->outSz;
                    }
                    uint8_t* res_mac = (uint8_t*)(res + 1);
                    memcpy(outMac, res_mac, *outMacLen);
                }
            }
        }
    }
    return ret;
}

#endif /* !NO_AES */


#ifdef WOLFHSM_CFG_DMA
int wh_Client_CmacDma(whClientContext* ctx, Cmac* cmac, CmacType type,
                      const uint8_t* key, uint32_t keyLen, const uint8_t* in,
                      uint32_t inLen, uint8_t* outMac, uint32_t* outMacLen)
{
    int                                 ret     = WH_ERROR_OK;
    whMessageCrypto_CmacAesDmaRequest*  req     = NULL;
    whMessageCrypto_CmacAesDmaResponse* res     = NULL;
    uint8_t*                            dataPtr = NULL;
    uintptr_t                           inAddr  = 0;

    if (ctx == NULL || cmac == NULL) {
        return WH_ERROR_BADARGS;
    }

    whKeyId  key_id = WH_DEVCTX_TO_KEYID(cmac->devCtx);
    uint32_t mac_len =
        ((outMac == NULL) || (outMacLen == NULL)) ? 0 : *outMacLen;

    /* For non-HSM keys on subsequent calls (no key provided), send the
     * stored key bytes so the server can reconstruct the CMAC context */
    if (key == NULL && keyLen == 0 && WH_KEYID_ISERASED(key_id) &&
        (inLen != 0 || mac_len != 0)) {
        key    = (const uint8_t*)cmac->aes.devKey;
        keyLen = cmac->aes.keylen;
    }

    /* Return success for a call with NULL params, or 0 len's */
    if ((inLen == 0) && (keyLen == 0) && (mac_len == 0)) {
        /* Update the type */
        cmac->type = type;
        return WH_ERROR_OK;
    }

    WH_DEBUG_CLIENT_VERBOSE(
        "cmac dma key:%p key_len:%d in:%p in_len:%d out:%p out_len:%d "
        "keyId:%x\n",
        key, (int)keyLen, in, (int)inLen, outMac, (int)mac_len, key_id);

    /* Get data pointer from the context to use as request/response storage */
    dataPtr = (uint8_t*)wh_CommClient_GetDataPtr(ctx->comm);
    if (dataPtr == NULL) {
        return WH_ERROR_BADARGS;
    }

    /* Setup generic header and get pointer to request data */
    req = (whMessageCrypto_CmacAesDmaRequest*)_createCryptoRequest(
        dataPtr, WC_ALGO_TYPE_CMAC, ctx->cryptoAffinity);
    memset(req, 0, sizeof(*req));

    uint8_t* req_key = (uint8_t*)(req + 1);
    uint32_t hdr_sz =
        sizeof(whMessageCrypto_GenericRequestHeader) + sizeof(*req);

    if (keyLen > WOLFHSM_CFG_COMM_DATA_LEN - hdr_sz) {
        return WH_ERROR_BADARGS;
    }
    uint16_t req_len = hdr_sz + keyLen;

    /* Setup request fields */
    req->outSz = mac_len;
    req->keyId = key_id;
    req->keySz = keyLen;

    /* Pack non-sensitive CMAC state into request */
    wh_Crypto_CmacAesSaveStateToMsg(&req->resumeState, cmac);

    /* Copy key bytes into trailing data */
    if ((key != NULL) && (keyLen > 0)) {
        memcpy(req_key, key, keyLen);
    }

    /* DMA for input data only */
    if (ret == WH_ERROR_OK && in != NULL && inLen != 0) {
        req->input.sz = inLen;
        ret           = wh_Client_DmaProcessClientAddress(
            ctx, (uintptr_t)in, (void**)&inAddr, req->input.sz,
            WH_DMA_OPER_CLIENT_READ_PRE, (whDmaFlags){0});
        if (ret == WH_ERROR_OK) {
            req->input.addr = inAddr;
        }
    }

    if (ret == WH_ERROR_OK) {
        /* Send the request */
        ret = wh_Client_SendRequest(ctx, WH_MESSAGE_GROUP_CRYPTO_DMA,
                                    WC_ALGO_TYPE_CMAC, req_len,
                                    (uint8_t*)dataPtr);
    }

    if (ret == WH_ERROR_OK) {
        /* Update the local type since call succeeded */
        cmac->type = type;

        /* Store key bytes locally for future calls (non-HSM keys) */
        if (key != NULL && keyLen > 0 && WH_KEYID_ISERASED(key_id)) {
            memcpy((void*)cmac->aes.devKey, key, keyLen);
            cmac->aes.keylen = keyLen;
        }

        uint16_t respSz = 0;
        do {
            ret = wh_Client_RecvResponse(ctx, NULL, NULL, &respSz,
                                         (uint8_t*)dataPtr);
        } while (ret == WH_ERROR_NOTREADY);

        if (ret == WH_ERROR_OK) {
            ret =
                _getCryptoResponse(dataPtr, WC_ALGO_TYPE_CMAC, (uint8_t**)&res);
            /* wolfCrypt allows positive error codes on success */
            if (ret >= 0) {
                /* Restore non-sensitive state from server response */
                ret = wh_Crypto_CmacAesRestoreStateFromMsg(cmac,
                                                           &res->resumeState);

                /* Copy out finalized CMAC if present */
                if (ret == 0 && outMac != NULL && outMacLen != NULL) {
                    if (res->outSz < *outMacLen) {
                        *outMacLen = res->outSz;
                    }
                    uint8_t* res_mac = (uint8_t*)(res + 1);
                    memcpy(outMac, res_mac, *outMacLen);
                }
            }
        }
    }

    /* Post DMA cleanup for input address */
    if (in != NULL && inAddr != 0) {
        (void)wh_Client_DmaProcessClientAddress(
            ctx, (uintptr_t)in, (void**)&inAddr, inLen,
            WH_DMA_OPER_CLIENT_READ_POST, (whDmaFlags){0});
    }

    return ret;
}
#endif /* WOLFHSM_CFG_DMA */

#endif /* WOLFSSL_CMAC */

#ifndef NO_SHA256

static int _xferSha256BlockAndUpdateDigest(whClientContext* ctx,
                                           wc_Sha256*       sha256,
                                           uint32_t         isLastBlock)
{
    uint16_t                        group   = WH_MESSAGE_GROUP_CRYPTO;
    uint16_t                        action  = WH_MESSAGE_ACTION_NONE;
    int                             ret     = 0;
    uint16_t                        dataSz  = 0;
    whMessageCrypto_Sha256Request*  req     = NULL;
    whMessageCrypto_Sha2Response*   res     = NULL;
    uint8_t*                        dataPtr = NULL;

    /* Get data buffer */
    dataPtr = wh_CommClient_GetDataPtr(ctx->comm);
    if (dataPtr == NULL) {
        return WH_ERROR_BADARGS;
    }

    /* Setup generic header and get pointer to request data */
    req = (whMessageCrypto_Sha256Request*)_createCryptoRequest(
        dataPtr, WC_HASH_TYPE_SHA256, ctx->cryptoAffinity);


    /* Send the full block to the server, along with the
     * current hash state if needed. Finalization/padding of last block is up to
     * the server, we just need to let it know we are done and sending an
     * incomplete last block */
    if (isLastBlock) {
        req->isLastBlock  = 1;
        req->lastBlockLen = sha256->buffLen;
    }
    else {
        req->isLastBlock = 0;
    }
    memcpy(req->inBlock, sha256->buffer,
            (isLastBlock) ? sha256->buffLen : WC_SHA256_BLOCK_SIZE);

    /* Send the hash state - this will be 0 on the first block on a properly
     * initialized sha256 struct */
    memcpy(req->resumeState.hash, sha256->digest, WC_SHA256_DIGEST_SIZE);
    req->resumeState.hiLen = sha256->hiLen;
    req->resumeState.loLen = sha256->loLen;

    uint32_t req_len =
        sizeof(whMessageCrypto_GenericRequestHeader) + sizeof(*req);

    ret = wh_Client_SendRequest(ctx, group, WC_ALGO_TYPE_HASH, req_len,
                                (uint8_t*)dataPtr);

    WH_DEBUG_CLIENT_VERBOSE("send SHA256 Req:\n");
    WH_DEBUG_VERBOSE_HEXDUMP("[client] inBlock: ", req->inBlock, WC_SHA256_BLOCK_SIZE);
    if (req->resumeState.hiLen != 0 || req->resumeState.loLen != 0) {
        WH_DEBUG_VERBOSE_HEXDUMP("  [client] resumeHash: ", req->resumeState.hash,
                         (isLastBlock) ? req->lastBlockLen
                                       : WC_SHA256_BLOCK_SIZE);
        WH_DEBUG_CLIENT_VERBOSE("  hiLen: %u, loLen: %u\n",
               (unsigned int)req->resumeState.hiLen,
               (unsigned int)req->resumeState.loLen);
    }
    WH_DEBUG_CLIENT_VERBOSE("  ret = %d\n", ret);

    if (ret == 0) {
        do {
            ret = wh_Client_RecvResponse(ctx, &group, &action, &dataSz,
                                         (uint8_t*)dataPtr);
        } while (ret == WH_ERROR_NOTREADY);
    }
    if (ret == 0) {
        /* Get response */
        ret = _getCryptoResponse(dataPtr, WC_HASH_TYPE_SHA256, (uint8_t**)&res);
        /* wolfCrypt allows positive error codes on success in some scenarios */
        if (ret >= 0) {
            WH_DEBUG_CLIENT_VERBOSE("Client SHA256 Res recv: ret=%d", ret);
            /* Store the received intermediate hash in the sha256
             * context and indicate the field is now valid and
             * should be passed back and forth to the server */
            memcpy(sha256->digest, res->hash, WC_SHA256_DIGEST_SIZE);
            sha256->hiLen = res->hiLen;
            sha256->loLen = res->loLen;
            WH_DEBUG_CLIENT_VERBOSE("Client SHA256 Res recv:\n");
            WH_DEBUG_VERBOSE_HEXDUMP("[client] hash: ", (uint8_t*)sha256->digest,
                             WC_SHA256_DIGEST_SIZE);
        }
    }

    return ret;
}

int wh_Client_Sha256(whClientContext* ctx, wc_Sha256* sha256, const uint8_t* in,
                     uint32_t inLen, uint8_t* out)
{
    int      ret               = 0;
    uint8_t* sha256BufferBytes = (uint8_t*)sha256->buffer;

    /* Caller invoked SHA Update:
     * wc_CryptoCb_Sha256Hash(sha256, data, len, NULL) */
    if (in != NULL) {
        size_t i = 0;

        /* Process the partial blocks directly from the input data. If there
         * is enough input data to fill a full block, transfer it to the
         * server */
        if (sha256->buffLen > 0) {
            while (i < inLen && sha256->buffLen < WC_SHA256_BLOCK_SIZE) {
                sha256BufferBytes[sha256->buffLen++] = in[i++];
            }
            if (sha256->buffLen == WC_SHA256_BLOCK_SIZE) {
                ret = _xferSha256BlockAndUpdateDigest(ctx, sha256, 0);
                sha256->buffLen = 0;
            }
        }

        /* Process as many full blocks from the input data as we can */
        while (ret == 0 && (inLen - i) >= WC_SHA256_BLOCK_SIZE) {
            memcpy(sha256BufferBytes, in + i, WC_SHA256_BLOCK_SIZE);
            ret = _xferSha256BlockAndUpdateDigest(ctx, sha256, 0);
            i += WC_SHA256_BLOCK_SIZE;
        }

        /* Copy any remaining data into the buffer to be sent in a
         * subsequent call when we have enough input data to send a full
         * block */
        while (i < inLen) {
            sha256BufferBytes[sha256->buffLen++] = in[i++];
        }
    }

    /* Caller invoked SHA finalize:
     * wc_CryptoCb_Sha256Hash(sha256, NULL, 0, * hash) */
    if (ret == 0 && out != NULL) {
        ret = _xferSha256BlockAndUpdateDigest(ctx, sha256, 1);

        /* Copy out the final hash value */
        if (ret == 0) {
            memcpy(out, sha256->digest, WC_SHA256_DIGEST_SIZE);
        }

        /* reset the state of the sha context (without blowing away devId) */
        wc_InitSha256_ex(sha256, NULL, sha256->devId);
    }

    return ret;
}

#ifdef WOLFHSM_CFG_DMA
int wh_Client_Sha256Dma(whClientContext* ctx, wc_Sha256* sha, const uint8_t* in,
                        uint32_t inLen, uint8_t* out)
{
    int                                ret     = WH_ERROR_OK;
    wc_Sha256*                         sha256  = sha;
    uint16_t                           respSz  = 0;
    uint16_t                           group   = WH_MESSAGE_GROUP_CRYPTO_DMA;
    uint8_t*                           dataPtr = NULL;
    whMessageCrypto_Sha2DmaRequest*    req     = NULL;
    whMessageCrypto_Sha2DmaResponse*   resp    = NULL;
    uintptr_t inAddr = 0; /* The req->input.addr is reused elsewhere, this
                             local variable is to keep track of the resulting
                             DMA translation to pass back to the callback on
                             POST operations. */
    uintptr_t outAddr   = 0;
    uintptr_t stateAddr = 0;

    /* Get data pointer from the context to use as request/response storage */
    dataPtr = (uint8_t*)wh_CommClient_GetDataPtr(ctx->comm);
    if (dataPtr == NULL) {
        return WH_ERROR_BADARGS;
    }

    /* Setup generic header and get pointer to request data */
    req = (whMessageCrypto_Sha2DmaRequest*)_createCryptoRequest(
        dataPtr, WC_HASH_TYPE_SHA256, ctx->cryptoAffinity);

    /* map addresses and setup default request structure */
    if (in != NULL || out != NULL) {
        req->finalize    = 0;
        req->state.sz    = sizeof(*sha256);
        req->input.sz    = inLen;
        req->output.sz   = WC_SHA256_DIGEST_SIZE; /* not needed, but YOLO */

        /* Perform address translations */
        ret = wh_Client_DmaProcessClientAddress(
            ctx, (uintptr_t)sha256, (void**)&stateAddr, req->state.sz,
            WH_DMA_OPER_CLIENT_WRITE_PRE, (whDmaFlags){0});
        if (ret == WH_ERROR_OK) {
            req->state.addr = stateAddr;
        }

        if (ret == WH_ERROR_OK) {
            ret = wh_Client_DmaProcessClientAddress(
                ctx, (uintptr_t)in, (void**)&inAddr, req->input.sz,
                WH_DMA_OPER_CLIENT_READ_PRE, (whDmaFlags){0});
            if (ret == WH_ERROR_OK) {
                req->input.addr = inAddr;
            }
        }

        if (ret == WH_ERROR_OK) {
            ret = wh_Client_DmaProcessClientAddress(
                ctx, (uintptr_t)out, (void**)&outAddr, req->output.sz,
                WH_DMA_OPER_CLIENT_WRITE_PRE, (whDmaFlags){0});
            if (ret == WH_ERROR_OK) {
                req->output.addr = outAddr;
            }
        }
    }

    /* Caller invoked SHA Update:
     * wc_CryptoCb_Sha256Hash(sha256, data, len, NULL) */
    if ((ret == WH_ERROR_OK) && (in != NULL)) {
        WH_DEBUG_CLIENT_VERBOSE("SHA256 DMA UPDATE: inAddr=%p, inSz=%u\n", in,
               (unsigned int)inLen);

        ret = wh_Client_SendRequest(
            ctx, group, WC_ALGO_TYPE_HASH,
            sizeof(whMessageCrypto_GenericRequestHeader) + sizeof(*req),
            (uint8_t*)dataPtr);

        if (ret == WH_ERROR_OK) {
            do {
                ret = wh_Client_RecvResponse(ctx, NULL, NULL, &respSz,
                                             (uint8_t*)dataPtr);
            } while (ret == WH_ERROR_NOTREADY);
        }

        if (ret == WH_ERROR_OK) {
            /* Get response structure pointer, validates generic header
             * rc */
            ret = _getCryptoResponse(dataPtr, WC_HASH_TYPE_SHA256,
                                     (uint8_t**)&resp);
            /* Nothing to do on success, as server will have updated the context
             * in client memory */
        }
    }

    /* Caller invoked SHA finalize:
     * wc_CryptoCb_Sha256Hash(sha256, NULL, 0, * hash) */
    if ((ret == WH_ERROR_OK) && (out != NULL)) {
        /* Packet will have been trashed, so re-populate all fields */
        req->finalize = 1;
        WH_DEBUG_CLIENT_VERBOSE("SHA256 DMA FINAL: outAddr=%p\n", out);
        /* send the request to the server */
        ret = wh_Client_SendRequest(
            ctx, group, WC_ALGO_TYPE_HASH,
            sizeof(whMessageCrypto_GenericRequestHeader) + sizeof(*req),
            (uint8_t*)dataPtr);

        if (ret == WH_ERROR_OK) {
            do {
                ret = wh_Client_RecvResponse(ctx, NULL, NULL, &respSz,
                                             (uint8_t*)dataPtr);
            } while (ret == WH_ERROR_NOTREADY);
        }

        /* Copy out the final hash value */
        if (ret == WH_ERROR_OK) {
            /* Get response structure pointer, validates generic header
             * rc */
            ret = _getCryptoResponse(dataPtr, WC_HASH_TYPE_SHA256,
                                     (uint8_t**)&resp);
            /* Nothing to do on success, as server will have updated the output
             * hash in client memory */
        }
    }

    /* This is called regardless of successful operation to give the callback a
     * chance for cleanup. i.e if XMALLOC had been used and XFREE call is
     * needed. Don't override return value with closing process address calls.*/
    if (in != NULL || out != NULL) {
        /* post operation address translations */
        (void)wh_Client_DmaProcessClientAddress(
            ctx, (uintptr_t)sha256, (void**)&stateAddr, sizeof(*sha256),
            WH_DMA_OPER_CLIENT_WRITE_POST, (whDmaFlags){0});
        (void)wh_Client_DmaProcessClientAddress(
            ctx, (uintptr_t)in, (void**)&inAddr, inLen,
            WH_DMA_OPER_CLIENT_READ_POST, (whDmaFlags){0});
        (void)wh_Client_DmaProcessClientAddress(
            ctx, (uintptr_t)out, (void**)&outAddr, WC_SHA256_DIGEST_SIZE,
            WH_DMA_OPER_CLIENT_WRITE_POST, (whDmaFlags){0});
    }

    return ret;
}
#endif /* WOLFHSM_CFG_DMA */
#endif /* !NO_SHA256 */

#ifdef WOLFSSL_SHA224

static int _xferSha224BlockAndUpdateDigest(whClientContext* ctx,
                                           wc_Sha224*       sha224,
                                           uint32_t         isLastBlock)
{
    uint16_t                       group   = WH_MESSAGE_GROUP_CRYPTO;
    uint16_t                       action  = WH_MESSAGE_ACTION_NONE;
    int                            ret     = 0;
    uint16_t                       dataSz  = 0;
    whMessageCrypto_Sha256Request* req     = NULL;
    whMessageCrypto_Sha2Response*  res     = NULL;
    uint8_t*                       dataPtr = NULL;

    /* Get data buffer */
    dataPtr = wh_CommClient_GetDataPtr(ctx->comm);
    if (dataPtr == NULL) {
        return WH_ERROR_BADARGS;
    }

    /* Setup generic header and get pointer to request data */
    req = (whMessageCrypto_Sha256Request*)_createCryptoRequest(
        dataPtr, WC_HASH_TYPE_SHA224, ctx->cryptoAffinity);


    /* Send the full block to the server, along with the
     * current hash state if needed. Finalization/padding of last block is up to
     * the server, we just need to let it know we are done and sending an
     * incomplete last block */
    if (isLastBlock) {
        req->isLastBlock  = 1;
        req->lastBlockLen = sha224->buffLen;
    }
    else {
        req->isLastBlock = 0;
    }
    memcpy(req->inBlock, sha224->buffer,
           (isLastBlock) ? sha224->buffLen : WC_SHA224_BLOCK_SIZE);

    /* Send the hash state - this will be 0 on the first block on a properly
     * initialized sha224 struct */
    memcpy(req->resumeState.hash, sha224->digest, WC_SHA256_DIGEST_SIZE);
    req->resumeState.hiLen = sha224->hiLen;
    req->resumeState.loLen = sha224->loLen;

    uint32_t req_len =
        sizeof(whMessageCrypto_GenericRequestHeader) + sizeof(*req);

    ret = wh_Client_SendRequest(ctx, group, WC_ALGO_TYPE_HASH, req_len,
                                (uint8_t*)dataPtr);

    WH_DEBUG_CLIENT_VERBOSE("send SHA224 Req:\n");
    WH_DEBUG_VERBOSE_HEXDUMP("[client] inBlock: ", req->inBlock, WC_SHA224_BLOCK_SIZE);
    if (req->resumeState.hiLen != 0 || req->resumeState.loLen != 0) {
        WH_DEBUG_VERBOSE_HEXDUMP("  [client] resumeHash: ", req->resumeState.hash,
                         (isLastBlock) ? req->lastBlockLen
                                       : WC_SHA224_BLOCK_SIZE);
        WH_DEBUG_CLIENT_VERBOSE("  hiLen: %u, loLen: %u\n", req->resumeState.hiLen,
               req->resumeState.loLen);
    }
    WH_DEBUG_CLIENT_VERBOSE("  ret = %d\n", ret);

    if (ret == 0) {
        do {
            ret = wh_Client_RecvResponse(ctx, &group, &action, &dataSz,
                                         (uint8_t*)dataPtr);
        } while (ret == WH_ERROR_NOTREADY);
    }
    if (ret == 0) {
        /* Get response */
        ret = _getCryptoResponse(dataPtr, WC_HASH_TYPE_SHA224, (uint8_t**)&res);
        /* wolfCrypt allows positive error codes on success in some scenarios */
        if (ret >= 0) {
            WH_DEBUG_CLIENT_VERBOSE("Client SHA224 Res recv: ret=%d", ret);
            /* Store the received intermediate hash in the sha224
             * context and indicate the field is now valid and
             * should be passed back and forth to the server.
             * The digest length is the same as sha256
             * for intermediate operation. Final output will be
             * truncated to WC_SHA224_DIGEST_SIZE.
             */
            memcpy(sha224->digest, res->hash, WC_SHA256_DIGEST_SIZE);
            sha224->hiLen = res->hiLen;
            sha224->loLen = res->loLen;
            WH_DEBUG_CLIENT_VERBOSE("Client SHA224 Res recv:\n");
            WH_DEBUG_VERBOSE_HEXDUMP("[client] hash: ", (uint8_t*)sha224->digest,
                             WC_SHA224_DIGEST_SIZE);
        }
    }

    return ret;
}

int wh_Client_Sha224(whClientContext* ctx, wc_Sha224* sha224, const uint8_t* in,
                     uint32_t inLen, uint8_t* out)
{
    int      ret               = 0;
    uint8_t* sha224BufferBytes = (uint8_t*)sha224->buffer;

    /* Caller invoked SHA Update:
     * wc_CryptoCb_Sha224Hash(sha224, data, len, NULL) */
    if (in != NULL) {
        size_t i = 0;

        /* Process the partial blocks directly from the input data. If there
         * is enough input data to fill a full block, transfer it to the
         * server */
        if (sha224->buffLen > 0) {
            while (i < inLen && sha224->buffLen < WC_SHA224_BLOCK_SIZE) {
                sha224BufferBytes[sha224->buffLen++] = in[i++];
            }
            if (sha224->buffLen == WC_SHA224_BLOCK_SIZE) {
                ret = _xferSha224BlockAndUpdateDigest(ctx, sha224, 0);
                sha224->buffLen = 0;
            }
        }

        /* Process as many full blocks from the input data as we can */
        while (ret == 0 && (inLen - i) >= WC_SHA224_BLOCK_SIZE) {
            memcpy(sha224BufferBytes, in + i, WC_SHA224_BLOCK_SIZE);
            ret = _xferSha224BlockAndUpdateDigest(ctx, sha224, 0);
            i += WC_SHA224_BLOCK_SIZE;
        }

        /* Copy any remaining data into the buffer to be sent in a
         * subsequent call when we have enough input data to send a full
         * block */
        while (i < inLen) {
            sha224BufferBytes[sha224->buffLen++] = in[i++];
        }
    }

    /* Caller invoked SHA finalize:
     * wc_CryptoCb_Sha224Hash(sha224, NULL, 0, * hash) */
    if (ret == 0 && out != NULL) {
        ret = _xferSha224BlockAndUpdateDigest(ctx, sha224, 1);

        /* Copy out the final hash value */
        if (ret == 0) {
            memcpy(out, sha224->digest, WC_SHA224_DIGEST_SIZE);
        }

        /* reset the state of the sha context (without blowing away devId) */
        wc_InitSha224_ex(sha224, NULL, sha224->devId);
    }

    return ret;
}

#ifdef WOLFHSM_CFG_DMA
int wh_Client_Sha224Dma(whClientContext* ctx, wc_Sha224* sha, const uint8_t* in,
                        uint32_t inLen, uint8_t* out)
{
    int                              ret     = WH_ERROR_OK;
    wc_Sha224*                       sha224  = sha;
    uint16_t                         respSz  = 0;
    uint16_t                         group   = WH_MESSAGE_GROUP_CRYPTO_DMA;
    uint8_t*                         dataPtr = NULL;
    whMessageCrypto_Sha2DmaRequest*  req     = NULL;
    whMessageCrypto_Sha2DmaResponse* resp    = NULL;
    uintptr_t                        inAddr    = 0;
    uintptr_t                        outAddr   = 0;
    uintptr_t                        stateAddr = 0;

    /* Get data pointer from the context to use as request/response storage */
    dataPtr = (uint8_t*)wh_CommClient_GetDataPtr(ctx->comm);
    if (dataPtr == NULL) {
        return WH_ERROR_BADARGS;
    }

    /* Setup generic header and get pointer to request data */
    req = (whMessageCrypto_Sha2DmaRequest*)_createCryptoRequest(
        dataPtr, WC_HASH_TYPE_SHA224, ctx->cryptoAffinity);

    if (in != NULL || out != NULL) {
        req->state.sz  = sizeof(*sha224);
        req->input.sz  = inLen;
        req->output.sz = WC_SHA224_DIGEST_SIZE; /* not needed, but YOLO */

        /* Perform address translations */
        ret = wh_Client_DmaProcessClientAddress(
            ctx, (uintptr_t)sha224, (void**)&stateAddr, req->state.sz,
            WH_DMA_OPER_CLIENT_WRITE_PRE, (whDmaFlags){0});
        if (ret == WH_ERROR_OK) {
            req->state.addr = stateAddr;
        }

        if (ret == WH_ERROR_OK) {
            ret = wh_Client_DmaProcessClientAddress(
                ctx, (uintptr_t)in, (void**)&inAddr, req->input.sz,
                WH_DMA_OPER_CLIENT_READ_PRE, (whDmaFlags){0});
            if (ret == WH_ERROR_OK) {
                req->input.addr = inAddr;
            }
        }

        if (ret == WH_ERROR_OK) {
            ret = wh_Client_DmaProcessClientAddress(
                ctx, (uintptr_t)out, (void**)&outAddr, req->output.sz,
                WH_DMA_OPER_CLIENT_WRITE_PRE, (whDmaFlags){0});
            if (ret == WH_ERROR_OK) {
                req->output.addr = outAddr;
            }
        }
    }

    /* Caller invoked SHA Update:
     * wc_CryptoCb_Sha224Hash(sha224, data, len, NULL) */
    if (in != NULL && ret == WH_ERROR_OK) {
        req->finalize    = 0;
        WH_DEBUG_CLIENT_VERBOSE("SHA224 DMA UPDATE: inAddr=%p, inSz=%u\n", in,
               (unsigned int)inLen);
        ret = wh_Client_SendRequest(
            ctx, group, WC_ALGO_TYPE_HASH,
            sizeof(whMessageCrypto_GenericRequestHeader) + sizeof(*req),
            (uint8_t*)dataPtr);

        if (ret == WH_ERROR_OK) {
            do {
                ret = wh_Client_RecvResponse(ctx, NULL, NULL, &respSz,
                                             (uint8_t*)dataPtr);
            } while (ret == WH_ERROR_NOTREADY);
        }

        if (ret == WH_ERROR_OK) {
            /* Get response structure pointer, validates generic header
             * rc */
            ret = _getCryptoResponse(dataPtr, WC_HASH_TYPE_SHA224,
                                     (uint8_t**)&resp);
            /* Nothing to do on success, as server will have updated the context
             * in client memory */
        }
    }

    /* Caller invoked SHA finalize:
     * wc_CryptoCb_Sha224Hash(sha224, NULL, 0, * hash) */
    if ((ret == WH_ERROR_OK) && (out != NULL)) {
        /* Packet will have been trashed, so re-populate all fields */
        req->finalize = 1;

        WH_DEBUG_CLIENT_VERBOSE("SHA224 DMA FINAL: outAddr=%p\n", out);
        /* send the request to the server */
        ret = wh_Client_SendRequest(
            ctx, group, WC_ALGO_TYPE_HASH,
            sizeof(whMessageCrypto_GenericRequestHeader) + sizeof(*req),
            (uint8_t*)dataPtr);

        if (ret == WH_ERROR_OK) {
            do {
                ret = wh_Client_RecvResponse(ctx, NULL, NULL, &respSz,
                                             (uint8_t*)dataPtr);
            } while (ret == WH_ERROR_NOTREADY);
        }

        /* Copy out the final hash value */
        if (ret == WH_ERROR_OK) {
            /* Get response structure pointer, validates generic header
             * rc */
            ret = _getCryptoResponse(dataPtr, WC_HASH_TYPE_SHA224,
                                     (uint8_t**)&resp);
            /* Nothing to do on success, as server will have updated the output
             * hash in client memory */
        }
    }

    if (in != NULL || out != NULL) {
        (void)wh_Client_DmaProcessClientAddress(
            ctx, (uintptr_t)sha224, (void**)&stateAddr, sizeof(*sha224),
            WH_DMA_OPER_CLIENT_WRITE_POST, (whDmaFlags){0});
        (void)wh_Client_DmaProcessClientAddress(
            ctx, (uintptr_t)in, (void**)&inAddr, inLen,
            WH_DMA_OPER_CLIENT_READ_POST, (whDmaFlags){0});
        (void)wh_Client_DmaProcessClientAddress(
            ctx, (uintptr_t)out, (void**)&outAddr, WC_SHA224_DIGEST_SIZE,
            WH_DMA_OPER_CLIENT_WRITE_POST, (whDmaFlags){0});
    }
    return ret;
}
#endif /* WOLFHSM_CFG_DMA */
#endif /* WOLFSSL_SHA224 */

#ifdef WOLFSSL_SHA384

static int _xferSha384BlockAndUpdateDigest(whClientContext* ctx,
                                           wc_Sha384*       sha384,
                                           uint32_t         isLastBlock)
{
    uint16_t                       group   = WH_MESSAGE_GROUP_CRYPTO;
    uint16_t                       action  = WH_MESSAGE_ACTION_NONE;
    int                            ret     = 0;
    uint16_t                       dataSz  = 0;
    whMessageCrypto_Sha512Request* req     = NULL;
    whMessageCrypto_Sha2Response*  res     = NULL;
    uint8_t*                       dataPtr = NULL;

    /* Get data buffer */
    dataPtr = wh_CommClient_GetDataPtr(ctx->comm);
    if (dataPtr == NULL) {
        return WH_ERROR_BADARGS;
    }

    /* Setup generic header and get pointer to request data */
    req = (whMessageCrypto_Sha512Request*)_createCryptoRequest(
        dataPtr, WC_HASH_TYPE_SHA384, ctx->cryptoAffinity);


    /* Send the full block to the server, along with the
     * current hash state if needed. Finalization/padding of last block is up to
     * the server, we just need to let it know we are done and sending an
     * incomplete last block */
    if (isLastBlock) {
        req->isLastBlock  = 1;
        req->lastBlockLen = sha384->buffLen;
    }
    else {
        req->isLastBlock = 0;
    }
    memcpy(req->inBlock, sha384->buffer,
           (isLastBlock) ? sha384->buffLen : WC_SHA384_BLOCK_SIZE);

    /* Send the hash state - this will be 0 on the first block on a properly
     * initialized sha384 struct */
    memcpy(req->resumeState.hash, sha384->digest, WC_SHA512_DIGEST_SIZE);
    req->resumeState.hiLen = sha384->hiLen;
    req->resumeState.loLen = sha384->loLen;

    uint32_t req_len =
        sizeof(whMessageCrypto_GenericRequestHeader) + sizeof(*req);

    ret = wh_Client_SendRequest(ctx, group, WC_ALGO_TYPE_HASH, req_len,
                                (uint8_t*)dataPtr);

    WH_DEBUG_CLIENT_VERBOSE("send SHA384 Req:\n");
    WH_DEBUG_VERBOSE_HEXDUMP("[client] inBlock: ", req->inBlock, WC_SHA384_BLOCK_SIZE);
    if (req->resumeState.hiLen != 0 || req->resumeState.loLen != 0) {
        WH_DEBUG_VERBOSE_HEXDUMP("  [client] resumeHash: ", req->resumeState.hash,
                         (isLastBlock) ? req->lastBlockLen
                                       : WC_SHA384_BLOCK_SIZE);
        WH_DEBUG_CLIENT_VERBOSE("  hiLen: %u, loLen: %u\n", req->resumeState.hiLen,
               req->resumeState.loLen);
    }
    WH_DEBUG_CLIENT_VERBOSE("  ret = %d\n", ret);

    if (ret == 0) {
        do {
            ret = wh_Client_RecvResponse(ctx, &group, &action, &dataSz,
                                         (uint8_t*)dataPtr);
        } while (ret == WH_ERROR_NOTREADY);
    }
    if (ret == 0) {
        /* Get response */
        ret = _getCryptoResponse(dataPtr, WC_HASH_TYPE_SHA384, (uint8_t**)&res);
        /* wolfCrypt allows positive error codes on success in some scenarios */
        if (ret >= 0) {
            WH_DEBUG_CLIENT_VERBOSE("Client SHA384 Res recv: ret=%d", ret);
            /* Store the received intermediate hash in the sha384
             * context and indicate the field is now valid and
             * should be passed back and forth to the server
             * The digest length is the same as sha512
             * for intermediate operation. Final output will be
             * truncated to WC_SHA384_DIGEST_SIZE.
             */
            memcpy(sha384->digest, res->hash, WC_SHA512_DIGEST_SIZE);
            sha384->hiLen = res->hiLen;
            sha384->loLen = res->loLen;
            WH_DEBUG_CLIENT_VERBOSE("Client SHA384 Res recv:\n");
            WH_DEBUG_VERBOSE_HEXDUMP("[client] hash: ", (uint8_t*)sha384->digest,
                             WC_SHA384_DIGEST_SIZE);
        }
    }

    return ret;
}

int wh_Client_Sha384(whClientContext* ctx, wc_Sha384* sha384, const uint8_t* in,
                     uint32_t inLen, uint8_t* out)
{
    int      ret               = 0;
    uint8_t* sha384BufferBytes = (uint8_t*)sha384->buffer;

    /* Caller invoked SHA Update:
     * wc_CryptoCb_Sha384Hash(sha384, data, len, NULL) */
    if (in != NULL) {
        size_t i = 0;

        /* Process the partial blocks directly from the input data. If there
         * is enough input data to fill a full block, transfer it to the
         * server */
        if (sha384->buffLen > 0) {
            while (i < inLen && sha384->buffLen < WC_SHA384_BLOCK_SIZE) {
                sha384BufferBytes[sha384->buffLen++] = in[i++];
            }
            if (sha384->buffLen == WC_SHA384_BLOCK_SIZE) {
                ret = _xferSha384BlockAndUpdateDigest(ctx, sha384, 0);
                sha384->buffLen = 0;
            }
        }

        /* Process as many full blocks from the input data as we can */
        while (ret == 0 && (inLen - i) >= WC_SHA384_BLOCK_SIZE) {
            memcpy(sha384BufferBytes, in + i, WC_SHA384_BLOCK_SIZE);
            ret = _xferSha384BlockAndUpdateDigest(ctx, sha384, 0);
            i += WC_SHA384_BLOCK_SIZE;
        }

        /* Copy any remaining data into the buffer to be sent in a
         * subsequent call when we have enough input data to send a full
         * block */
        while (i < inLen) {
            sha384BufferBytes[sha384->buffLen++] = in[i++];
        }
    }

    /* Caller invoked SHA finalize:
     * wc_CryptoCb_Sha384Hash(sha384, NULL, 0, * hash) */
    if (ret == 0 && out != NULL) {
        ret = _xferSha384BlockAndUpdateDigest(ctx, sha384, 1);

        /* Copy out the final hash value */
        if (ret == 0) {
            memcpy(out, sha384->digest, WC_SHA384_DIGEST_SIZE);
        }

        /* reset the state of the sha context (without blowing away devId) */
        wc_InitSha384_ex(sha384, NULL, sha384->devId);
    }

    return ret;
}

#ifdef WOLFHSM_CFG_DMA
int wh_Client_Sha384Dma(whClientContext* ctx, wc_Sha384* sha, const uint8_t* in,
                        uint32_t inLen, uint8_t* out)
{
    int                              ret     = WH_ERROR_OK;
    wc_Sha384*                       sha384  = sha;
    uint16_t                         respSz  = 0;
    uint16_t                         group   = WH_MESSAGE_GROUP_CRYPTO_DMA;
    uint8_t*                         dataPtr = NULL;
    whMessageCrypto_Sha2DmaRequest*  req     = NULL;
    whMessageCrypto_Sha2DmaResponse* resp    = NULL;
    uintptr_t                        inAddr    = 0;
    uintptr_t                        outAddr   = 0;
    uintptr_t                        stateAddr = 0;

    /* Get data pointer from the context to use as request/response storage */
    dataPtr = (uint8_t*)wh_CommClient_GetDataPtr(ctx->comm);
    if (dataPtr == NULL) {
        return WH_ERROR_BADARGS;
    }

    /* Setup generic header and get pointer to request data */
    req = (whMessageCrypto_Sha2DmaRequest*)_createCryptoRequest(
        dataPtr, WC_HASH_TYPE_SHA384, ctx->cryptoAffinity);

    if (in != NULL || out != NULL) {
        req->state.sz  = sizeof(*sha384);
        req->input.sz  = inLen;
        req->output.sz = WC_SHA384_DIGEST_SIZE; /* not needed, but YOLO */

        /* Perform address translations */
        ret = wh_Client_DmaProcessClientAddress(
            ctx, (uintptr_t)sha384, (void**)&stateAddr, req->state.sz,
            WH_DMA_OPER_CLIENT_WRITE_PRE, (whDmaFlags){0});
        if (ret == WH_ERROR_OK) {
            req->state.addr = stateAddr;
        }

        if (ret == WH_ERROR_OK) {
            ret = wh_Client_DmaProcessClientAddress(
                ctx, (uintptr_t)in, (void**)&inAddr, req->input.sz,
                WH_DMA_OPER_CLIENT_READ_PRE, (whDmaFlags){0});
            if (ret == WH_ERROR_OK) {
                req->input.addr = inAddr;
            }
        }

        if (ret == WH_ERROR_OK) {
            ret = wh_Client_DmaProcessClientAddress(
                ctx, (uintptr_t)out, (void**)&outAddr, req->output.sz,
                WH_DMA_OPER_CLIENT_WRITE_PRE, (whDmaFlags){0});
            if (ret == WH_ERROR_OK) {
                req->output.addr = outAddr;
            }
        }
    }

    /* Caller invoked SHA Update:
     * wc_CryptoCb_Sha384Hash(sha384, data, len, NULL) */
    if (in != NULL && ret == WH_ERROR_OK) {
        req->finalize    = 0;
        WH_DEBUG_CLIENT_VERBOSE("SHA384 DMA UPDATE: inAddr=%p, inSz=%u\n", in,
               (unsigned int)inLen);
        ret = wh_Client_SendRequest(
            ctx, group, WC_ALGO_TYPE_HASH,
            sizeof(whMessageCrypto_GenericRequestHeader) + sizeof(*req),
            (uint8_t*)dataPtr);

        if (ret == WH_ERROR_OK) {
            do {
                ret = wh_Client_RecvResponse(ctx, NULL, NULL, &respSz,
                                             (uint8_t*)dataPtr);
            } while (ret == WH_ERROR_NOTREADY);
        }

        if (ret == WH_ERROR_OK) {
            /* Get response structure pointer, validates generic header
             * rc */
            ret = _getCryptoResponse(dataPtr, WC_HASH_TYPE_SHA384,
                                     (uint8_t**)&resp);
            /* Nothing to do on success, as server will have updated the context
             * in client memory */
        }
    }

    /* Caller invoked SHA finalize:
     * wc_CryptoCb_Sha384Hash(sha384, NULL, 0, * hash) */
    if ((ret == WH_ERROR_OK) && (out != NULL)) {
        /* Packet will have been trashed, so re-populate all fields */
        req->finalize = 1;

        WH_DEBUG_CLIENT_VERBOSE("SHA384 DMA FINAL: outAddr=%p\n", out);
        /* send the request to the server */
        ret = wh_Client_SendRequest(
            ctx, group, WC_ALGO_TYPE_HASH,
            sizeof(whMessageCrypto_GenericRequestHeader) + sizeof(*req),
            (uint8_t*)dataPtr);

        if (ret == WH_ERROR_OK) {
            do {
                ret = wh_Client_RecvResponse(ctx, NULL, NULL, &respSz,
                                             (uint8_t*)dataPtr);
            } while (ret == WH_ERROR_NOTREADY);
        }

        /* Copy out the final hash value */
        if (ret == WH_ERROR_OK) {
            /* Get response structure pointer, validates generic header
             * rc */
            ret = _getCryptoResponse(dataPtr, WC_HASH_TYPE_SHA384,
                                     (uint8_t**)&resp);
            /* Nothing to do on success, as server will have updated the output
             * hash in client memory */
        }
    }

    if (in != NULL || out != NULL) {
        (void)wh_Client_DmaProcessClientAddress(
            ctx, (uintptr_t)sha384, (void**)&stateAddr, sizeof(*sha384),
            WH_DMA_OPER_CLIENT_WRITE_POST, (whDmaFlags){0});
        (void)wh_Client_DmaProcessClientAddress(
            ctx, (uintptr_t)in, (void**)&inAddr, inLen,
            WH_DMA_OPER_CLIENT_READ_POST, (whDmaFlags){0});
        (void)wh_Client_DmaProcessClientAddress(
            ctx, (uintptr_t)out, (void**)&outAddr, WC_SHA384_DIGEST_SIZE,
            WH_DMA_OPER_CLIENT_WRITE_POST, (whDmaFlags){0});
    }
    return ret;
}
#endif /* WOLFHSM_CFG_DMA */
#endif /* WOLFSSL_SHA384 */


#if defined(WOLFSSL_SHA512) && defined(WOLFSSL_SHA512_HASHTYPE)

static int _xferSha512BlockAndUpdateDigest(whClientContext* ctx,
                                           wc_Sha512*       sha512,
                                           uint32_t         isLastBlock)
{
    uint16_t                       group   = WH_MESSAGE_GROUP_CRYPTO;
    uint16_t                       action  = WH_MESSAGE_ACTION_NONE;
    int                            ret     = 0;
    uint16_t                       dataSz  = 0;
    whMessageCrypto_Sha512Request* req     = NULL;
    whMessageCrypto_Sha2Response*  res     = NULL;
    uint8_t*                       dataPtr = NULL;

    /* Get data buffer */
    dataPtr = wh_CommClient_GetDataPtr(ctx->comm);
    if (dataPtr == NULL) {
        return WH_ERROR_BADARGS;
    }

    /* Setup generic header and get pointer to request data */
    req = (whMessageCrypto_Sha512Request*)_createCryptoRequest(
        dataPtr, WC_HASH_TYPE_SHA512, ctx->cryptoAffinity);


    /* Send the full block to the server, along with the
     * current hash state if needed. Finalization/padding of last block is up to
     * the server, we just need to let it know we are done and sending an
     * incomplete last block */
    if (isLastBlock) {
        req->isLastBlock  = 1;
        req->lastBlockLen = sha512->buffLen;
    }
    else {
        req->isLastBlock = 0;
    }
    memcpy(req->inBlock, sha512->buffer,
           (isLastBlock) ? sha512->buffLen : WC_SHA512_BLOCK_SIZE);

    /* Send the hash state - this will be 0 on the first block on a properly
     * initialized sha512 struct */
    memcpy(req->resumeState.hash, sha512->digest, WC_SHA512_DIGEST_SIZE);
    req->resumeState.hiLen    = sha512->hiLen;
    req->resumeState.loLen    = sha512->loLen;
    req->resumeState.hashType = sha512->hashType;
    uint32_t req_len =
        sizeof(whMessageCrypto_GenericRequestHeader) + sizeof(*req);

    ret = wh_Client_SendRequest(ctx, group, WC_ALGO_TYPE_HASH, req_len,
                                (uint8_t*)dataPtr);

    WH_DEBUG_CLIENT_VERBOSE("send SHA512 Req:\n");
    WH_DEBUG_VERBOSE_HEXDUMP("[client] inBlock: ", req->inBlock, WC_SHA512_BLOCK_SIZE);
    if (req->resumeState.hiLen != 0 || req->resumeState.loLen != 0) {
        WH_DEBUG_VERBOSE_HEXDUMP("  [client] resumeHash: ", req->resumeState.hash,
                         (isLastBlock) ? req->lastBlockLen
                                       : WC_SHA512_BLOCK_SIZE);
        WH_DEBUG_CLIENT_VERBOSE("  hiLen: %u, loLen: %u\n", req->resumeState.hiLen,
               req->resumeState.loLen);
    }
    WH_DEBUG_CLIENT_VERBOSE("  ret = %d\n", ret);

    if (ret == 0) {
        do {
            ret = wh_Client_RecvResponse(ctx, &group, &action, &dataSz,
                                         (uint8_t*)dataPtr);
        } while (ret == WH_ERROR_NOTREADY);
    }
    if (ret == 0) {
        /* Get response */
        ret = _getCryptoResponse(dataPtr, WC_HASH_TYPE_SHA512, (uint8_t**)&res);
        /* wolfCrypt allows positive error codes on success in some scenarios */
        if (ret >= 0) {
            WH_DEBUG_CLIENT_VERBOSE("Client SHA512 Res recv: ret=%d", ret);
            WH_DEBUG_CLIENT_VERBOSE("hashType: %d\n", sha512->hashType);
            /* Store the received intermediate hash in the sha512
             * context and indicate the field is now valid and
             * should be passed back and forth to the server */
            memcpy(sha512->digest, res->hash, WC_SHA512_DIGEST_SIZE);
            sha512->hiLen = res->hiLen;
            sha512->loLen = res->loLen;
            WH_DEBUG_CLIENT_VERBOSE("Client SHA512 Res recv:\n");
            WH_DEBUG_VERBOSE_HEXDUMP("[client] hash: ", (uint8_t*)sha512->digest,
                             WC_SHA512_DIGEST_SIZE);
        }
    }

    return ret;
}

int wh_Client_Sha512(whClientContext* ctx, wc_Sha512* sha512, const uint8_t* in,
                     uint32_t inLen, uint8_t* out)
{
    int      ret               = 0;
    uint8_t* sha512BufferBytes = (uint8_t*)sha512->buffer;
    int      hashType          = WC_HASH_TYPE_SHA512;

    /* Caller invoked SHA Update:
     * wc_CryptoCb_Sha512Hash(sha512, data, len, NULL) */
    if (in != NULL) {
        size_t i = 0;

        /* Process the partial blocks directly from the input data. If there
         * is enough input data to fill a full block, transfer it to the
         * server */
        if (sha512->buffLen > 0) {
            while (i < inLen && sha512->buffLen < WC_SHA512_BLOCK_SIZE) {
                sha512BufferBytes[sha512->buffLen++] = in[i++];
            }
            if (sha512->buffLen == WC_SHA512_BLOCK_SIZE) {
                ret = _xferSha512BlockAndUpdateDigest(ctx, sha512, 0);
                sha512->buffLen = 0;
            }
        }

        /* Process as many full blocks from the input data as we can */
        while (ret == 0 && (inLen - i) >= WC_SHA512_BLOCK_SIZE) {
            memcpy(sha512BufferBytes, in + i, WC_SHA512_BLOCK_SIZE);
            ret = _xferSha512BlockAndUpdateDigest(ctx, sha512, 0);
            i += WC_SHA512_BLOCK_SIZE;
        }

        /* Copy any remaining data into the buffer to be sent in a
         * subsequent call when we have enough input data to send a full
         * block */
        while (i < inLen) {
            sha512BufferBytes[sha512->buffLen++] = in[i++];
        }
    }

    /* Caller invoked SHA finalize:
     * wc_CryptoCb_Sha512Hash(sha512, NULL, 0, * hash) */
    if (ret == 0 && out != NULL) {
        ret = _xferSha512BlockAndUpdateDigest(ctx, sha512, 1);

        /* Copy out the final hash value */
        if (ret == 0) {
            memcpy(out, sha512->digest, WC_SHA512_DIGEST_SIZE);
        }
        /* keep hashtype before initialization */
        hashType = sha512->hashType;
        /* reset the state of the sha context (without blowing away devId and
         *  hashType)
         */
        switch (hashType) {
            case WC_HASH_TYPE_SHA512_224:
                ret = wc_InitSha512_224_ex(sha512, NULL, sha512->devId);
                break;
            case WC_HASH_TYPE_SHA512_256:
                ret = wc_InitSha512_256_ex(sha512, NULL, sha512->devId);
                break;
            default:
                ret = wc_InitSha512_ex(sha512, NULL, sha512->devId);
                break;
        }
    }

    return ret;
}

#ifdef WOLFHSM_CFG_DMA
int wh_Client_Sha512Dma(whClientContext* ctx, wc_Sha512* sha, const uint8_t* in,
                        uint32_t inLen, uint8_t* out)
{
    int                              ret     = WH_ERROR_OK;
    wc_Sha512*                       sha512  = sha;
    uint16_t                         respSz  = 0;
    uint16_t                         group   = WH_MESSAGE_GROUP_CRYPTO_DMA;
    uint8_t*                         dataPtr = NULL;
    whMessageCrypto_Sha2DmaRequest*  req     = NULL;
    whMessageCrypto_Sha2DmaResponse* resp    = NULL;
    uintptr_t                        inAddr    = 0;
    uintptr_t                        outAddr   = 0;
    uintptr_t                        stateAddr = 0;

    /* Get data pointer from the context to use as request/response storage */
    dataPtr = (uint8_t*)wh_CommClient_GetDataPtr(ctx->comm);
    if (dataPtr == NULL) {
        return WH_ERROR_BADARGS;
    }

    /* Setup generic header and get pointer to request data */
    req = (whMessageCrypto_Sha2DmaRequest*)_createCryptoRequest(
        dataPtr, WC_HASH_TYPE_SHA512, ctx->cryptoAffinity);

    if (in != NULL || out != NULL) {
        req->state.sz  = sizeof(*sha512);
        req->input.sz  = inLen;
        req->output.sz = WC_SHA512_DIGEST_SIZE; /* not needed, but YOLO */

        /* Perform address translations */
        ret = wh_Client_DmaProcessClientAddress(
            ctx, (uintptr_t)sha512, (void**)&stateAddr, req->state.sz,
            WH_DMA_OPER_CLIENT_WRITE_PRE, (whDmaFlags){0});
        if (ret == WH_ERROR_OK) {
            req->state.addr = stateAddr;
        }

        if (ret == WH_ERROR_OK) {
            ret = wh_Client_DmaProcessClientAddress(
                ctx, (uintptr_t)in, (void**)&inAddr, req->input.sz,
                WH_DMA_OPER_CLIENT_READ_PRE, (whDmaFlags){0});
            if (ret == WH_ERROR_OK) {
                req->input.addr = inAddr;
            }
        }

        if (ret == WH_ERROR_OK) {
            ret = wh_Client_DmaProcessClientAddress(
                ctx, (uintptr_t)out, (void**)&outAddr, req->output.sz,
                WH_DMA_OPER_CLIENT_WRITE_PRE, (whDmaFlags){0});
            if (ret == WH_ERROR_OK) {
                req->output.addr = outAddr;
            }
        }
    }

    /* Caller invoked SHA Update:
     * wc_CryptoCb_Sha512Hash(sha512, data, len, NULL) */
    if (in != NULL && ret == WH_ERROR_OK) {
        req->finalize    = 0;
        WH_DEBUG_CLIENT_VERBOSE("SHA512 DMA UPDATE: inAddr=%p, inSz=%u\n", in,
               (unsigned int)inLen);
        ret = wh_Client_SendRequest(
            ctx, group, WC_ALGO_TYPE_HASH,
            sizeof(whMessageCrypto_GenericRequestHeader) + sizeof(*req),
            (uint8_t*)dataPtr);

        if (ret == WH_ERROR_OK) {
            do {
                ret = wh_Client_RecvResponse(ctx, NULL, NULL, &respSz,
                                             (uint8_t*)dataPtr);
            } while (ret == WH_ERROR_NOTREADY);
        }

        if (ret == WH_ERROR_OK) {
            /* Get response structure pointer, validates generic header
             * rc */
            ret = _getCryptoResponse(dataPtr, WC_HASH_TYPE_SHA512,
                                     (uint8_t**)&resp);
            /* Nothing to do on success, as server will have updated the context
             * in client memory */
        }
    }

    /* Caller invoked SHA finalize:
     * wc_CryptoCb_Sha512Hash(sha512, NULL, 0, * hash) */
    if ((ret == WH_ERROR_OK) && (out != NULL)) {
        /* Packet will have been trashed, so re-populate all fields */
        req->finalize = 1;

        WH_DEBUG_CLIENT_VERBOSE("SHA512 DMA FINAL: outAddr=%p\n", out);
        /* send the request to the server */
        ret = wh_Client_SendRequest(
            ctx, group, WC_ALGO_TYPE_HASH,
            sizeof(whMessageCrypto_GenericRequestHeader) + sizeof(*req),
            (uint8_t*)dataPtr);

        if (ret == WH_ERROR_OK) {
            do {
                ret = wh_Client_RecvResponse(ctx, NULL, NULL, &respSz,
                                             (uint8_t*)dataPtr);
            } while (ret == WH_ERROR_NOTREADY);
        }

        /* Copy out the final hash value */
        if (ret == WH_ERROR_OK) {
            /* Get response structure pointer, validates generic header
             * rc */
            ret = _getCryptoResponse(dataPtr, WC_HASH_TYPE_SHA512,
                                     (uint8_t**)&resp);
            /* Nothing to do on success, as server will have updated the output
             * hash in client memory */
        }
    }

    if (in != NULL || out != NULL) {
        (void)wh_Client_DmaProcessClientAddress(
            ctx, (uintptr_t)sha512, (void**)&stateAddr, sizeof(*sha512),
            WH_DMA_OPER_CLIENT_WRITE_POST, (whDmaFlags){0});
        (void)wh_Client_DmaProcessClientAddress(
            ctx, (uintptr_t)in, (void**)&inAddr, inLen,
            WH_DMA_OPER_CLIENT_READ_POST, (whDmaFlags){0});
        (void)wh_Client_DmaProcessClientAddress(
            ctx, (uintptr_t)out, (void**)&outAddr, WC_SHA512_DIGEST_SIZE,
            WH_DMA_OPER_CLIENT_WRITE_POST, (whDmaFlags){0});
    }
    return ret;
}
#endif /* WOLFHSM_CFG_DMA  */
#endif /* WOLFSSL_SHA512 */

#ifdef HAVE_DILITHIUM

int wh_Client_MlDsaSetKeyId(MlDsaKey* key, whKeyId keyId)
{
    if (key == NULL) {
        return WH_ERROR_BADARGS;
    }

    key->devCtx = WH_KEYID_TO_DEVCTX(keyId);

    return WH_ERROR_OK;
}

int wh_Client_MlDsaGetKeyId(MlDsaKey* key, whKeyId* outId)
{
    if (key == NULL || outId == NULL) {
        return WH_ERROR_BADARGS;
    }

    *outId = WH_DEVCTX_TO_KEYID(key->devCtx);

    return WH_ERROR_OK;
}

int wh_Client_MlDsaImportKey(whClientContext* ctx, MlDsaKey* key,
                             whKeyId* inout_keyId, whNvmFlags flags,
                             uint16_t label_len, uint8_t* label)
{
    int      ret    = WH_ERROR_OK;
    whKeyId  key_id = WH_KEYID_ERASED;
    byte     buffer[DILITHIUM_MAX_BOTH_KEY_DER_SIZE];
    uint16_t buffer_len = 0;

    if ((ctx == NULL) || (key == NULL) ||
        ((label_len != 0) && (label == NULL))) {
        return WH_ERROR_BADARGS;
    }

    if (inout_keyId != NULL) {
        key_id = *inout_keyId;
    }

    ret = wh_Crypto_MlDsaSerializeKeyDer(key, sizeof(buffer), buffer,
                                         &buffer_len);
    WH_DEBUG_CLIENT_VERBOSE("serialize ret:%d, key:%p, max_size:%u, buffer:%p, "
           "outlen:%u\n",
           ret, key, (unsigned int)sizeof(buffer), buffer,
           buffer_len);
    if (ret == WH_ERROR_OK) {
        /* Cache the key and get the keyID */
        ret = wh_Client_KeyCache(ctx, flags, label, label_len, buffer,
                                 buffer_len, &key_id);
        if ((ret == WH_ERROR_OK) && (inout_keyId != NULL)) {
            *inout_keyId = key_id;
        }
    }

    WH_DEBUG_CLIENT_VERBOSE("label:%.*s ret:%d keyid:%u\n", label_len,
           label, ret, key_id);
    return ret;
}

int wh_Client_MlDsaExportKey(whClientContext* ctx, whKeyId keyId, MlDsaKey* key,
                             uint16_t label_len, uint8_t* label)
{
    int ret = WH_ERROR_OK;
    /* buffer cannot be larger than MTU */
    byte     buffer[DILITHIUM_MAX_BOTH_KEY_DER_SIZE];
    uint16_t buffer_len = sizeof(buffer);

    if ((ctx == NULL) || WH_KEYID_ISERASED(keyId) || (key == NULL)) {
        return WH_ERROR_BADARGS;
    }

    /* Now export the DER key from the server */
    ret =
        wh_Client_KeyExport(ctx, keyId, label, label_len, buffer, &buffer_len);
    if (ret == WH_ERROR_OK) {
        /* Update the key structure */
        ret = wh_Crypto_MlDsaDeserializeKeyDer(buffer, buffer_len, key);
    }

    WH_DEBUG_CLIENT_VERBOSE("keyid:%x key:%p ret:%d label:%.*s\n", keyId,
           key, ret, (int)label_len, label);
    return ret;
}

static int _MlDsaMakeKey(whClientContext* ctx, int size, int level,
                         whKeyId* inout_key_id, whNvmFlags flags,
                         uint16_t label_len, uint8_t* label, MlDsaKey* key)
{
    int                                  ret     = WH_ERROR_OK;
    whKeyId                              key_id  = WH_KEYID_ERASED;
    uint8_t*                             dataPtr = NULL;
    whMessageCrypto_MlDsaKeyGenRequest*  req     = NULL;
    whMessageCrypto_MlDsaKeyGenResponse* res     = NULL;

    if (ctx == NULL) {
        return WH_ERROR_BADARGS;
    }

    /* Get data pointer from the context to use as request/response storage */
    dataPtr = (uint8_t*)wh_CommClient_GetDataPtr(ctx->comm);
    if (dataPtr == NULL) {
        return WH_ERROR_BADARGS;
    }

    /* Setup generic header and get pointer to request data */
    req = (whMessageCrypto_MlDsaKeyGenRequest*)_createCryptoRequestWithSubtype(
        dataPtr, WC_PK_TYPE_PQC_SIG_KEYGEN, WC_PQC_SIG_TYPE_DILITHIUM,
        ctx->cryptoAffinity);

    /* Use the supplied key id if provided */
    if (inout_key_id != NULL) {
        key_id = *inout_key_id;
    }

    /* No other calls before here, so this is always true */
    if (ret == WH_ERROR_OK) {
        /* Request Message */
        uint16_t group  = WH_MESSAGE_GROUP_CRYPTO;
        uint16_t action = WC_ALGO_TYPE_PK;

        uint16_t req_len =
            sizeof(whMessageCrypto_GenericRequestHeader) + sizeof(*req);

        if (req_len <= WOLFHSM_CFG_COMM_DATA_LEN) {
            memset(req, 0, sizeof(*req));
            req->level = level;
            req->sz    = size;
            req->flags = flags;
            req->keyId = key_id;
            if ((label != NULL) && (label_len > 0)) {
                if (label_len > WH_NVM_LABEL_LEN) {
                    label_len = WH_NVM_LABEL_LEN;
                }
                memcpy(req->label, label, label_len);
            }

            ret = wh_Client_SendRequest(ctx, group, action, req_len,
                                        (uint8_t*)dataPtr);
            WH_DEBUG_CLIENT_VERBOSE("Req sent:size:%u, ret:%d\n",
                   (unsigned int)req->sz, ret);
            if (ret == 0) {
                uint16_t res_len;
                do {
                    ret = wh_Client_RecvResponse(ctx, &group, &action, &res_len,
                                                 (uint8_t*)dataPtr);
                } while (ret == WH_ERROR_NOTREADY);

                if (ret == WH_ERROR_OK) {
                    /* Get response structure pointer, validates generic header
                     * rc */
                    ret = _getCryptoResponse(dataPtr, WC_PK_TYPE_PQC_SIG_KEYGEN,
                                             (uint8_t**)&res);
                    /* wolfCrypt allows positive error codes on success in some
                     * scenarios */
                    if (ret >= 0) {
                        WH_DEBUG_CLIENT_VERBOSE(
                            "Res recv:keyid:%u, len:%u, ret:%d\n",
                            (unsigned int)res->keyId,
                            (unsigned int)res->len, ret);
                        /* Key is cached on server or is ephemeral */
                        key_id = (whKeyId)(res->keyId);

                        /* Update output variable if requested */
                        if (inout_key_id != NULL) {
                            *inout_key_id = key_id;
                        }

                        /* Update the context if provided */
                        if (key != NULL) {
                            uint16_t der_size = (uint16_t)(res->len);
                            /* Set the key_id. Should be ERASED if EPHEMERAL */
                            wh_Client_MlDsaSetKeyId(key, key_id);

                            if (flags & WH_NVM_FLAGS_EPHEMERAL) {
                                uint8_t* key_der = (uint8_t*)(res + 1);
                                /* Response has the exported key */
                                ret = wh_Crypto_MlDsaDeserializeKeyDer(
                                    key_der, der_size, key);
                    WH_DEBUG_VERBOSE_HEXDUMP(
                                    "[client] ML-DSA KeyGen export:", key_der,
                                    der_size);
                            }
                        }
                    }
                }
            }
        }
        else {
            ret = WH_ERROR_BADARGS;
        }
    }
    return ret;
}

int wh_Client_MlDsaMakeCacheKey(whClientContext* ctx, int size, int level,
                                whKeyId* inout_key_id, whNvmFlags flags,
                                uint16_t label_len, uint8_t* label)
{
    if (inout_key_id == NULL) {
        return WH_ERROR_BADARGS;
    }

    return _MlDsaMakeKey(ctx, size, level, inout_key_id, flags, label_len,
                         label, NULL);
}

int wh_Client_MlDsaMakeExportKey(whClientContext* ctx, int level, int size,
                                 MlDsaKey* key)
{
    if (key == NULL) {
        return WH_ERROR_BADARGS;
    }

    return _MlDsaMakeKey(ctx, size, level, NULL, WH_NVM_FLAGS_EPHEMERAL, 0,
                         NULL, key);
}


int wh_Client_MlDsaSign(whClientContext* ctx, const byte* in, word32 in_len,
                      byte* out, word32* inout_len, MlDsaKey* key,
                      const byte* context, byte contextLen,
                      word32 preHashType)
{
    int                                ret     = 0;
    whMessageCrypto_MlDsaSignRequest*  req     = NULL;
    whMessageCrypto_MlDsaSignResponse* res     = NULL;
    uint8_t*                           dataPtr = NULL;

    /* Transaction state */
    whKeyId key_id;
    int     evict = 0;

    WH_DEBUG_CLIENT_VERBOSE("ctx:%p key:%p, in:%p in_len:%u, out:%p inout_len:%p\n",
           ctx, key, in, (unsigned)in_len, out, inout_len);

    if ((ctx == NULL) || (key == NULL) || ((in == NULL) && (in_len > 0)) ||
        (out == NULL) || (inout_len == NULL)) {
        return WH_ERROR_BADARGS;
    }

    key_id = WH_DEVCTX_TO_KEYID(key->devCtx);

    WH_DEBUG_CLIENT_VERBOSE("keyid:%x, in_len:%u, inout_len:%p\n", key_id,
           in_len, inout_len);

    /* Import key if necessary */
    if (WH_KEYID_ISERASED(key_id)) {
        /* Must import the key to the server and evict it afterwards */
        uint8_t    keyLabel[] = "TempMlDsaSign";
        whNvmFlags flags      = WH_NVM_FLAGS_USAGE_SIGN;

        ret = wh_Client_MlDsaImportKey(ctx, key, &key_id, flags,
                                       sizeof(keyLabel), keyLabel);
        if (ret == WH_ERROR_OK) {
            evict = 1;
        }
    }

    if (ret == WH_ERROR_OK) {
        /* Request Message */
        uint16_t group  = WH_MESSAGE_GROUP_CRYPTO;
        uint16_t action = WC_ALGO_TYPE_PK;

        uint16_t req_len = sizeof(whMessageCrypto_GenericRequestHeader) +
                           sizeof(*req) + in_len + contextLen;
        uint32_t options = 0;

        /* Get data pointer from the context to use as request/response storage
         */
        dataPtr = (uint8_t*)wh_CommClient_GetDataPtr(ctx->comm);
        if (dataPtr == NULL) {
            return WH_ERROR_BADARGS;
        }

        /* Setup generic header and get pointer to request data */
        req =
            (whMessageCrypto_MlDsaSignRequest*)_createCryptoRequestWithSubtype(
                dataPtr, WC_PK_TYPE_PQC_SIG_SIGN, WC_PQC_SIG_TYPE_DILITHIUM,
                ctx->cryptoAffinity);

        if (req_len <= WOLFHSM_CFG_COMM_DATA_LEN) {
            uint8_t* req_data = (uint8_t*)(req + 1);
            if (evict != 0) {
                options |= WH_MESSAGE_CRYPTO_MLDSA_SIGN_OPTIONS_EVICT;
            }

            memset(req, 0, sizeof(*req));
            req->options     = options;
            req->level       = key->level;
            req->keyId       = key_id;
            req->sz          = in_len;
            req->contextSz   = contextLen;
            req->preHashType = preHashType;
            if ((in != NULL) && (in_len > 0)) {
                memcpy(req_data, in, in_len);
            }
            if ((context != NULL) && (contextLen > 0)) {
                memcpy(req_data + in_len, context, contextLen);
            }

            /* Send Request */
            ret = wh_Client_SendRequest(ctx, group, action, req_len,
                                        (uint8_t*)dataPtr);
            if (ret == WH_ERROR_OK) {
                /* Server will evict at this point. Reset evict */
                evict = 0;

                /* Response Message */
                uint16_t res_len = 0;

                /* Recv Response */
                do {
                    ret = wh_Client_RecvResponse(ctx, &group, &action, &res_len,
                                                 (uint8_t*)dataPtr);
                } while (ret == WH_ERROR_NOTREADY);

                if (ret == WH_ERROR_OK) {
                    /* Get response structure pointer, validates generic header
                     * rc */
                    ret = _getCryptoResponse(dataPtr, WC_PK_TYPE_PQC_SIG_SIGN,
                                             (uint8_t**)&res);
                    /* wolfCrypt allows positive error codes on success in some
                     * scenarios */
                    if (ret >= 0) {
                        uint8_t* res_sig = (uint8_t*)(res + 1);
                        uint16_t sig_len = res->sz;
                        /* check inoutlen and read out */
                        if (inout_len != NULL) {
                            if (sig_len > *inout_len) {
                                /* Silently truncate the signature */
                                sig_len = *inout_len;
                            }
                            *inout_len = sig_len;
                            if ((out != NULL) && (sig_len > 0)) {
                                memcpy(out, res_sig, sig_len);
                            }
                        }
                    }
                }
            }
        }
        else {
            /* Request length is too long */
            ret = WH_ERROR_BADARGS;
        }
    } /* Evict the key manually on error */
    if (evict != 0) {
        (void)wh_Client_KeyEvict(ctx, key_id);
    }
    WH_DEBUG_CLIENT_VERBOSE("ret:%d\n", ret);
    return ret;
}

int wh_Client_MlDsaVerify(whClientContext* ctx, const byte* sig, word32 sig_len,
                         const byte* msg, word32 msg_len, int* out_res,
                         MlDsaKey* key, const byte* context, byte contextLen,
                         word32 preHashType)
{
    int                                  ret     = WH_ERROR_OK;
    uint8_t*                             dataPtr = NULL;
    whMessageCrypto_MlDsaVerifyRequest*  req     = NULL;
    whMessageCrypto_MlDsaVerifyResponse* res     = NULL;

    /* Transaction state */
    whKeyId key_id;
    int     evict = 0;


    WH_DEBUG_CLIENT_VERBOSE("ctx:%p key:%p, sig:%p sig_len:%u, msg:%p msg_len:%u "
           "out_res:%p\n",
           ctx, key, sig, sig_len, msg, msg_len, out_res);

    if ((ctx == NULL) || (key == NULL) || ((sig == NULL) && (sig_len > 0)) ||
        ((msg == NULL) && (msg_len > 0))) {
        return WH_ERROR_BADARGS;
    }

    key_id = WH_DEVCTX_TO_KEYID(key->devCtx);

    /* Import key if necessary */
    if (WH_KEYID_ISERASED(key_id)) {
        /* Must import the key to the server and evict it afterwards */
        uint8_t    keyLabel[] = "TempMlDsaVerify";
        whNvmFlags flags      = WH_NVM_FLAGS_USAGE_VERIFY;

        ret = wh_Client_MlDsaImportKey(ctx, key, &key_id, flags,
                                       sizeof(keyLabel), keyLabel);
        if (ret == 0) {
            evict = 1;
        }
    }

    if (ret == WH_ERROR_OK) {
        /* Request Message */
        uint16_t group   = WH_MESSAGE_GROUP_CRYPTO;
        uint16_t action  = WC_ALGO_TYPE_PK;
        uint32_t options = 0;

        uint16_t req_len = sizeof(whMessageCrypto_GenericRequestHeader) +
                           sizeof(*req) + sig_len + msg_len + contextLen;


        /* Get data pointer from the context to use as request/response storage
         */
        dataPtr = (uint8_t*)wh_CommClient_GetDataPtr(ctx->comm);
        if (dataPtr == NULL) {
            return WH_ERROR_BADARGS;
        }

        /* Setup generic header and get pointer to request data */
        req = (whMessageCrypto_MlDsaVerifyRequest*)
            _createCryptoRequestWithSubtype(dataPtr, WC_PK_TYPE_PQC_SIG_VERIFY,
                                            WC_PQC_SIG_TYPE_DILITHIUM,
                                            ctx->cryptoAffinity);

        if (req_len <= WOLFHSM_CFG_COMM_DATA_LEN) {
            uint8_t* req_sig  = (uint8_t*)(req + 1);
            uint8_t* req_hash = req_sig + sig_len;

            /* Set request packet members */
            if (evict != 0) {
                options |= WH_MESSAGE_CRYPTO_MLDSA_VERIFY_OPTIONS_EVICT;
            }

            memset(req, 0, sizeof(*req));
            req->options     = options;
            req->level       = key->level;
            req->keyId       = key_id;
            req->sigSz       = sig_len;
            if ((sig != NULL) && (sig_len > 0)) {
                memcpy(req_sig, sig, sig_len);
            }
            req->hashSz      = msg_len;
            if ((msg != NULL) && (msg_len > 0)) {
                memcpy(req_hash, msg, msg_len);
            }
            req->contextSz   = contextLen;
            req->preHashType = preHashType;
            if ((context != NULL) && (contextLen > 0)) {
                memcpy(req_hash + msg_len, context, contextLen);
            }

            /* write request */
            ret = wh_Client_SendRequest(ctx, group, action, req_len,
                                        (uint8_t*)dataPtr);

            if (ret == WH_ERROR_OK) {
                /* Server will evict at this point. Reset evict */
                evict = 0;
                /* Response Message */
                uint16_t res_len = 0;

                /* Recv Response */
                do {
                    ret = wh_Client_RecvResponse(ctx, &group, &action, &res_len,
                                                 (uint8_t*)dataPtr);
                } while (ret == WH_ERROR_NOTREADY);
                if (ret == 0) {
                    /* Get response structure pointer, validates generic header
                     * rc */
                    ret = _getCryptoResponse(dataPtr, WC_PK_TYPE_PQC_SIG_VERIFY,
                                             (uint8_t**)&res);
                    /* wolfCrypt allows positive error codes on success in some
                     * scenarios */
                    if (ret >= 0) {
                        *out_res = res->res;
                    }
                }
            }
        }
        else {
            /* Request length is too long */
            ret = WH_ERROR_BADARGS;
        }
    }
    /* Evict the key manually on error */
    if (evict != 0) {
        (void)wh_Client_KeyEvict(ctx, key_id);
    }
    WH_DEBUG_CLIENT_VERBOSE("ret:%d\n", ret);
    return ret;
}

int wh_Client_MlDsaCheckPrivKey(whClientContext* ctx, MlDsaKey* key,
                                const byte* pubKey, word32 pubKeySz)
{
    /* TODO */
    (void)ctx;
    (void)key;
    (void)pubKey;
    (void)pubKeySz;
    return WH_ERROR_NOHANDLER;
}


#ifdef WOLFHSM_CFG_DMA

int wh_Client_MlDsaImportKeyDma(whClientContext* ctx, MlDsaKey* key,
                                whKeyId* inout_keyId, whNvmFlags flags,
                                uint16_t label_len, uint8_t* label)
{
    int      ret    = WH_ERROR_OK;
    whKeyId  key_id = WH_KEYID_ERASED;
    byte     buffer[DILITHIUM_MAX_BOTH_KEY_DER_SIZE];
    uint16_t buffer_len = 0;

    if ((ctx == NULL) || (key == NULL) ||
        ((label_len != 0) && (label == NULL))) {
        return WH_ERROR_BADARGS;
    }

    if (inout_keyId != NULL) {
        key_id = *inout_keyId;
    }

    /* Serialize the key to a temporary buffer first */
    ret = wh_Crypto_MlDsaSerializeKeyDer(key, sizeof(buffer), buffer,
                                         &buffer_len);
    if (ret == WH_ERROR_OK) {
        /* Cache the key using DMA and get the keyID */
        ret = wh_Client_KeyCacheDma(ctx, flags, label, label_len, buffer,
                                    buffer_len, &key_id);
        if ((ret == WH_ERROR_OK) && (inout_keyId != NULL)) {
            *inout_keyId = key_id;
        }
    }

    return ret;
}

int wh_Client_MlDsaExportKeyDma(whClientContext* ctx, whKeyId keyId,
                                MlDsaKey* key, uint16_t label_len,
                                uint8_t* label)
{
    int      ret                                = WH_ERROR_OK;
    byte     buffer[DILITHIUM_MAX_BOTH_KEY_DER_SIZE] = {0};
    uint16_t buffer_len                         = sizeof(buffer);

    if ((ctx == NULL) || WH_KEYID_ISERASED(keyId) || (key == NULL)) {
        return WH_ERROR_BADARGS;
    }

    /* Export the key from server using DMA */
    ret = wh_Client_KeyExportDma(ctx, keyId, buffer, buffer_len, label,
                                 label_len, &buffer_len);
    if (ret == WH_ERROR_OK) {
        /* Deserialize the key */
        ret = wh_Crypto_MlDsaDeserializeKeyDer(buffer, buffer_len, key);
    }

    return ret;
}

static int _MlDsaMakeKeyDma(whClientContext* ctx, int level,
                            whKeyId* inout_key_id, whNvmFlags flags,
                            uint16_t label_len, uint8_t* label, MlDsaKey* key)
{
    int                                     ret    = WH_ERROR_OK;
    whKeyId                                 key_id = WH_KEYID_ERASED;
    byte                                    buffer[DILITHIUM_MAX_BOTH_KEY_DER_SIZE];
    uint8_t*                                dataPtr = NULL;
    whMessageCrypto_MlDsaKeyGenDmaRequest*  req     = NULL;
    whMessageCrypto_MlDsaKeyGenDmaResponse* res     = NULL;
    uintptr_t                               keyAddr   = 0;
    uint64_t                                keyAddrSz = 0;

    if (ctx == NULL) {
        return WH_ERROR_BADARGS;
    }

    /* Get data pointer from the context to use as request/response storage */
    dataPtr = (uint8_t*)wh_CommClient_GetDataPtr(ctx->comm);
    if (dataPtr == NULL) {
        return WH_ERROR_BADARGS;
    }

    /* Setup generic header and get pointer to request data */
    req =
        (whMessageCrypto_MlDsaKeyGenDmaRequest*)_createCryptoRequestWithSubtype(
            dataPtr, WC_PK_TYPE_PQC_SIG_KEYGEN, WC_PQC_SIG_TYPE_DILITHIUM,
            ctx->cryptoAffinity);

    /* Use the supplied key id if provided */
    if (inout_key_id != NULL) {
        key_id = *inout_key_id;
    }

    /* Request Message */
    uint16_t group  = WH_MESSAGE_GROUP_CRYPTO_DMA;
    uint16_t action = WC_ALGO_TYPE_PK;

    uint16_t req_len =
        sizeof(whMessageCrypto_GenericRequestHeader) + sizeof(*req);

    if (req_len <= WOLFHSM_CFG_COMM_DATA_LEN) {
        memset(req, 0, sizeof(*req));
        req->level    = level;
        req->flags    = flags;
        req->keyId    = key_id;
        req->key.sz = keyAddrSz = sizeof(buffer);

        ret = wh_Client_DmaProcessClientAddress(
            ctx, (uintptr_t)buffer, (void**)&keyAddr, keyAddrSz,
            WH_DMA_OPER_CLIENT_WRITE_PRE, (whDmaFlags){0});
        if (ret == WH_ERROR_OK) {
            req->key.addr = (uint64_t)(uintptr_t)keyAddr;
        }

        if ((label != NULL) && (label_len > 0)) {
            if (label_len > WH_NVM_LABEL_LEN) {
                label_len = WH_NVM_LABEL_LEN;
            }
            memcpy(req->label, label, label_len);
            req->labelSize = label_len;
        }

        if (ret == WH_ERROR_OK) {
            ret = wh_Client_SendRequest(ctx, group, action, req_len,
                                        (uint8_t*)dataPtr);
        }
        if (ret == WH_ERROR_OK) {
            uint16_t res_len;
            do {
                ret = wh_Client_RecvResponse(ctx, &group, &action, &res_len,
                                             (uint8_t*)dataPtr);
            } while (ret == WH_ERROR_NOTREADY);
        }

        (void)wh_Client_DmaProcessClientAddress(
            ctx, (uintptr_t)buffer, (void**)&keyAddr, keyAddrSz,
            WH_DMA_OPER_CLIENT_WRITE_POST, (whDmaFlags){0});

        if (ret == WH_ERROR_OK) {
            /* Get response structure pointer, validates generic header
             * rc */
            ret = _getCryptoResponse(dataPtr, WC_PK_TYPE_PQC_SIG_KEYGEN,
                                     (uint8_t**)&res);
            /* wolfCrypt allows positive error codes on success in some
             * scenarios */
            if (ret >= 0) {
                /* Key is cached on server or is ephemeral */
                key_id = (whKeyId)(res->keyId);

                /* Update output variable if requested */
                if (inout_key_id != NULL) {
                    *inout_key_id = key_id;
                }

                /* Update the context if provided */
                if (key != NULL) {
                    /* Set the key_id. Should be ERASED if EPHEMERAL */
                    wh_Client_MlDsaSetKeyId(key, key_id);

                    if (flags & WH_NVM_FLAGS_EPHEMERAL) {
                        /* Response has the exported key */
                        ret = wh_Crypto_MlDsaDeserializeKeyDer(
                            buffer, res->keySize, key);
                    }
                }
            }
        }
    }
    else {
        ret = WH_ERROR_BADARGS;
    }
    return ret;
}


int wh_Client_MlDsaMakeExportKeyDma(whClientContext* ctx, int level,
                                    MlDsaKey* key)
{
    if (key == NULL) {
        return WH_ERROR_BADARGS;
    }

    return _MlDsaMakeKeyDma(ctx, level, NULL, WH_NVM_FLAGS_EPHEMERAL, 0, NULL,
                            key);
}


int wh_Client_MlDsaSignDma(whClientContext* ctx, const byte* in, word32 in_len,
                         byte* out, word32* out_len, MlDsaKey* key,
                         const byte* context, byte contextLen,
                         word32 preHashType)
{
    int                                   ret     = 0;
    whMessageCrypto_MlDsaSignDmaRequest*  req     = NULL;
    whMessageCrypto_MlDsaSignDmaResponse* res     = NULL;
    uint8_t*                              dataPtr = NULL;
    uintptr_t                             inAddr  = 0;
    uintptr_t                             outAddr = 0;

    /* Transaction state */
    whKeyId key_id;
    int     evict = 0;

    if ((ctx == NULL) || (key == NULL) || ((in == NULL) && (in_len > 0)) ||
        (out == NULL) || (out_len == NULL)) {
        return WH_ERROR_BADARGS;
    }

    key_id = WH_DEVCTX_TO_KEYID(key->devCtx);

    /* Import key if necessary */
    if (WH_KEYID_ISERASED(key_id)) {
        /* Must import the key to the server and evict it afterwards */
        uint8_t    keyLabel[] = "TempMlDsaSign";
        whNvmFlags flags      = WH_NVM_FLAGS_USAGE_SIGN;

        ret = wh_Client_MlDsaImportKeyDma(ctx, key, &key_id, flags,
                                          sizeof(keyLabel), keyLabel);
        if (ret == WH_ERROR_OK) {
            evict = 1;
        }
    }

    WH_DEBUG_CLIENT_VERBOSE("keyid:%x, in_len:%u, inout_len:%p\n", key_id,
           in_len, out_len);

    if (ret == WH_ERROR_OK) {
        /* Request Message */
        uint16_t group  = WH_MESSAGE_GROUP_CRYPTO_DMA;
        uint16_t action = WC_ALGO_TYPE_PK;

        uint16_t req_len =
            sizeof(whMessageCrypto_GenericRequestHeader) + sizeof(*req) +
            contextLen;
        uint32_t options = 0;

        /* Get data pointer from the context to use as request/response storage
         */
        dataPtr = (uint8_t*)wh_CommClient_GetDataPtr(ctx->comm);
        if (dataPtr == NULL) {
            return WH_ERROR_BADARGS;
        }

        /* Setup generic header and get pointer to request data */
        req = (whMessageCrypto_MlDsaSignDmaRequest*)
            _createCryptoRequestWithSubtype(dataPtr, WC_PK_TYPE_PQC_SIG_SIGN,
                                            WC_PQC_SIG_TYPE_DILITHIUM,
                                            ctx->cryptoAffinity);

        if (req_len <= WOLFHSM_CFG_COMM_DATA_LEN) {
            if (evict != 0) {
                options |= WH_MESSAGE_CRYPTO_MLDSA_SIGN_OPTIONS_EVICT;
            }

            memset(req, 0, sizeof(*req));
            req->options     = options;
            req->level       = key->level;
            req->keyId       = key_id;
            req->contextSz   = contextLen;
            req->preHashType = preHashType;
            if ((context != NULL) && (contextLen > 0)) {
                memcpy((uint8_t*)(req + 1), context, contextLen);
            }

            /* Set up DMA buffers */
            req->msg.sz   = in_len;
            ret           = wh_Client_DmaProcessClientAddress(
                ctx, (uintptr_t)in, (void**)&inAddr, req->msg.sz,
                WH_DMA_OPER_CLIENT_READ_PRE, (whDmaFlags){0});
            if (ret == WH_ERROR_OK) {
                req->msg.addr = inAddr;
            }

            if (ret == WH_ERROR_OK) {
                req->sig.sz = *out_len;
                ret         = wh_Client_DmaProcessClientAddress(
                    ctx, (uintptr_t)out, (void**)&outAddr, req->sig.sz,
                    WH_DMA_OPER_CLIENT_WRITE_PRE, (whDmaFlags){0});
                if (ret == WH_ERROR_OK) {
                    req->sig.addr = outAddr;
                }
            }

            /* Send Request */
            if (ret == WH_ERROR_OK) {
                ret = wh_Client_SendRequest(ctx, group, action, req_len,
                                            (uint8_t*)dataPtr);
            }
            if (ret == WH_ERROR_OK) {
                /* Server will evict at this point if requested */
                evict = 0;

                /* Response Message */
                uint16_t res_len = 0;

                /* Recv Response */
                do {
                    ret = wh_Client_RecvResponse(ctx, &group, &action, &res_len,
                                                 (uint8_t*)dataPtr);
                } while (ret == WH_ERROR_NOTREADY);

                if (ret == WH_ERROR_OK) {
                    /* Get response structure pointer, validates generic header
                     * rc */
                    ret = _getCryptoResponse(dataPtr, WC_PK_TYPE_PQC_SIG_SIGN,
                                             (uint8_t**)&res);
                    /* wolfCrypt allows positive error codes on success in some
                     * scenarios */
                    if (ret >= 0) {
                        /* Update signature length */
                        *out_len = res->sigLen;
                    }
                }
            }

            (void)wh_Client_DmaProcessClientAddress(
                ctx, (uintptr_t)out, (void**)&outAddr, *out_len,
                WH_DMA_OPER_CLIENT_WRITE_POST, (whDmaFlags){0});
            (void)wh_Client_DmaProcessClientAddress(
                ctx, (uintptr_t)in, (void**)&inAddr, in_len,
                WH_DMA_OPER_CLIENT_READ_POST, (whDmaFlags){0});
        }
        else {
            ret = WH_ERROR_BADARGS;
        }
    }
    /* Evict the key manually on error if needed */
    if (evict != 0) {
        (void)wh_Client_KeyEvict(ctx, key_id);
    }

    return ret;
}

int wh_Client_MlDsaVerifyDma(whClientContext* ctx, const byte* sig,
                            word32 sig_len, const byte* msg, word32 msg_len,
                            int* out_res, MlDsaKey* key, const byte* context,
                            byte contextLen, word32 preHashType)
{
    int                                     ret     = 0;
    whMessageCrypto_MlDsaVerifyDmaRequest*  req     = NULL;
    whMessageCrypto_MlDsaVerifyDmaResponse* res     = NULL;
    uint8_t*                                dataPtr = NULL;

    /* Transaction state */
    whKeyId key_id;
    int     evict = 0;

    if ((ctx == NULL) || (key == NULL) || ((sig == NULL) && (sig_len > 0)) ||
        ((msg == NULL) && (msg_len > 0)) || (out_res == NULL)) {
        return WH_ERROR_BADARGS;
    }

    key_id = WH_DEVCTX_TO_KEYID(key->devCtx);

    /* Import key if necessary */
    if (WH_KEYID_ISERASED(key_id)) {
        /* Must import the key to the server and evict it afterwards */
        uint8_t    keyLabel[] = "TempMlDsaVerify";
        whNvmFlags flags      = WH_NVM_FLAGS_USAGE_VERIFY;

        ret = wh_Client_MlDsaImportKeyDma(ctx, key, &key_id, flags,
                                          sizeof(keyLabel), keyLabel);
        if (ret == 0) {
            evict = 1;
        }
    }

    if (ret == WH_ERROR_OK) {
        /* Request Message */
        uint16_t group   = WH_MESSAGE_GROUP_CRYPTO_DMA;
        uint16_t action  = WC_ALGO_TYPE_PK;
        uint32_t options = 0;
        uintptr_t sigAddr = 0;
        uintptr_t msgAddr = 0;

        uint16_t req_len =
            sizeof(whMessageCrypto_GenericRequestHeader) + sizeof(*req) +
            contextLen;

        /* Get data pointer from the context to use as request/response storage
         */
        dataPtr = (uint8_t*)wh_CommClient_GetDataPtr(ctx->comm);
        if (dataPtr == NULL) {
            return WH_ERROR_BADARGS;
        }

        /* Setup generic header and get pointer to request data */
        req = (whMessageCrypto_MlDsaVerifyDmaRequest*)
            _createCryptoRequestWithSubtype(dataPtr, WC_PK_TYPE_PQC_SIG_VERIFY,
                                            WC_PQC_SIG_TYPE_DILITHIUM,
                                            ctx->cryptoAffinity);

        if (req_len <= WOLFHSM_CFG_COMM_DATA_LEN) {
            if (evict != 0) {
                options |= WH_MESSAGE_CRYPTO_MLDSA_VERIFY_OPTIONS_EVICT;
            }

            memset(req, 0, sizeof(*req));
            req->options     = options;
            req->level       = key->level;
            req->keyId       = key_id;
            req->contextSz   = contextLen;
            req->preHashType = preHashType;
            if ((context != NULL) && (contextLen > 0)) {
                memcpy((uint8_t*)(req + 1), context, contextLen);
            }

            /* Set up DMA buffers */
            req->sig.sz   = sig_len;
            ret           = wh_Client_DmaProcessClientAddress(
                ctx, (uintptr_t)sig, (void**)&sigAddr, sig_len,
                WH_DMA_OPER_CLIENT_READ_PRE, (whDmaFlags){0});
            if (ret == WH_ERROR_OK) {
                req->sig.addr = sigAddr;
            }
            if (ret == WH_ERROR_OK) {
                req->msg.sz = msg_len;
                ret         = wh_Client_DmaProcessClientAddress(
                    ctx, (uintptr_t)msg, (void**)&msgAddr, msg_len,
                    WH_DMA_OPER_CLIENT_READ_PRE, (whDmaFlags){0});
                if (ret == WH_ERROR_OK) {
                    req->msg.addr = msgAddr;
                }
            }

            /* Send Request */
            if (ret == WH_ERROR_OK) {
                ret = wh_Client_SendRequest(ctx, group, action, req_len,
                                            (uint8_t*)dataPtr);
            }
            if (ret == WH_ERROR_OK) {
                /* Server will evict at this point if requested */
                evict = 0;

                /* Response Message */
                uint16_t res_len = 0;

                /* Recv Response */
                do {
                    ret = wh_Client_RecvResponse(ctx, &group, &action, &res_len,
                                                 (uint8_t*)dataPtr);
                } while (ret == WH_ERROR_NOTREADY);

                if (ret == WH_ERROR_OK) {
                    /* Get response structure pointer, validates generic header
                     * rc */
                    ret = _getCryptoResponse(dataPtr, WC_PK_TYPE_PQC_SIG_VERIFY,
                                             (uint8_t**)&res);
                    /* wolfCrypt allows positive error codes on success in some
                     * scenarios */
                    if (ret >= 0) {
                        /* Set verification result */
                        *out_res = res->verifyResult;
                    }
                }
            }

            (void)wh_Client_DmaProcessClientAddress(
                ctx, (uintptr_t)msg, (void**)&msgAddr, msg_len,
                WH_DMA_OPER_CLIENT_READ_POST, (whDmaFlags){0});
            (void)wh_Client_DmaProcessClientAddress(
                ctx, (uintptr_t)sig, (void**)&sigAddr, sig_len,
                WH_DMA_OPER_CLIENT_READ_POST, (whDmaFlags){0});
        }
        else {
            ret = WH_ERROR_BADARGS;
        }
    }

    /* Evict the key manually on error if needed */
    if (evict != 0) {
        (void)wh_Client_KeyEvict(ctx, key_id);
    }

    return ret;
}


int wh_Client_MlDsaCheckPrivKeyDma(whClientContext* ctx, MlDsaKey* key,
                                   const byte* pubKey, word32 pubKeySz)
{
    /* TODO */
    (void)ctx;
    (void)key;
    (void)pubKey;
    (void)pubKeySz;
    return CRYPTOCB_UNAVAILABLE;
}


#endif /* WOLFHSM_CFG_DMA */
#endif /* HAVE_DILITHIUM */

#endif /* !WOLFHSM_CFG_NO_CRYPTO && WOLFHSM_CFG_ENABLE_CLIENT */