wh_client_cryptocb.c

/*
 * Copyright (C) 2026 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_cryptocb.c
 *
 */

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

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

#include <stdint.h>

#include "wolfhsm/wh_common.h"
#include "wolfhsm/wh_error.h"
#include "wolfhsm/wh_utils.h"
#include "wolfhsm/wh_comm.h"
#include "wolfhsm/wh_message.h"
#include "wolfhsm/wh_client.h"

#include "wolfssl/wolfcrypt/settings.h"
#include "wolfssl/wolfcrypt/types.h"
#include "wolfssl/wolfcrypt/error-crypt.h"
#include "wolfssl/wolfcrypt/cryptocb.h"
#include "wolfssl/wolfcrypt/asn.h"
#include "wolfssl/wolfcrypt/aes.h"
#include "wolfssl/wolfcrypt/sm4.h"
#include "wolfssl/wolfcrypt/cmac.h"
#include "wolfssl/wolfcrypt/rsa.h"
#include "wolfssl/wolfcrypt/curve25519.h"
#include "wolfssl/wolfcrypt/ecc.h"
#include "wolfssl/wolfcrypt/sha256.h"
#include "wolfssl/wolfcrypt/sha512.h"
#include "wolfssl/wolfcrypt/wc_mlkem.h"
#if defined(WOLFSSL_HAVE_LMS)
#include "wolfssl/wolfcrypt/wc_lms.h"
#endif
#if defined(WOLFSSL_HAVE_XMSS)
#include "wolfssl/wolfcrypt/wc_xmss.h"
#endif

#include "wolfhsm/wh_crypto.h"
#include "wolfhsm/wh_client_crypto.h"
#include "wolfhsm/wh_client_cryptocb.h"
#include "wolfhsm/wh_message_crypto.h"


#if defined(WOLFSSL_HAVE_MLKEM)
static int _handlePqcKemKeyGen(whClientContext* ctx, wc_CryptoInfo* info,
                               int useDma);
static int _handlePqcEncaps(whClientContext* ctx, wc_CryptoInfo* info,
                            int useDma);
static int _handlePqcDecaps(whClientContext* ctx, wc_CryptoInfo* info,
                            int useDma);
#endif /* WOLFSSL_HAVE_MLKEM */
#if defined(WOLFSSL_HAVE_LMS) || defined(WOLFSSL_HAVE_XMSS)
static int _handlePqcStatefulSigKeyGen(whClientContext* ctx,
                                       wc_CryptoInfo* info, int useDma);
static int _handlePqcStatefulSigSign(whClientContext* ctx, wc_CryptoInfo* info,
                                     int useDma);
static int _handlePqcStatefulSigVerify(whClientContext* ctx,
                                       wc_CryptoInfo* info, int useDma);
static int _handlePqcStatefulSigSigsLeft(whClientContext* ctx,
                                         wc_CryptoInfo* info, int useDma);
#endif /* WOLFSSL_HAVE_LMS || WOLFSSL_HAVE_XMSS */


#if defined(WOLFSSL_HAVE_MLDSA) || defined(HAVE_FALCON)
static int _handlePqcSigKeyGen(whClientContext* ctx, wc_CryptoInfo* info,
                               int useDma);
static int _handlePqcSign(whClientContext* ctx, wc_CryptoInfo* info,
                          int useDma);
static int _handlePqcVerify(whClientContext* ctx, wc_CryptoInfo* info,
                            int useDma);
static int _handlePqcSigCheckPrivKey(whClientContext* ctx, wc_CryptoInfo* info,
                                     int useDma);
#endif /* WOLFSSL_HAVE_MLDSA || HAVE_FALCON */

int wh_Client_CryptoCb(int devId, wc_CryptoInfo* info, void* inCtx)
{
    int ret;

    if ((devId == INVALID_DEVID) || (info == NULL) || (inCtx == NULL)) {
        return BAD_FUNC_ARG;
    }

#ifdef WOLFHSM_CFG_DMA
    /* If the client prefers DMA operations, dispatch to the DMA callback first
     * and fall back to the standard (non-DMA) callback if the algorithm is not
     * supported by the DMA callback. */
    if (((whClientContext*)inCtx)->dma.preferDma) {
        ret = wh_Client_CryptoCbDma(devId, info, inCtx);
        if (ret == CRYPTOCB_UNAVAILABLE) {
            ret = wh_Client_CryptoCbStd(devId, info, inCtx);
        }
    }
    else
#endif /* WOLFHSM_CFG_DMA */
    {
        /* DMA not preferred (or not compiled in); use the standard callback */
        ret = wh_Client_CryptoCbStd(devId, info, inCtx);
    }

    /* Propagate the error unchanged so if the algo is unsupported
     * (CRYPTOCB_UNAVAILABLE), wolfCrypt can fall back to its default
     * (software) implementation for operations wolfHSM does not offload.
     * Eventually we want this to be a hard error, but there are edge cases
     * around compound operations that need to be carefully handled and may
     * require changes to wolfCrypt to successfully facilitate. */
    return ret;
}

int wh_Client_CryptoCbStd(int devId, wc_CryptoInfo* info, void* inCtx)
{
    /* III When possible, return wolfCrypt-enumerated errors */
    int ret = CRYPTOCB_UNAVAILABLE;
    whClientContext* ctx = inCtx;
    if (    (devId == INVALID_DEVID) ||
            (info == NULL) ||
            (inCtx == NULL)) {
        return BAD_FUNC_ARG;
    }

    WH_DEBUG_CLIENT("info:%p algo_type:%d\n", info,
            (info!=NULL)?info->algo_type:-1);
    WH_DEBUG_CLIENT_VERBOSE("CryptoCb info details: info=%p algo_type=%d", info,
                            (info!=NULL)?info->algo_type:-1);
    /* Based on the info type, process the request */
    switch (info->algo_type)
    {
#if !defined(NO_AES) || !defined(NO_DES3) || defined(WOLFSSL_SM4)
    case WC_ALGO_TYPE_CIPHER:
        switch (info->cipher.type)
        {
#ifndef NO_AES
#ifdef HAVE_AES_CBC
        case WC_CIPHER_AES_CBC:
        {
            /* Extract info parameters */
            uint32_t enc        = info->cipher.enc;
            Aes* aes            = info->cipher.aescbc.aes;
            const uint8_t* in   = info->cipher.aescbc.in;
            uint32_t len        = info->cipher.aescbc.sz;
            uint8_t* out        = info->cipher.aescbc.out;

            ret = wh_Client_AesCbc(ctx, aes, enc, in, len, out);

        } break;
#endif /* HAVE_AES_CBC */

#ifdef WOLFSSL_AES_COUNTER
        case WC_CIPHER_AES_CTR: {
            /* Extract info parameters */
            uint32_t       enc = info->cipher.enc;
            Aes*           aes = info->cipher.aesctr.aes;
            const uint8_t* in  = info->cipher.aesctr.in;
            uint32_t       len = info->cipher.aesctr.sz;
            uint8_t*       out = info->cipher.aesctr.out;

            ret = wh_Client_AesCtr(ctx, aes, enc, in, len, out);

        } break;
#endif /* WOLFSSL_AES_COUNTER */

#ifdef HAVE_AES_ECB
        case WC_CIPHER_AES_ECB: {
            /* Extract info parameters */
            uint32_t       enc = info->cipher.enc;
            Aes*           aes = info->cipher.aesecb.aes;
            const uint8_t* in  = info->cipher.aesecb.in;
            uint32_t       len = info->cipher.aesecb.sz;
            uint8_t*       out = info->cipher.aesecb.out;

            ret = wh_Client_AesEcb(ctx, aes, enc, in, len, out);

        } break;
#endif /* HAVE_AES_ECB */

#ifdef HAVE_AESGCM
        case WC_CIPHER_AES_GCM:
        {
            /* Extract info parameters */
            uint32_t enc            =   info->cipher.enc;
            Aes* aes                = (enc == 0) ?
                                        info->cipher.aesgcm_dec.aes :
                                        info->cipher.aesgcm_enc.aes;
            uint32_t len            = (enc == 0) ?
                                        info->cipher.aesgcm_dec.sz :
                                        info->cipher.aesgcm_enc.sz;
            uint32_t iv_len         = (enc == 0) ?
                                        info->cipher.aesgcm_dec.ivSz:
                                        info->cipher.aesgcm_enc.ivSz;
            uint32_t authin_len     = (enc == 0) ?
                                        info->cipher.aesgcm_dec.authInSz:
                                        info->cipher.aesgcm_enc.authInSz;
            uint32_t tag_len        = (enc == 0) ?
                                        info->cipher.aesgcm_dec.authTagSz:
                                        info->cipher.aesgcm_enc.authTagSz;
            const uint8_t* in       = (enc == 0) ?
                                        info->cipher.aesgcm_dec.in :
                                        info->cipher.aesgcm_enc.in;
            const uint8_t* iv       = (enc == 0) ?
                                        info->cipher.aesgcm_dec.iv :
                                        info->cipher.aesgcm_enc.iv;
            const uint8_t* authin   = (enc == 0) ?
                                        info->cipher.aesgcm_dec.authIn :
                                        info->cipher.aesgcm_enc.authIn;
            const uint8_t* dec_tag  =   info->cipher.aesgcm_dec.authTag;
            uint8_t* enc_tag        =   info->cipher.aesgcm_enc.authTag;
            uint8_t* out            = (enc == 0) ?
                                        info->cipher.aesgcm_dec.out :
                                        info->cipher.aesgcm_enc.out;

            ret = wh_Client_AesGcm(ctx, aes, enc, in, len,iv, iv_len,
                    authin, authin_len, dec_tag, enc_tag, tag_len, out);
        } break;
#endif /* HAVE_AESGCM */
#endif /* !NO_AES */

#ifdef WOLFSSL_SM4
#ifdef WOLFSSL_SM4_ECB
        case WC_CIPHER_SM4_ECB: {
            uint32_t       enc = info->cipher.enc;
            wc_Sm4*        sm4 = info->cipher.sm4ecb.sm4;
            const uint8_t* in  = info->cipher.sm4ecb.in;
            uint32_t       len = info->cipher.sm4ecb.sz;
            uint8_t*       out = info->cipher.sm4ecb.out;

            ret = wh_Client_Sm4Ecb(ctx, sm4, enc, in, len, out);
        } break;
#endif /* WOLFSSL_SM4_ECB */

#ifdef WOLFSSL_SM4_CBC
        case WC_CIPHER_SM4_CBC: {
            uint32_t       enc = info->cipher.enc;
            wc_Sm4*        sm4 = info->cipher.sm4cbc.sm4;
            const uint8_t* in  = info->cipher.sm4cbc.in;
            uint32_t       len = info->cipher.sm4cbc.sz;
            uint8_t*       out = info->cipher.sm4cbc.out;

            ret = wh_Client_Sm4Cbc(ctx, sm4, enc, in, len, out);
        } break;
#endif /* WOLFSSL_SM4_CBC */

#ifdef WOLFSSL_SM4_CTR
        case WC_CIPHER_SM4_CTR: {
            /* CTR is its own inverse, so the direction is not carried */
            wc_Sm4*        sm4 = info->cipher.sm4ctr.sm4;
            const uint8_t* in  = info->cipher.sm4ctr.in;
            uint32_t       len = info->cipher.sm4ctr.sz;
            uint8_t*       out = info->cipher.sm4ctr.out;

            ret = wh_Client_Sm4Ctr(ctx, sm4, in, len, out);
        } break;
#endif /* WOLFSSL_SM4_CTR */

#ifdef WOLFSSL_SM4_GCM
        case WC_CIPHER_SM4_GCM: {
            uint32_t enc = info->cipher.enc;
            wc_Sm4*  sm4 = (enc == 0) ? info->cipher.sm4gcm_dec.sm4
                                      : info->cipher.sm4gcm_enc.sm4;
            uint32_t len = (enc == 0) ? info->cipher.sm4gcm_dec.sz
                                      : info->cipher.sm4gcm_enc.sz;
            uint32_t iv_len     = (enc == 0) ? info->cipher.sm4gcm_dec.nonceSz
                                             : info->cipher.sm4gcm_enc.nonceSz;
            uint32_t authin_len = (enc == 0) ? info->cipher.sm4gcm_dec.authInSz
                                             : info->cipher.sm4gcm_enc.authInSz;
            uint32_t tag_len    = (enc == 0) ? info->cipher.sm4gcm_dec.authTagSz
                                             : info->cipher.sm4gcm_enc.authTagSz;
            const uint8_t* in   = (enc == 0) ? info->cipher.sm4gcm_dec.in
                                             : info->cipher.sm4gcm_enc.in;
            const uint8_t* iv   = (enc == 0) ? info->cipher.sm4gcm_dec.nonce
                                             : info->cipher.sm4gcm_enc.nonce;
            const uint8_t* authin = (enc == 0)
                                        ? info->cipher.sm4gcm_dec.authIn
                                        : info->cipher.sm4gcm_enc.authIn;
            uint8_t* out          = (enc == 0) ? info->cipher.sm4gcm_dec.out
                                               : info->cipher.sm4gcm_enc.out;
            /* The decrypt tag is const on the wolfCrypt side; the client only
             * writes a tag back when encrypting. */
            uint8_t* tag =
                (enc == 0) ? (uint8_t*)info->cipher.sm4gcm_dec.authTag
                           : info->cipher.sm4gcm_enc.authTag;

            ret = wh_Client_Sm4Gcm(ctx, sm4, enc, in, len, iv, iv_len, authin,
                                   authin_len, tag, tag_len, out);
        } break;
#endif /* WOLFSSL_SM4_GCM */

#ifdef WOLFSSL_SM4_CCM
        case WC_CIPHER_SM4_CCM: {
            uint32_t enc = info->cipher.enc;
            wc_Sm4*  sm4 = (enc == 0) ? info->cipher.sm4ccm_dec.sm4
                                      : info->cipher.sm4ccm_enc.sm4;
            uint32_t len = (enc == 0) ? info->cipher.sm4ccm_dec.sz
                                      : info->cipher.sm4ccm_enc.sz;
            uint32_t iv_len     = (enc == 0) ? info->cipher.sm4ccm_dec.nonceSz
                                             : info->cipher.sm4ccm_enc.nonceSz;
            uint32_t authin_len = (enc == 0) ? info->cipher.sm4ccm_dec.authInSz
                                             : info->cipher.sm4ccm_enc.authInSz;
            uint32_t tag_len    = (enc == 0) ? info->cipher.sm4ccm_dec.authTagSz
                                             : info->cipher.sm4ccm_enc.authTagSz;
            const uint8_t* in   = (enc == 0) ? info->cipher.sm4ccm_dec.in
                                             : info->cipher.sm4ccm_enc.in;
            const uint8_t* iv   = (enc == 0) ? info->cipher.sm4ccm_dec.nonce
                                             : info->cipher.sm4ccm_enc.nonce;
            const uint8_t* authin = (enc == 0)
                                        ? info->cipher.sm4ccm_dec.authIn
                                        : info->cipher.sm4ccm_enc.authIn;
            uint8_t* out          = (enc == 0) ? info->cipher.sm4ccm_dec.out
                                               : info->cipher.sm4ccm_enc.out;
            uint8_t* tag =
                (enc == 0) ? (uint8_t*)info->cipher.sm4ccm_dec.authTag
                           : info->cipher.sm4ccm_enc.authTag;

            ret = wh_Client_Sm4Ccm(ctx, sm4, enc, in, len, iv, iv_len, authin,
                                   authin_len, tag, tag_len, out);
        } break;
#endif /* WOLFSSL_SM4_CCM */
#endif /* WOLFSSL_SM4 */

        default:
            ret = CRYPTOCB_UNAVAILABLE;
            break;
        }
        break;
#endif /* !NO_AES || !NO_DES */

    case WC_ALGO_TYPE_PK:
        switch (info->pk.type)
        {
#ifndef NO_RSA
#ifdef WOLFSSL_KEY_GEN
        case WC_PK_TYPE_RSA_KEYGEN:
        {
            /* Extract info parameters */
            int size            = info->pk.rsakg.size;
            int e               = info->pk.rsakg.e;
            RsaKey* rsa         = info->pk.rsakg.key;

            ret = wh_Client_RsaMakeExportKey(ctx, size, e, rsa);
        } break;
#endif  /* WOLFSSL_KEY_GEN */

        case WC_PK_TYPE_RSA:
        {
            /* Extract info parameters */
            RsaKey* rsa         = info->pk.rsa.key;
            int rsa_type        = info->pk.rsa.type;
            const uint8_t* in   = info->pk.rsa.in;
            word32 in_len       = info->pk.rsa.inLen;
            uint8_t* out        = info->pk.rsa.out;
            word32* out_len     = info->pk.rsa.outLen;

            uint16_t len = 0;
            if(out_len != NULL) {
                len = *out_len;
            }

            ret = wh_Client_RsaFunction(ctx,
                    rsa, rsa_type, in, in_len,
                    out, &len);

            /* Propagate updated length on BUFFER_SIZE so callers can re-call
             * with a sufficiently large output buffer. */
            if (((ret == WH_ERROR_OK) || (ret == WH_ERROR_BUFFER_SIZE)) &&
                (out_len != NULL)) {
                *out_len = len;
            }
        } break;

        case WC_PK_TYPE_RSA_GET_SIZE:
        {
            /* Extract info parameters */
            const RsaKey* rsa   = info->pk.rsa_get_size.key;
            int* out_size       = info->pk.rsa_get_size.keySize;

            ret = wh_Client_RsaGetSize(ctx, rsa, out_size);
        } break;

#endif /* !NO_RSA */

#ifdef HAVE_ECC
#ifdef HAVE_ECC_DHE
        case WC_PK_TYPE_EC_KEYGEN:
        {
            /* Extract info parameters */
            ecc_key* key        = info->pk.eckg.key;
            uint32_t size       = info->pk.eckg.size;
            uint32_t curve_id   = info->pk.eckg.curveId;

            ret = wh_Client_EccMakeExportKey(ctx, size, curve_id, key);
        } break;

        case WC_PK_TYPE_ECDH:
        {
            /* Extract info parameters */
            ecc_key* priv_key   = info->pk.ecdh.private_key;
            ecc_key* pub_key    = info->pk.ecdh.public_key;
            uint8_t* out        = info->pk.ecdh.out;
            word32* out_len     = info->pk.ecdh.outlen;

            uint16_t len = 0;
            if(out_len != NULL) {
                len = *out_len;
            }

            ret = wh_Client_EccSharedSecret(ctx,
                                            priv_key, pub_key,
                                            out, &len);
            /* Propagate updated length on BUFFER_SIZE so callers can re-call
             * with a sufficiently large output buffer. */
            if (((ret == WH_ERROR_OK) || (ret == WH_ERROR_BUFFER_SIZE)) &&
                (out_len != NULL)) {
                *out_len = len;
            }
        } break;
#endif /* HAVE_ECC_DHE */

#ifdef HAVE_ECC_SIGN
        case WC_PK_TYPE_ECDSA_SIGN:
        {
            /* Extract info parameters */
            ecc_key* key        = info->pk.eccsign.key;
            const uint8_t* hash = (const uint8_t*)info->pk.eccsign.in;
            uint16_t hash_len   = (uint16_t)info->pk.eccsign.inlen;
            uint8_t* sig        = (uint8_t*)info->pk.eccsign.out;
            word32* out_sig_len = info->pk.eccsign.outlen;

            uint16_t sig_len = 0;
            if(out_sig_len != NULL) {
                sig_len = (uint16_t)(*out_sig_len);
            }

            ret = wh_Client_EccSign(ctx, key, hash, hash_len, sig, &sig_len);
            /* Propagate updated length on BUFFER_SIZE so callers can re-call
             * with a sufficiently large output buffer. */
            if (((ret == WH_ERROR_OK) || (ret == WH_ERROR_BUFFER_SIZE)) &&
                (out_sig_len != NULL)) {
                *out_sig_len = sig_len;
            }
        } break;
#endif /* HAVE_ECC_SIGN */

#ifdef HAVE_ECC_VERIFY
        case WC_PK_TYPE_ECDSA_VERIFY:
        {
            /* Extract info parameters */
            ecc_key* key        = info->pk.eccverify.key;
            const uint8_t* sig  = (const uint8_t*)info->pk.eccverify.sig;
            uint16_t sig_len    = (uint16_t)info->pk.eccverify.siglen;
            const uint8_t* hash = (const uint8_t*)info->pk.eccverify.hash;
            uint16_t hash_len   = (uint16_t)info->pk.eccverify.hashlen;
            int* out_res        = info->pk.eccverify.res;

            ret = wh_Client_EccVerify(ctx, key, sig, sig_len, hash, hash_len,
                    out_res);
        } break;
#endif /* HAVE_ECC_VERIFY */

        case WC_PK_TYPE_EC_MAKE_PUB: {
            /* Extract info parameters */
            ecc_key* key         = info->pk.ecc_make_pub.key;
            uint8_t* pub_out     = (uint8_t*)info->pk.ecc_make_pub.pubOut;
            word32*  out_pub_len = info->pk.ecc_make_pub.pubOutSz;

            uint16_t pub_len = 0;
            if (out_pub_len != NULL) {
                /* Clamp rather than truncate: an oversized capacity must not
                 * wrap to a small one and provoke a spurious BUFFER_E. */
                pub_len = (*out_pub_len > UINT16_MAX)
                              ? UINT16_MAX
                              : (uint16_t)(*out_pub_len);
            }

            ret = wh_Client_EccMakePub(ctx, key, pub_out, &pub_len);
            /* Propagate updated length on BUFFER_SIZE so callers can re-call
             * with a sufficiently large output buffer. */
            if (((ret == WH_ERROR_OK) || (ret == WH_ERROR_BUFFER_SIZE)) &&
                (out_pub_len != NULL)) {
                *out_pub_len = pub_len;
            }
            if (ret == WH_ERROR_BADARGS) {
                ret = BAD_FUNC_ARG;
            }
            else if (ret == WH_ERROR_BUFFER_SIZE) {
                ret = BUFFER_E;
            }
        } break;

#ifdef HAVE_ECC_CHECK_KEY
        case WC_PK_TYPE_EC_CHECK_PUB_KEY: {
            /* Extract info parameters */
            ecc_key*       key = info->pk.ecc_check_pub.key;
            const uint8_t* pub_key =
                (const uint8_t*)info->pk.ecc_check_pub.pubKey;
            word32 pub_key_len = info->pk.ecc_check_pub.pubKeySz;
            int    check_order = info->pk.ecc_check_pub.checkOrder;
            int    check_priv  = info->pk.ecc_check_pub.checkPriv;

            if (pub_key_len > UINT16_MAX) {
                ret = BAD_FUNC_ARG;
            }
            else {
                ret = wh_Client_EccCheckPubKey(ctx, key, pub_key,
                                               (uint16_t)pub_key_len,
                                               check_order, check_priv);
                if (ret == WH_ERROR_BADARGS) {
                    ret = BAD_FUNC_ARG;
                }
            }
        } break;

        case WC_PK_TYPE_EC_CHECK_PRIV_KEY: {
            ret = CRYPTOCB_UNAVAILABLE;
        } break;
#endif /* HAVE_ECC_CHECK_KEY */

#endif /* HAVE_ECC */

#ifdef HAVE_CURVE25519
        case WC_PK_TYPE_CURVE25519_KEYGEN:
        {
            /* Extract info parameters */
            curve25519_key* key = info->pk.curve25519kg.key;
            uint16_t size       = info->pk.curve25519kg.size;

            ret = wh_Client_Curve25519MakeExportKey(ctx, size, key);
        } break;

        case WC_PK_TYPE_CURVE25519:
        {
            /* Extract info parameters */
            curve25519_key* pub_key     = info->pk.curve25519.public_key;
            curve25519_key* priv_key    = info->pk.curve25519.private_key;
            int endian                  = info->pk.curve25519.endian;
            uint8_t* out                = info->pk.curve25519.out;
            word32* out_len             = info->pk.curve25519.outlen;
            uint16_t len                = 0;

            if(out_len != NULL) {
                len = *out_len;
            }

            ret = wh_Client_Curve25519SharedSecret(ctx,
                                            priv_key, pub_key,
                                            endian,
                                            out, &len);
            /* Propagate updated length on BUFFER_SIZE so callers can re-call
             * with a sufficiently large output buffer. */
            if (((ret == WH_ERROR_OK) || (ret == WH_ERROR_BUFFER_SIZE)) &&
                (out_len != NULL)) {
                *out_len = len;
            }
        } break;
#endif /* HAVE_CURVE25519 */

#ifdef HAVE_ED25519
        case WC_PK_TYPE_ED25519_KEYGEN: {
            ed25519_key* key = info->pk.ed25519kg.key;
            /* Only default Ed25519 supported */
            ret = wh_Client_Ed25519MakeExportKey(ctx, key);
            if (ret == WH_ERROR_BADARGS) {
                ret = BAD_FUNC_ARG;
            }
        } break;

        case WC_PK_TYPE_ED25519_SIGN: {
            ed25519_key*   key    = info->pk.ed25519sign.key;
            const uint8_t* in     = (const uint8_t*)info->pk.ed25519sign.in;
            uint32_t       inLen  = info->pk.ed25519sign.inLen;
            uint8_t*       out    = info->pk.ed25519sign.out;
            word32*        outLen = info->pk.ed25519sign.outLen;
            uint8_t        type   = info->pk.ed25519sign.type;
            uint32_t       len;

            len = 0;
            if (outLen != NULL) {
                len = *outLen;
            }
            ret = wh_Client_Ed25519Sign(
                ctx, key, in, inLen, type, info->pk.ed25519sign.context,
                info->pk.ed25519sign.contextLen, out, &len);
            /* Propagate updated length on BUFFER_SIZE so callers can re-call
             * with a sufficiently large output buffer. */
            if (((ret == WH_ERROR_OK) || (ret == WH_ERROR_BUFFER_SIZE)) &&
                (outLen != NULL)) {
                *outLen = len;
            }
            if (ret == WH_ERROR_BADARGS) {
                ret = BAD_FUNC_ARG;
            }
            else if (ret == WH_ERROR_NOTIMPL) {
                ret = CRYPTOCB_UNAVAILABLE;
            }
        } break;

        case WC_PK_TYPE_ED25519_VERIFY: {
            ed25519_key*   key    = info->pk.ed25519verify.key;
            const uint8_t* sig    = info->pk.ed25519verify.sig;
            uint32_t       sigLen = info->pk.ed25519verify.sigLen;
            const uint8_t* msg    = info->pk.ed25519verify.msg;
            uint32_t       msgLen = info->pk.ed25519verify.msgLen;
            int*           res    = info->pk.ed25519verify.res;
            uint8_t        type   = info->pk.ed25519verify.type;

            ret =
                wh_Client_Ed25519Verify(ctx, key, sig, sigLen, msg, msgLen,
                                        type, info->pk.ed25519verify.context,
                                        info->pk.ed25519verify.contextLen, res);
            if (ret == WH_ERROR_BADARGS) {
                ret = BAD_FUNC_ARG;
            }
            else if (ret == WH_ERROR_NOTIMPL) {
                ret = CRYPTOCB_UNAVAILABLE;
            }
        } break;
#endif /* HAVE_ED25519 */

#if defined(WOLFSSL_HAVE_MLKEM)
        case WC_PK_TYPE_PQC_KEM_KEYGEN:
            ret = _handlePqcKemKeyGen(ctx, info, 0);
            break;

        case WC_PK_TYPE_PQC_KEM_ENCAPS:
            ret = _handlePqcEncaps(ctx, info, 0);
            break;

        case WC_PK_TYPE_PQC_KEM_DECAPS:
            ret = _handlePqcDecaps(ctx, info, 0);
            break;

#endif /* WOLFSSL_HAVE_MLKEM */
#if defined(WOLFSSL_HAVE_LMS) || defined(WOLFSSL_HAVE_XMSS)
        case WC_PK_TYPE_PQC_STATEFUL_SIG_KEYGEN:
            ret = _handlePqcStatefulSigKeyGen(ctx, info, 0);
            break;

        case WC_PK_TYPE_PQC_STATEFUL_SIG_SIGN:
            ret = _handlePqcStatefulSigSign(ctx, info, 0);
            break;

        case WC_PK_TYPE_PQC_STATEFUL_SIG_VERIFY:
            ret = _handlePqcStatefulSigVerify(ctx, info, 0);
            break;

        case WC_PK_TYPE_PQC_STATEFUL_SIG_SIGS_LEFT:
            ret = _handlePqcStatefulSigSigsLeft(ctx, info, 0);
            break;

#endif /* WOLFSSL_HAVE_LMS || WOLFSSL_HAVE_XMSS */

#if defined(WOLFSSL_SM2) && defined(HAVE_ECC)
        case WC_PK_TYPE_SM2_SIGN: {
            ecc_key*    key      = info->pk.sm2sign.key;
            const byte* in       = info->pk.sm2sign.in;
            word32      in_len   = info->pk.sm2sign.inlen;
            byte*       out      = info->pk.sm2sign.out;
            word32*     out_len  = info->pk.sm2sign.outlen;
            uint16_t    sig_len  = 0;

            /* Convert to a uint16_t local to support big endian. Saturate
             * rather than truncate: a capacity of 65536 would otherwise wrap
             * to zero and fail a request the output easily fits. */
            if (out_len != NULL) {
                sig_len = (*out_len > UINT16_MAX) ? UINT16_MAX
                                                  : (uint16_t)(*out_len);
            }

            if (in_len > UINT16_MAX) {
                ret = WH_ERROR_BADARGS;
            }
            else {
                ret = wh_Client_Sm2Sign(ctx, key, in, (uint16_t)in_len, out,
                                        &sig_len);
                /* Propagate the required length on BUFFER_SIZE so the caller
                 * can retry with a large enough buffer. */
                if (((ret == WH_ERROR_OK) || (ret == WH_ERROR_BUFFER_SIZE)) &&
                    (out_len != NULL)) {
                    *out_len = sig_len;
                }
            }
        } break;

        case WC_PK_TYPE_SM2_VERIFY: {
            word32 sig_len  = info->pk.sm2verify.siglen;
            word32 hash_len = info->pk.sm2verify.hashlen;

            if ((sig_len > UINT16_MAX) || (hash_len > UINT16_MAX)) {
                ret = WH_ERROR_BADARGS;
            }
            else {
                ret = wh_Client_Sm2Verify(
                    ctx, info->pk.sm2verify.key, info->pk.sm2verify.sig,
                    (uint16_t)sig_len, info->pk.sm2verify.hash,
                    (uint16_t)hash_len, info->pk.sm2verify.res);
            }
        } break;

        case WC_PK_TYPE_SM2_SHARED_SECRET: {
            word32*  out_len = info->pk.sm2dh.outlen;
            uint16_t sec_len = 0;

            /* Saturate rather than truncate, as above. */
            if (out_len != NULL) {
                sec_len = (*out_len > UINT16_MAX) ? UINT16_MAX
                                                  : (uint16_t)(*out_len);
            }

            ret = wh_Client_Sm2SharedSecret(ctx, info->pk.sm2dh.private_key,
                                            info->pk.sm2dh.public_key,
                                            info->pk.sm2dh.out, &sec_len);
            if (((ret == WH_ERROR_OK) || (ret == WH_ERROR_BUFFER_SIZE)) &&
                (out_len != NULL)) {
                *out_len = sec_len;
            }
        } break;
#endif /* WOLFSSL_SM2 && HAVE_ECC */

#if defined(WOLFSSL_HAVE_MLDSA) || defined(HAVE_FALCON)
        case WC_PK_TYPE_PQC_SIG_KEYGEN:
            ret = _handlePqcSigKeyGen(ctx, info, 0);
            break;

        case WC_PK_TYPE_PQC_SIG_SIGN:
            ret = _handlePqcSign(ctx, info, 0);
            break;

        case WC_PK_TYPE_PQC_SIG_VERIFY:
            ret = _handlePqcVerify(ctx, info, 0);
            break;

        case WC_PK_TYPE_PQC_SIG_CHECK_PRIV_KEY:
            ret = _handlePqcSigCheckPrivKey(ctx, info, 0);
            break;

#endif /* WOLFSSL_HAVE_MLDSA || HAVE_FALCON */

        case WC_PK_TYPE_NONE:
        default:
            ret = CRYPTOCB_UNAVAILABLE;
            break;
        }
        break;

#ifndef WC_NO_RNG
    case WC_ALGO_TYPE_RNG:
    {
        /* Extract info parameters */
        uint8_t* out = info->rng.out;
        uint32_t size = info->rng.sz;

        ret = wh_Client_RngGenerate(ctx, out, size);
    } break;
    case WC_ALGO_TYPE_SEED: {
        /* Extract info parameters */
        uint8_t* seed = info->seed.seed;
        uint32_t size = info->seed.sz;

        ret = wh_Client_RngGenerate(ctx, seed, size);
    } break;
#endif /* !WC_NO_RNG */

#ifdef WOLFSSL_CMAC
    case WC_ALGO_TYPE_CMAC:
    {
        /* Extract info parameters */
        const uint8_t* in          = info->cmac.in;
        uint32_t       in_len      = (in == NULL) ? 0 : info->cmac.inSz;
        const uint8_t* key         = info->cmac.key;
        uint32_t       key_len     = (key == NULL) ? 0 : info->cmac.keySz;
        uint8_t*       outMac      = info->cmac.out;
        uint32_t*      out_mac_len = (uint32_t*)info->cmac.outSz;
        Cmac*          cmac        = info->cmac.cmac;
        int            type        = info->cmac.type;

        ret = wh_Client_Cmac(ctx, cmac, type, key, key_len, in, in_len, outMac,
                             out_mac_len);
    } break; /* case WC_ALGO_TYPE_CMAC */

#endif /* WOLFSSL_CMAC */

    case WC_ALGO_TYPE_HASH: {
        switch (info->hash.type) {
#ifndef NO_SHA256
            case WC_HASH_TYPE_SHA256: {
                wc_Sha256*     sha   = info->hash.sha256;
                const uint8_t* in    = info->hash.in;
                uint32_t       inLen = info->hash.inSz;
                uint8_t*       out   = info->hash.digest;

                ret = wh_Client_Sha256(ctx, sha, in, inLen, out);
            } break;
#endif /* !NO_SHA256 */
#ifdef WOLFSSL_SHA224
            case WC_HASH_TYPE_SHA224: {
                wc_Sha224*     sha   = info->hash.sha224;
                const uint8_t* in    = info->hash.in;
                uint32_t       inLen = info->hash.inSz;
                uint8_t*       out   = info->hash.digest;

                ret = wh_Client_Sha224(ctx, sha, in, inLen, out);
            } break;
#endif /* WOLFSSL_SHA224 */
#ifdef WOLFSSL_SHA384
            case WC_HASH_TYPE_SHA384: {
                wc_Sha384*     sha   = info->hash.sha384;
                const uint8_t* in    = info->hash.in;
                uint32_t       inLen = info->hash.inSz;
                uint8_t*       out   = info->hash.digest;

                ret = wh_Client_Sha384(ctx, sha, in, inLen, out);
            } break;
#endif /* WOLFSSL_SHA384 */
#if defined(WOLFSSL_SHA512) && defined(WOLFSSL_SHA512_HASHTYPE)
            case WC_HASH_TYPE_SHA512: {
                wc_Sha512*     sha   = info->hash.sha512;
                const uint8_t* in    = info->hash.in;
                uint32_t       inLen = info->hash.inSz;
                uint8_t*       out   = info->hash.digest;

                ret = wh_Client_Sha512(ctx, sha, in, inLen, out);
            } break;
#endif /* WOLFSSL_SHA512 && WOLFSSL_SHA512_HASHTYPE */
#if defined(WOLFSSL_SHA3)
            case WC_HASH_TYPE_SHA3_224:
            case WC_HASH_TYPE_SHA3_256:
            case WC_HASH_TYPE_SHA3_384:
            case WC_HASH_TYPE_SHA3_512: {
                wc_Sha3* sha = info->hash.sha3;
#ifdef WOLFSSL_HASH_FLAGS
                /* Keccak-mode SHA3 (legacy 0x01-padding variant) is a software-
                 * only mode; fall through to wolfCrypt's software path. */
                if (sha != NULL &&
                    (sha->flags & WC_HASH_SHA3_KECCAK256) != 0u) {
                    ret = CRYPTOCB_UNAVAILABLE;
                    break;
                }
#endif
                switch (info->hash.type) {
#ifndef WOLFSSL_NOSHA3_224
                    case WC_HASH_TYPE_SHA3_224:
                        ret = wh_Client_Sha3_224(ctx, sha, info->hash.in,
                                                 info->hash.inSz,
                                                 info->hash.digest);
                        break;
#endif
#ifndef WOLFSSL_NOSHA3_256
                    case WC_HASH_TYPE_SHA3_256:
                        ret = wh_Client_Sha3_256(ctx, sha, info->hash.in,
                                                 info->hash.inSz,
                                                 info->hash.digest);
                        break;
#endif
#ifndef WOLFSSL_NOSHA3_384
                    case WC_HASH_TYPE_SHA3_384:
                        ret = wh_Client_Sha3_384(ctx, sha, info->hash.in,
                                                 info->hash.inSz,
                                                 info->hash.digest);
                        break;
#endif
#ifndef WOLFSSL_NOSHA3_512
                    case WC_HASH_TYPE_SHA3_512:
                        ret = wh_Client_Sha3_512(ctx, sha, info->hash.in,
                                                 info->hash.inSz,
                                                 info->hash.digest);
                        break;
#endif
                }
            } break;
#endif /* WOLFSSL_SHA3 */
            default:
                ret = CRYPTOCB_UNAVAILABLE;
                break;
        }
    } break; /* case WC_ALGO_TYPE_HASH */

#if defined(HAVE_HKDF) || defined(HAVE_CMAC_KDF)
    case WC_ALGO_TYPE_KDF: {
        /* Handle different KDF types */
        switch (info->kdf.type) {
#ifdef HAVE_HKDF
            case WC_KDF_TYPE_HKDF: {
                /* Extract HKDF-specific parameters */
                int         hashType = info->kdf.hkdf.hashType;
                const byte* inKey    = info->kdf.hkdf.inKey;
                word32      inKeySz  = info->kdf.hkdf.inKeySz;
                const byte* salt     = info->kdf.hkdf.salt;
                word32      saltSz   = info->kdf.hkdf.saltSz;
                const byte* kdf_info = info->kdf.hkdf.info;
                word32      infoSz   = info->kdf.hkdf.infoSz;
                byte*       out      = info->kdf.hkdf.out;
                word32      outSz    = info->kdf.hkdf.outSz;

                ret = wh_Client_HkdfMakeExportKey(
                    ctx, hashType, WH_KEYID_ERASED, inKey, inKeySz, salt,
                    saltSz, kdf_info, infoSz, out, outSz);
            } break;
#endif /* HAVE_HKDF */
#ifdef HAVE_CMAC_KDF
            case WC_KDF_TYPE_TWOSTEP_CMAC: {
                const byte* salt        = info->kdf.twostep_cmac.salt;
                word32      saltSz      = info->kdf.twostep_cmac.saltSz;
                const byte* z           = info->kdf.twostep_cmac.z;
                word32      zSz         = info->kdf.twostep_cmac.zSz;
                const byte* fixedInfo   = info->kdf.twostep_cmac.fixedInfo;
                word32      fixedInfoSz = info->kdf.twostep_cmac.fixedInfoSz;
                byte*       out         = info->kdf.twostep_cmac.out;
                word32      outSz       = info->kdf.twostep_cmac.outSz;

                ret = wh_Client_CmacKdfMakeExportKey(
                    ctx, WH_KEYID_ERASED, salt, saltSz, WH_KEYID_ERASED, z, zSz,
                    fixedInfo, fixedInfoSz, out, outSz);
            } break;
#endif /* HAVE_CMAC_KDF */
            default:
                ret = CRYPTOCB_UNAVAILABLE;
                break;
        }
    } break; /* case WC_ALGO_TYPE_KDF */
#endif       /* HAVE_HKDF || HAVE_CMAC_KDF */

    case WC_ALGO_TYPE_NONE:
    default:
        ret = CRYPTOCB_UNAVAILABLE;
        break;
    }

    /* Fix up error code to be wolfCrypt */
    if (ret == WH_ERROR_BADARGS) {
        ret = BAD_FUNC_ARG;
    }
    else if (ret == WH_ERROR_BUFFER_SIZE) {
        ret = BUFFER_E;
    }

    if (ret == CRYPTOCB_UNAVAILABLE) {
        WH_DEBUG_CLIENT("X not implemented: algo->type:%d\n", info->algo_type);
    } else {
        WH_DEBUG_CLIENT("ret:%d algo->type:%d\n", ret, info->algo_type);
    }
    return ret;
}

#if defined(WOLFSSL_HAVE_MLKEM)
static int _handlePqcKemKeyGen(whClientContext* ctx, wc_CryptoInfo* info,
                               int useDma)
{
    int ret = CRYPTOCB_UNAVAILABLE;

    /* Extract info parameters */
    int   size = info->pk.pqc_kem_kg.size;
    void* key  = info->pk.pqc_kem_kg.key;
    int   type = info->pk.pqc_kem_kg.type;

#ifndef WOLFHSM_CFG_DMA
    if (useDma) {
        /* DMA support not available - user passed wrong devId */
        return WC_HW_E;
    }
#endif

    (void)size;

    switch (type) {
        case WC_PQC_KEM_TYPE_KYBER: {
            int level = ((MlKemKey*)key)->type;
#ifdef WOLFHSM_CFG_DMA
            if (useDma) {
                ret = wh_Client_MlKemMakeExportKeyDma(ctx, level, key);
            }
            else
#endif /* WOLFHSM_CFG_DMA */
            {
                ret = wh_Client_MlKemMakeExportKey(ctx, level, key);
            }
        } break;

        default:
            ret = CRYPTOCB_UNAVAILABLE;
            break;
    }

    if (ret == WH_ERROR_BADARGS) {
        ret = BAD_FUNC_ARG;
    }
    else if (ret == WH_ERROR_NOTIMPL) {
        ret = CRYPTOCB_UNAVAILABLE;
    }

    return ret;
}

static int _handlePqcEncaps(whClientContext* ctx, wc_CryptoInfo* info,
                            int useDma)
{
    int ret = CRYPTOCB_UNAVAILABLE;

    /* Extract info parameters */
    byte*  ciphertext    = info->pk.pqc_encaps.ciphertext;
    word32 ciphertextLen = info->pk.pqc_encaps.ciphertextLen;
    byte*  sharedSecret  = info->pk.pqc_encaps.sharedSecret;
    word32 sharedSecLen  = info->pk.pqc_encaps.sharedSecretLen;
    void*  key           = info->pk.pqc_encaps.key;
    int    type          = info->pk.pqc_encaps.type;

#ifndef WOLFHSM_CFG_DMA
    if (useDma) {
        /* DMA support not available - user passed wrong devId */
        return WC_HW_E;
    }
#endif

    switch (type) {
        case WC_PQC_KEM_TYPE_KYBER:
#ifdef WOLFHSM_CFG_DMA
            if (useDma) {
                ret = wh_Client_MlKemEncapsulateDma(ctx, key, ciphertext,
                                                    &ciphertextLen,
                                                    sharedSecret, &sharedSecLen);
            }
            else
#endif /* WOLFHSM_CFG_DMA */
            {
                ret = wh_Client_MlKemEncapsulate(ctx, key, ciphertext,
                                                 &ciphertextLen, sharedSecret,
                                                 &sharedSecLen);
            }
            if (ret == WH_ERROR_OK) {
                info->pk.pqc_encaps.ciphertextLen = ciphertextLen;
                info->pk.pqc_encaps.sharedSecretLen = sharedSecLen;
            }
            break;

        default:
            ret = CRYPTOCB_UNAVAILABLE;
            break;
    }

    if (ret == WH_ERROR_BADARGS) {
        ret = BAD_FUNC_ARG;
    }
    else if (ret == WH_ERROR_NOTIMPL) {
        ret = CRYPTOCB_UNAVAILABLE;
    }

    return ret;
}

static int _handlePqcDecaps(whClientContext* ctx, wc_CryptoInfo* info,
                            int useDma)
{
    int ret = CRYPTOCB_UNAVAILABLE;

    /* Extract info parameters */
    const byte* ciphertext    = info->pk.pqc_decaps.ciphertext;
    word32      ciphertextLen = info->pk.pqc_decaps.ciphertextLen;
    byte*       sharedSecret  = info->pk.pqc_decaps.sharedSecret;
    word32      sharedSecLen  = info->pk.pqc_decaps.sharedSecretLen;
    void*       key           = info->pk.pqc_decaps.key;
    int         type          = info->pk.pqc_decaps.type;

#ifndef WOLFHSM_CFG_DMA
    if (useDma) {
        /* DMA support not available - user passed wrong devId */
        return WC_HW_E;
    }
#endif

    switch (type) {
        case WC_PQC_KEM_TYPE_KYBER:
#ifdef WOLFHSM_CFG_DMA
            if (useDma) {
                ret = wh_Client_MlKemDecapsulateDma(
                    ctx, key, ciphertext, ciphertextLen, sharedSecret,
                    &sharedSecLen);
            }
            else
#endif /* WOLFHSM_CFG_DMA */
            {
                ret = wh_Client_MlKemDecapsulate(ctx, key, ciphertext,
                                                 ciphertextLen, sharedSecret,
                                                 &sharedSecLen);
            }
            if (ret == WH_ERROR_OK) {
                info->pk.pqc_decaps.sharedSecretLen = sharedSecLen;
            }
            break;

        default:
            ret = CRYPTOCB_UNAVAILABLE;
            break;
    }

    if (ret == WH_ERROR_BADARGS) {
        ret = BAD_FUNC_ARG;
    }
    else if (ret == WH_ERROR_NOTIMPL) {
        ret = CRYPTOCB_UNAVAILABLE;
    }

    return ret;
}
#endif /* WOLFSSL_HAVE_MLKEM */

#if defined(WOLFSSL_HAVE_LMS) || defined(WOLFSSL_HAVE_XMSS)
static int _handlePqcStatefulSigKeyGen(whClientContext* ctx,
                                       wc_CryptoInfo* info, int useDma)
{
    int ret = CRYPTOCB_UNAVAILABLE;
    int type = info->pk.pqc_stateful_sig_kg.type;

    /* Unused when all enabled algorithms are verify-only (no keygen path). */
    (void)ctx;
    (void)useDma;

#ifndef WOLFHSM_CFG_DMA
    if (useDma) {
        return WC_HW_E;
    }
#endif

    switch (type) {
#if defined(WOLFSSL_HAVE_LMS) && !defined(WOLFSSL_LMS_VERIFY_ONLY)
        case WC_PQC_STATEFUL_SIG_TYPE_LMS:
#ifdef WOLFHSM_CFG_DMA
            if (useDma) {
                ret = wh_Client_LmsMakeExportKeyDma(
                    ctx, (LmsKey*)info->pk.pqc_stateful_sig_kg.key);
            }
            else
#endif /* WOLFHSM_CFG_DMA */
            {
                /* Non-DMA transport not supported in v1; signatures exceed the
                 * default WOLFHSM_CFG_COMM_DATA_LEN. */
                ret = CRYPTOCB_UNAVAILABLE;
            }
            break;
#endif /* WOLFSSL_HAVE_LMS && !WOLFSSL_LMS_VERIFY_ONLY */
#if defined(WOLFSSL_HAVE_XMSS) && !defined(WOLFSSL_XMSS_VERIFY_ONLY)
        case WC_PQC_STATEFUL_SIG_TYPE_XMSS:
#ifdef WOLFHSM_CFG_DMA
            if (useDma) {
                ret = wh_Client_XmssMakeExportKeyDma(
                    ctx, (XmssKey*)info->pk.pqc_stateful_sig_kg.key);
            }
            else
#endif /* WOLFHSM_CFG_DMA */
            {
                ret = CRYPTOCB_UNAVAILABLE;
            }
            break;
#endif /* WOLFSSL_HAVE_XMSS && !WOLFSSL_XMSS_VERIFY_ONLY */

        default:
            ret = CRYPTOCB_UNAVAILABLE;
            break;
    }

    if (ret == WH_ERROR_BADARGS) {
        ret = BAD_FUNC_ARG;
    }
    else if (ret == WH_ERROR_NOTIMPL) {
        ret = CRYPTOCB_UNAVAILABLE;
    }

    return ret;
}

static int _handlePqcStatefulSigSign(whClientContext* ctx, wc_CryptoInfo* info,
                                     int useDma)
{
    int ret  = CRYPTOCB_UNAVAILABLE;
    int type = info->pk.pqc_stateful_sig_sign.type;

    /* Unused when all enabled algorithms are verify-only (no sign path). */
    (void)ctx;
    (void)useDma;

#ifndef WOLFHSM_CFG_DMA
    if (useDma) {
        return WC_HW_E;
    }
#endif

    switch (type) {
#if defined(WOLFSSL_HAVE_LMS) && !defined(WOLFSSL_LMS_VERIFY_ONLY)
        case WC_PQC_STATEFUL_SIG_TYPE_LMS:
#ifdef WOLFHSM_CFG_DMA
            if (useDma) {
                ret = wh_Client_LmsSignDma(
                    ctx,
                    info->pk.pqc_stateful_sig_sign.msg,
                    info->pk.pqc_stateful_sig_sign.msgSz,
                    info->pk.pqc_stateful_sig_sign.out,
                    info->pk.pqc_stateful_sig_sign.outSz,
                    (LmsKey*)info->pk.pqc_stateful_sig_sign.key);
            }
            else
#endif /* WOLFHSM_CFG_DMA */
            {
                ret = CRYPTOCB_UNAVAILABLE;
            }
            break;
#endif /* WOLFSSL_HAVE_LMS && !WOLFSSL_LMS_VERIFY_ONLY */
#if defined(WOLFSSL_HAVE_XMSS) && !defined(WOLFSSL_XMSS_VERIFY_ONLY)
        case WC_PQC_STATEFUL_SIG_TYPE_XMSS:
#ifdef WOLFHSM_CFG_DMA
            if (useDma) {
                ret = wh_Client_XmssSignDma(
                    ctx,
                    info->pk.pqc_stateful_sig_sign.msg,
                    info->pk.pqc_stateful_sig_sign.msgSz,
                    info->pk.pqc_stateful_sig_sign.out,
                    info->pk.pqc_stateful_sig_sign.outSz,
                    (XmssKey*)info->pk.pqc_stateful_sig_sign.key);
            }
            else
#endif /* WOLFHSM_CFG_DMA */
            {
                ret = CRYPTOCB_UNAVAILABLE;
            }
            break;
#endif /* WOLFSSL_HAVE_XMSS && !WOLFSSL_XMSS_VERIFY_ONLY */

        default:
            ret = CRYPTOCB_UNAVAILABLE;
            break;
    }

    if (ret == WH_ERROR_BADARGS) {
        ret = BAD_FUNC_ARG;
    }
    else if (ret == WH_ERROR_NOTIMPL) {
        ret = CRYPTOCB_UNAVAILABLE;
    }

    return ret;
}

static int _handlePqcStatefulSigVerify(whClientContext* ctx,
                                       wc_CryptoInfo* info, int useDma)
{
    int ret  = CRYPTOCB_UNAVAILABLE;
    int type = info->pk.pqc_stateful_sig_verify.type;

#ifndef WOLFHSM_CFG_DMA
    (void)ctx;
    if (useDma) {
        return WC_HW_E;
    }
#endif

    switch (type) {
#ifdef WOLFSSL_HAVE_LMS
        case WC_PQC_STATEFUL_SIG_TYPE_LMS:
#ifdef WOLFHSM_CFG_DMA
            if (useDma) {
                ret = wh_Client_LmsVerifyDma(
                    ctx,
                    info->pk.pqc_stateful_sig_verify.sig,
                    info->pk.pqc_stateful_sig_verify.sigSz,
                    info->pk.pqc_stateful_sig_verify.msg,
                    info->pk.pqc_stateful_sig_verify.msgSz,
                    info->pk.pqc_stateful_sig_verify.res,
                    (LmsKey*)info->pk.pqc_stateful_sig_verify.key);
            }
            else
#endif /* WOLFHSM_CFG_DMA */
            {
                ret = CRYPTOCB_UNAVAILABLE;
            }
            break;
#endif /* WOLFSSL_HAVE_LMS */
#ifdef WOLFSSL_HAVE_XMSS
        case WC_PQC_STATEFUL_SIG_TYPE_XMSS:
#ifdef WOLFHSM_CFG_DMA
            if (useDma) {
                ret = wh_Client_XmssVerifyDma(
                    ctx,
                    info->pk.pqc_stateful_sig_verify.sig,
                    info->pk.pqc_stateful_sig_verify.sigSz,
                    info->pk.pqc_stateful_sig_verify.msg,
                    info->pk.pqc_stateful_sig_verify.msgSz,
                    info->pk.pqc_stateful_sig_verify.res,
                    (XmssKey*)info->pk.pqc_stateful_sig_verify.key);
            }
            else
#endif /* WOLFHSM_CFG_DMA */
            {
                ret = CRYPTOCB_UNAVAILABLE;
            }
            break;
#endif /* WOLFSSL_HAVE_XMSS */

        default:
            ret = CRYPTOCB_UNAVAILABLE;
            break;
    }

    if (ret == WH_ERROR_BADARGS) {
        ret = BAD_FUNC_ARG;
    }
    else if (ret == WH_ERROR_NOTIMPL) {
        ret = CRYPTOCB_UNAVAILABLE;
    }

    return ret;
}

static int _handlePqcStatefulSigSigsLeft(whClientContext* ctx,
                                         wc_CryptoInfo* info, int useDma)
{
    int ret  = CRYPTOCB_UNAVAILABLE;
    int type = info->pk.pqc_stateful_sig_sigs_left.type;

    /* Unused when all enabled algorithms are verify-only (no sigsLeft path). */
    (void)ctx;
    (void)useDma;

#ifndef WOLFHSM_CFG_DMA
    if (useDma) {
        return WC_HW_E;
    }
#endif

    switch (type) {
#if defined(WOLFSSL_HAVE_LMS) && !defined(WOLFSSL_LMS_VERIFY_ONLY)
        case WC_PQC_STATEFUL_SIG_TYPE_LMS:
#ifdef WOLFHSM_CFG_DMA
            if (useDma) {
                /* ret is the error code if negative, otherwise a boolean */
                ret = wh_Client_LmsSigsLeftDma(
                    ctx, (LmsKey*)info->pk.pqc_stateful_sig_sigs_left.key);
                if (ret >= 0) {
                    *(info->pk.pqc_stateful_sig_sigs_left.sigsLeft) =
                        (word32)ret;
                    ret = WH_ERROR_OK;
                }
            }
            else
#endif /* WOLFHSM_CFG_DMA */
            {
                ret = CRYPTOCB_UNAVAILABLE;
            }
            break;
#endif /* WOLFSSL_HAVE_LMS && !WOLFSSL_LMS_VERIFY_ONLY */
#if defined(WOLFSSL_HAVE_XMSS) && !defined(WOLFSSL_XMSS_VERIFY_ONLY)
        case WC_PQC_STATEFUL_SIG_TYPE_XMSS:
#ifdef WOLFHSM_CFG_DMA
            if (useDma) {
                /* ret is the error code if negative, otherwise a boolean */
                ret = wh_Client_XmssSigsLeftDma(
                    ctx, (XmssKey*)info->pk.pqc_stateful_sig_sigs_left.key);
                if (ret >= 0) {
                    *(info->pk.pqc_stateful_sig_sigs_left.sigsLeft) =
                        (word32)ret;
                    ret = WH_ERROR_OK;
                }
            }
            else
#endif /* WOLFHSM_CFG_DMA */
            {
                ret = CRYPTOCB_UNAVAILABLE;
            }
            break;
#endif /* WOLFSSL_HAVE_XMSS && !WOLFSSL_XMSS_VERIFY_ONLY */

        default:
            ret = CRYPTOCB_UNAVAILABLE;
            break;
    }

    if (ret == WH_ERROR_BADARGS) {
        ret = BAD_FUNC_ARG;
    }
    else if (ret == WH_ERROR_NOTIMPL) {
        ret = CRYPTOCB_UNAVAILABLE;
    }

    return ret;
}
#endif /* WOLFSSL_HAVE_LMS || WOLFSSL_HAVE_XMSS */

#if defined(HAVE_FALCON) || defined(WOLFSSL_HAVE_MLDSA)
static int _handlePqcSigKeyGen(whClientContext* ctx, wc_CryptoInfo* info,
                               int useDma)
{
    int ret = CRYPTOCB_UNAVAILABLE;

    /* Extract info parameters */
    int     size = info->pk.pqc_sig_kg.size;
    void*   key  = info->pk.pqc_sig_kg.key;
    int     type = info->pk.pqc_sig_kg.type;

#ifndef WOLFHSM_CFG_DMA
    if (useDma) {
        /* DMA support not available - user passed wrong devId */
        return WC_HW_E;
    }
#endif

    switch (type) {
#ifdef WOLFSSL_HAVE_MLDSA
        case WC_PQC_SIG_TYPE_MLDSA: {
            int level = ((wc_MlDsaKey*)key)->level;
#ifdef WOLFHSM_CFG_DMA
            if (useDma) {
                ret = wh_Client_MlDsaMakeExportKeyDma(ctx, level, key);
            }
            else
#endif /* WOLFHSM_CFG_DMA */
            {
                ret = wh_Client_MlDsaMakeExportKey(ctx, level, size, key);
            }
        } break;
#endif /* WOLFSSL_HAVE_MLDSA */

        /* Support for additional PQC algorithms should be added here */

        default:
            ret = CRYPTOCB_UNAVAILABLE;
            break;
    }

    return ret;
}

static int _handlePqcSign(whClientContext* ctx, wc_CryptoInfo* info, int useDma)
{
    int ret = CRYPTOCB_UNAVAILABLE;

    /* Extract info parameters */
    const byte* in          = info->pk.pqc_sign.in;
    word32      in_len      = info->pk.pqc_sign.inlen;
    byte*       out         = info->pk.pqc_sign.out;
    word32*     out_len     = info->pk.pqc_sign.outlen;
    void*       key         = info->pk.pqc_sign.key;
    int         type        = info->pk.pqc_sign.type;
    const byte* context     = info->pk.pqc_sign.context;
    byte        contextLen  = info->pk.pqc_sign.contextLen;
    word32      preHashType = info->pk.pqc_sign.preHashType;

#ifndef WOLFHSM_CFG_DMA
    if (useDma) {
        /* DMA support not available - user passed wrong devId */
        return WC_HW_E;
    }
#endif

    switch (type) {
#ifdef WOLFSSL_HAVE_MLDSA
        case WC_PQC_SIG_TYPE_MLDSA:
#ifdef WOLFHSM_CFG_DMA
            if (useDma) {
                ret = wh_Client_MlDsaSignDma(ctx, in, in_len, out, out_len,
                                                key, context, contextLen,
                                                preHashType);
            }
            else
#endif /* WOLFHSM_CFG_DMA */
            {
                ret = wh_Client_MlDsaSign(ctx, in, in_len, out, out_len, key,
                                             context, contextLen, preHashType);
            }
            break;
#endif /* WOLFSSL_HAVE_MLDSA */

        /* Support for additional PQC algorithms should be added here */

        default:
            ret = CRYPTOCB_UNAVAILABLE;
            break;
    }

    return ret;
}

static int _handlePqcVerify(whClientContext* ctx, wc_CryptoInfo* info,
                            int useDma)
{
    int ret = CRYPTOCB_UNAVAILABLE;

    /* Extract info parameters */
    const byte* sig         = info->pk.pqc_verify.sig;
    word32      sig_len     = info->pk.pqc_verify.siglen;
    const byte* msg         = info->pk.pqc_verify.msg;
    word32      msg_len     = info->pk.pqc_verify.msglen;
    int*        res         = info->pk.pqc_verify.res;
    void*       key         = info->pk.pqc_verify.key;
    int         type        = info->pk.pqc_verify.type;
    const byte* context     = info->pk.pqc_verify.context;
    byte        contextLen  = info->pk.pqc_verify.contextLen;
    word32      preHashType = info->pk.pqc_verify.preHashType;

#ifndef WOLFHSM_CFG_DMA
    if (useDma) {
        /* DMA support not available - user passed wrong devId */
        return WC_HW_E;
    }
#endif

    switch (type) {
#ifdef WOLFSSL_HAVE_MLDSA
        case WC_PQC_SIG_TYPE_MLDSA:
#ifdef WOLFHSM_CFG_DMA
            if (useDma) {
                ret = wh_Client_MlDsaVerifyDma(ctx, sig, sig_len, msg, msg_len,
                                                  res, key, context, contextLen,
                                                  preHashType);
            }
            else
#endif /* WOLFHSM_CFG_DMA */
            {
                ret = wh_Client_MlDsaVerify(ctx, sig, sig_len, msg, msg_len,
                                               res, key, context, contextLen,
                                               preHashType);
            }
            break;
#endif /* WOLFSSL_HAVE_MLDSA */

        /* Support for additional PQC algorithms should be added here */

        default:
            ret = CRYPTOCB_UNAVAILABLE;
            break;
    }

    return ret;
}

static int _handlePqcSigCheckPrivKey(whClientContext* ctx, wc_CryptoInfo* info,
                                     int useDma)
{
    int ret = CRYPTOCB_UNAVAILABLE;

    /* Extract info parameters */
    void*       key      = info->pk.pqc_sig_check.key;
    const byte* pubKey   = info->pk.pqc_sig_check.pubKey;
    word32      pubKeySz = info->pk.pqc_sig_check.pubKeySz;
    int         type     = info->pk.pqc_sig_check.type;

#ifndef WOLFHSM_CFG_DMA
    if (useDma) {
        /* DMA support not available - user passed wrong devId */
        return WC_HW_E;
    }
#endif

    switch (type) {
#ifdef WOLFSSL_HAVE_MLDSA
        case WC_PQC_SIG_TYPE_MLDSA:
#ifdef WOLFHSM_CFG_DMA
            if (useDma) {
                ret =
                    wh_Client_MlDsaCheckPrivKeyDma(ctx, key, pubKey, pubKeySz);
            }
            else
#endif /* WOLFHSM_CFG_DMA */
            {
                ret = wh_Client_MlDsaCheckPrivKey(ctx, key, pubKey, pubKeySz);
            }
            break;
#endif /* WOLFSSL_HAVE_MLDSA */

            /* Support for additional PQC algorithms should be added here */

        default:
            ret = CRYPTOCB_UNAVAILABLE;
            break;
    }

    return ret;
}
#endif /* HAVE_FALCON || WOLFSSL_HAVE_MLDSA */


#ifdef WOLFHSM_CFG_DMA
int wh_Client_CryptoCbDma(int devId, wc_CryptoInfo* info, void* inCtx)
{
    /* III When possible, return wolfCrypt-enumerated errors */
    int ret = CRYPTOCB_UNAVAILABLE;
    whClientContext* ctx = inCtx;

    if (    (devId == INVALID_DEVID) ||
            (info == NULL) ||
            (inCtx == NULL)) {
        return BAD_FUNC_ARG;
    }

    WH_DEBUG_CLIENT("CryptoCb invoked\n");
    WH_DEBUG_CLIENT_VERBOSE("CryptoCbDma info details: info=%p algo_type=%d", info,
                            (info!=NULL)?info->algo_type:-1);

    /* Based on the info type, process the request */
    switch (info->algo_type)
    {
    case WC_ALGO_TYPE_HASH: {
        switch (info->hash.type) {
#ifndef NO_SHA256
            case WC_HASH_TYPE_SHA256: {
                wc_Sha256*     sha   = info->hash.sha256;
                const uint8_t* in    = info->hash.in;
                uint32_t       inLen = info->hash.inSz;
                uint8_t*       out   = info->hash.digest;

                ret = wh_Client_Sha256Dma(ctx, sha, in, inLen, out);
            } break;
#endif /* !NO_SHA256 */
#ifdef WOLFSSL_SHA224
            case WC_HASH_TYPE_SHA224: {
                wc_Sha224*     sha   = info->hash.sha224;
                const uint8_t* in    = info->hash.in;
                uint32_t       inLen = info->hash.inSz;
                uint8_t*       out   = info->hash.digest;

                ret = wh_Client_Sha224Dma(ctx, sha, in, inLen, out);
            } break;
#endif /* WOLFSSL_SHA224 */
#ifdef WOLFSSL_SHA384
            case WC_HASH_TYPE_SHA384: {
                wc_Sha384*     sha   = info->hash.sha384;
                const uint8_t* in    = info->hash.in;
                uint32_t       inLen = info->hash.inSz;
                uint8_t*       out   = info->hash.digest;

                ret = wh_Client_Sha384Dma(ctx, sha, in, inLen, out);
            } break;
#endif /* WOLFSSL_SHA384 */
#if defined(WOLFSSL_SHA512) && defined(WOLFSSL_SHA512_HASHTYPE)
            case WC_HASH_TYPE_SHA512: {
                wc_Sha512*     sha   = info->hash.sha512;
                const uint8_t* in    = info->hash.in;
                uint32_t       inLen = info->hash.inSz;
                uint8_t*       out   = info->hash.digest;

                ret = wh_Client_Sha512Dma(ctx, sha, in, inLen, out);
            } break;
#endif /* WOLFSSL_SHA512 && defined(WOLFSSL_SHA512_HASHTYPE) */
#if defined(WOLFSSL_SHA3)
            case WC_HASH_TYPE_SHA3_224:
            case WC_HASH_TYPE_SHA3_256:
            case WC_HASH_TYPE_SHA3_384:
            case WC_HASH_TYPE_SHA3_512: {
                wc_Sha3* sha = info->hash.sha3;
#ifdef WOLFSSL_HASH_FLAGS
                if (sha != NULL &&
                    (sha->flags & WC_HASH_SHA3_KECCAK256) != 0u) {
                    ret = CRYPTOCB_UNAVAILABLE;
                    break;
                }
#endif
                switch (info->hash.type) {
#ifndef WOLFSSL_NOSHA3_224
                    case WC_HASH_TYPE_SHA3_224:
                        ret = wh_Client_Sha3_224Dma(ctx, sha, info->hash.in,
                                                    info->hash.inSz,
                                                    info->hash.digest);
                        break;
#endif
#ifndef WOLFSSL_NOSHA3_256
                    case WC_HASH_TYPE_SHA3_256:
                        ret = wh_Client_Sha3_256Dma(ctx, sha, info->hash.in,
                                                    info->hash.inSz,
                                                    info->hash.digest);
                        break;
#endif
#ifndef WOLFSSL_NOSHA3_384
                    case WC_HASH_TYPE_SHA3_384:
                        ret = wh_Client_Sha3_384Dma(ctx, sha, info->hash.in,
                                                    info->hash.inSz,
                                                    info->hash.digest);
                        break;
#endif
#ifndef WOLFSSL_NOSHA3_512
                    case WC_HASH_TYPE_SHA3_512:
                        ret = wh_Client_Sha3_512Dma(ctx, sha, info->hash.in,
                                                    info->hash.inSz,
                                                    info->hash.digest);
                        break;
#endif
                }
            } break;
#endif /* WOLFSSL_SHA3 */
            default:
                ret = CRYPTOCB_UNAVAILABLE;
                break;
        }
    } break; /* case WC_ALGO_TYPE_HASH */


    case WC_ALGO_TYPE_PK: {
        switch (info->pk.type) {
#if defined(WOLFSSL_HAVE_MLKEM)
            case WC_PK_TYPE_PQC_KEM_KEYGEN:
                ret = _handlePqcKemKeyGen(ctx, info, 1);
                break;
            case WC_PK_TYPE_PQC_KEM_ENCAPS:
                ret = _handlePqcEncaps(ctx, info, 1);
                break;
            case WC_PK_TYPE_PQC_KEM_DECAPS:
                ret = _handlePqcDecaps(ctx, info, 1);
                break;
#endif /* WOLFSSL_HAVE_MLKEM */
#if defined(WOLFSSL_HAVE_LMS) || defined(WOLFSSL_HAVE_XMSS)
            case WC_PK_TYPE_PQC_STATEFUL_SIG_KEYGEN:
                ret = _handlePqcStatefulSigKeyGen(ctx, info, 1);
                break;
            case WC_PK_TYPE_PQC_STATEFUL_SIG_SIGN:
                ret = _handlePqcStatefulSigSign(ctx, info, 1);
                break;
            case WC_PK_TYPE_PQC_STATEFUL_SIG_VERIFY:
                ret = _handlePqcStatefulSigVerify(ctx, info, 1);
                break;
            case WC_PK_TYPE_PQC_STATEFUL_SIG_SIGS_LEFT:
                ret = _handlePqcStatefulSigSigsLeft(ctx, info, 1);
                break;
#endif /* WOLFSSL_HAVE_LMS || WOLFSSL_HAVE_XMSS */
#if defined(WOLFSSL_HAVE_MLDSA) || defined(HAVE_FALCON)
            case WC_PK_TYPE_PQC_SIG_KEYGEN:
                ret = _handlePqcSigKeyGen(ctx, info, 1);
                break;
            case WC_PK_TYPE_PQC_SIG_SIGN:
                ret = _handlePqcSign(ctx, info, 1);
                break;
            case WC_PK_TYPE_PQC_SIG_VERIFY:
                ret = _handlePqcVerify(ctx, info, 1);
                break;
            case WC_PK_TYPE_PQC_SIG_CHECK_PRIV_KEY:
                ret = _handlePqcSigCheckPrivKey(ctx, info, 1);
                break;
#endif /* WOLFSSL_HAVE_MLDSA || HAVE_FALCON */
#ifdef HAVE_ED25519
            case WC_PK_TYPE_ED25519_KEYGEN: {
                ed25519_key* key = info->pk.ed25519kg.key;
                /* Only default Ed25519 supported */
                ret = wh_Client_Ed25519MakeExportKey(ctx, key);
                if (ret == WH_ERROR_BADARGS) {
                    ret = BAD_FUNC_ARG;
                }
            } break;

            case WC_PK_TYPE_ED25519_SIGN: {
                ed25519_key*   key    = info->pk.ed25519sign.key;
                const uint8_t* in     = (const uint8_t*)info->pk.ed25519sign.in;
                uint32_t       inLen  = info->pk.ed25519sign.inLen;
                uint8_t*       out    = info->pk.ed25519sign.out;
                word32*        outLen = info->pk.ed25519sign.outLen;
                uint8_t        type   = info->pk.ed25519sign.type;
                uint32_t       len;

                len = 0;
                if (outLen != NULL) {
                    len = *outLen;
                }
                ret = wh_Client_Ed25519SignDma(
                    ctx, key, in, inLen, type, info->pk.ed25519sign.context,
                    info->pk.ed25519sign.contextLen, out, &len);
                if (ret == WH_ERROR_OK && outLen != NULL) {
                    *outLen = len;
                }
                else if (ret == WH_ERROR_BADARGS) {
                    ret = BAD_FUNC_ARG;
                }
                else if (ret == WH_ERROR_NOTIMPL) {
                    ret = CRYPTOCB_UNAVAILABLE;
                }
            } break;

            case WC_PK_TYPE_ED25519_VERIFY: {
                ed25519_key*   key    = info->pk.ed25519verify.key;
                const uint8_t* sig    = info->pk.ed25519verify.sig;
                uint32_t       sigLen = info->pk.ed25519verify.sigLen;
                const uint8_t* msg    = info->pk.ed25519verify.msg;
                uint32_t       msgLen = info->pk.ed25519verify.msgLen;
                int*           res    = info->pk.ed25519verify.res;
                uint8_t        type   = info->pk.ed25519verify.type;

                ret = wh_Client_Ed25519VerifyDma(
                    ctx, key, sig, sigLen, msg, msgLen, type,
                    info->pk.ed25519verify.context,
                    info->pk.ed25519verify.contextLen, res);
                if (ret == WH_ERROR_BADARGS) {
                    ret = BAD_FUNC_ARG;
                }
                else if (ret == WH_ERROR_NOTIMPL) {
                    ret = CRYPTOCB_UNAVAILABLE;
                }
            } break;
#endif /* HAVE_ED25519 */

        }
    } break; /* case WC_ALGO_TYPE_PK */

#ifdef WOLFSSL_CMAC
    case WC_ALGO_TYPE_CMAC: {
        Cmac*          cmac      = info->cmac.cmac;
        CmacType       type      = info->cmac.type;
        const uint8_t* key       = info->cmac.key;
        uint32_t       keyLen    = info->cmac.keySz;
        const uint8_t* in        = info->cmac.in;
        uint32_t       inLen     = info->cmac.inSz;
        uint8_t*       outMac    = info->cmac.out;
        uint32_t*      outMacLen = (uint32_t*)info->cmac.outSz;

        ret = wh_Client_CmacDma(ctx, cmac, type, key, keyLen, in, inLen, outMac,
                                outMacLen);
    } break;
#endif

#if !defined(NO_AES) || !defined(NO_DES3) || defined(WOLFSSL_SM4)
    case WC_ALGO_TYPE_CIPHER:
        switch (info->cipher.type) {
#ifndef NO_AES
#ifdef WOLFSSL_AES_COUNTER
            case WC_CIPHER_AES_CTR: {
                /* Extract info parameters */
                uint32_t       enc = info->cipher.enc;
                Aes*           aes = info->cipher.aesctr.aes;
                const uint8_t* in  = info->cipher.aesctr.in;
                uint32_t       len = info->cipher.aesctr.sz;
                uint8_t*       out = info->cipher.aesctr.out;

                ret = wh_Client_AesCtrDma(ctx, aes, enc, in, len, out);
            } break;
#endif /* WOLFSSL_AES_COUNTER */
#ifdef HAVE_AES_CBC
            case WC_CIPHER_AES_CBC: {
                /* Extract info parameters */
                uint32_t       enc = info->cipher.enc;
                Aes*           aes = info->cipher.aescbc.aes;
                const uint8_t* in  = info->cipher.aescbc.in;
                uint32_t       len = info->cipher.aescbc.sz;
                uint8_t*       out = info->cipher.aescbc.out;

                ret = wh_Client_AesCbcDma(ctx, aes, enc, in, len, out);
            } break;
#endif /* HAVE_AES_CBC */
#ifdef HAVE_AESGCM
            case WC_CIPHER_AES_GCM: {
                /* Extract info parameters */
                uint32_t enc        = info->cipher.enc;
                Aes*     aes        = (enc == 0) ? info->cipher.aesgcm_dec.aes
                                                 : info->cipher.aesgcm_enc.aes;
                uint32_t len        = (enc == 0) ? info->cipher.aesgcm_dec.sz
                                                 : info->cipher.aesgcm_enc.sz;
                uint32_t iv_len     = (enc == 0) ? info->cipher.aesgcm_dec.ivSz
                                                 : info->cipher.aesgcm_enc.ivSz;
                uint32_t authin_len = (enc == 0)
                                          ? info->cipher.aesgcm_dec.authInSz
                                          : info->cipher.aesgcm_enc.authInSz;
                uint32_t tag_len    = (enc == 0)
                                          ? info->cipher.aesgcm_dec.authTagSz
                                          : info->cipher.aesgcm_enc.authTagSz;
                const uint8_t* in   = (enc == 0) ? info->cipher.aesgcm_dec.in
                                                 : info->cipher.aesgcm_enc.in;
                const uint8_t* iv   = (enc == 0) ? info->cipher.aesgcm_dec.iv
                                                 : info->cipher.aesgcm_enc.iv;
                const uint8_t* authin  = (enc == 0)
                                             ? info->cipher.aesgcm_dec.authIn
                                             : info->cipher.aesgcm_enc.authIn;
                const uint8_t* dec_tag = info->cipher.aesgcm_dec.authTag;
                uint8_t*       enc_tag = info->cipher.aesgcm_enc.authTag;
                uint8_t*       out = (enc == 0) ? info->cipher.aesgcm_dec.out
                                                : info->cipher.aesgcm_enc.out;

                ret = wh_Client_AesGcmDma(ctx, aes, enc, in, len, iv, iv_len,
                                          authin, authin_len, dec_tag, enc_tag,
                                          tag_len, out);
            } break;
#endif /* HAVE_AESGCM */
#ifdef HAVE_AES_ECB
            case WC_CIPHER_AES_ECB: {
                /* Extract info parameters */
                uint32_t       enc = info->cipher.enc;
                Aes*           aes = info->cipher.aesecb.aes;
                const uint8_t* in  = info->cipher.aesecb.in;
                uint32_t       len = info->cipher.aesecb.sz;
                uint8_t*       out = info->cipher.aesecb.out;

                ret = wh_Client_AesEcbDma(ctx, aes, enc, in, len, out);
            } break;
#endif /* HAVE_AES_ECB */
#endif /* !NO_AES */
#ifdef WOLFSSL_SM4
#ifdef WOLFSSL_SM4_ECB
            case WC_CIPHER_SM4_ECB: {
                uint32_t       enc = info->cipher.enc;
                wc_Sm4*        sm4 = info->cipher.sm4ecb.sm4;
                const uint8_t* in  = info->cipher.sm4ecb.in;
                uint32_t       len = info->cipher.sm4ecb.sz;
                uint8_t*       out = info->cipher.sm4ecb.out;

                ret = wh_Client_Sm4EcbDma(ctx, sm4, enc, in, len, out);
            } break;
#endif /* WOLFSSL_SM4_ECB */
#ifdef WOLFSSL_SM4_CBC
            case WC_CIPHER_SM4_CBC: {
                uint32_t       enc = info->cipher.enc;
                wc_Sm4*        sm4 = info->cipher.sm4cbc.sm4;
                const uint8_t* in  = info->cipher.sm4cbc.in;
                uint32_t       len = info->cipher.sm4cbc.sz;
                uint8_t*       out = info->cipher.sm4cbc.out;

                ret = wh_Client_Sm4CbcDma(ctx, sm4, enc, in, len, out);
            } break;
#endif /* WOLFSSL_SM4_CBC */
#ifdef WOLFSSL_SM4_CTR
            case WC_CIPHER_SM4_CTR: {
                wc_Sm4*        sm4 = info->cipher.sm4ctr.sm4;
                const uint8_t* in  = info->cipher.sm4ctr.in;
                uint32_t       len = info->cipher.sm4ctr.sz;
                uint8_t*       out = info->cipher.sm4ctr.out;

                ret = wh_Client_Sm4CtrDma(ctx, sm4, in, len, out);
            } break;
#endif /* WOLFSSL_SM4_CTR */
#ifdef WOLFSSL_SM4_GCM
            case WC_CIPHER_SM4_GCM: {
                uint32_t enc = info->cipher.enc;
                wc_Sm4*  sm4 = (enc == 0) ? info->cipher.sm4gcm_dec.sm4
                                          : info->cipher.sm4gcm_enc.sm4;
                uint32_t len = (enc == 0) ? info->cipher.sm4gcm_dec.sz
                                          : info->cipher.sm4gcm_enc.sz;
                uint32_t iv_len = (enc == 0) ? info->cipher.sm4gcm_dec.nonceSz
                                             : info->cipher.sm4gcm_enc.nonceSz;
                uint32_t authin_len =
                    (enc == 0) ? info->cipher.sm4gcm_dec.authInSz
                               : info->cipher.sm4gcm_enc.authInSz;
                uint32_t tag_len =
                    (enc == 0) ? info->cipher.sm4gcm_dec.authTagSz
                               : info->cipher.sm4gcm_enc.authTagSz;
                const uint8_t* in = (enc == 0) ? info->cipher.sm4gcm_dec.in
                                               : info->cipher.sm4gcm_enc.in;
                const uint8_t* iv = (enc == 0) ? info->cipher.sm4gcm_dec.nonce
                                               : info->cipher.sm4gcm_enc.nonce;
                const uint8_t* authin =
                    (enc == 0) ? info->cipher.sm4gcm_dec.authIn
                               : info->cipher.sm4gcm_enc.authIn;
                uint8_t* out = (enc == 0) ? info->cipher.sm4gcm_dec.out
                                          : info->cipher.sm4gcm_enc.out;
                uint8_t* tag =
                    (enc == 0) ? (uint8_t*)info->cipher.sm4gcm_dec.authTag
                               : info->cipher.sm4gcm_enc.authTag;

                ret = wh_Client_Sm4GcmDma(ctx, sm4, enc, in, len, iv, iv_len,
                                          authin, authin_len, tag, tag_len,
                                          out);
            } break;
#endif /* WOLFSSL_SM4_GCM */
#ifdef WOLFSSL_SM4_CCM
            case WC_CIPHER_SM4_CCM: {
                uint32_t enc = info->cipher.enc;
                wc_Sm4*  sm4 = (enc == 0) ? info->cipher.sm4ccm_dec.sm4
                                          : info->cipher.sm4ccm_enc.sm4;
                uint32_t len = (enc == 0) ? info->cipher.sm4ccm_dec.sz
                                          : info->cipher.sm4ccm_enc.sz;
                uint32_t iv_len = (enc == 0) ? info->cipher.sm4ccm_dec.nonceSz
                                             : info->cipher.sm4ccm_enc.nonceSz;
                uint32_t authin_len =
                    (enc == 0) ? info->cipher.sm4ccm_dec.authInSz
                               : info->cipher.sm4ccm_enc.authInSz;
                uint32_t tag_len =
                    (enc == 0) ? info->cipher.sm4ccm_dec.authTagSz
                               : info->cipher.sm4ccm_enc.authTagSz;
                const uint8_t* in = (enc == 0) ? info->cipher.sm4ccm_dec.in
                                               : info->cipher.sm4ccm_enc.in;
                const uint8_t* iv = (enc == 0) ? info->cipher.sm4ccm_dec.nonce
                                               : info->cipher.sm4ccm_enc.nonce;
                const uint8_t* authin =
                    (enc == 0) ? info->cipher.sm4ccm_dec.authIn
                               : info->cipher.sm4ccm_enc.authIn;
                uint8_t* out = (enc == 0) ? info->cipher.sm4ccm_dec.out
                                          : info->cipher.sm4ccm_enc.out;
                uint8_t* tag =
                    (enc == 0) ? (uint8_t*)info->cipher.sm4ccm_dec.authTag
                               : info->cipher.sm4ccm_enc.authTag;

                ret = wh_Client_Sm4CcmDma(ctx, sm4, enc, in, len, iv, iv_len,
                                          authin, authin_len, tag, tag_len,
                                          out);
            } break;
#endif /* WOLFSSL_SM4_CCM */
#endif /* WOLFSSL_SM4 */
            default:
                ret = CRYPTOCB_UNAVAILABLE;
                break;
        }
        break;
#endif /* !NO_AES || !NO_DES */

#ifndef WC_NO_RNG
    case WC_ALGO_TYPE_RNG: {
        /* Extract info parameters */
        uint8_t* out  = info->rng.out;
        uint32_t size = info->rng.sz;

        ret = wh_Client_RngGenerateDma(ctx, out, size);
    } break;
    case WC_ALGO_TYPE_SEED: {
        /* Extract info parameters */
        uint8_t* seed = info->seed.seed;
        uint32_t size = info->seed.sz;

        ret = wh_Client_RngGenerateDma(ctx, seed, size);
    } break;
#endif /* !WC_NO_RNG */

    case WC_ALGO_TYPE_NONE:
    default:
        ret = CRYPTOCB_UNAVAILABLE;
        break;
    }

    if (ret == CRYPTOCB_UNAVAILABLE) {
        WH_DEBUG_CLIENT("X not implemented: algo->type:%d\n", info->algo_type);
    } else {
        WH_DEBUG_CLIENT("ret:%d algo->type:%d\n", ret, info->algo_type);
    }
    return ret;
}
#endif /* WOLFHSM_CFG_DMA */

#endif /* !WOLFHSM_CFG_NO_CRYPTO && WOLFHSM_CFG_ENABLE_CLIENT */