wh_message_crypto.c

/*
 * Copyright (C) 2025 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/>.
 */
/*
 * wolfhsm/wh_message_crypto.c
 *
 * Message translation functions for crypto operations.
 */

#include "wolfhsm/wh_message_crypto.h"
#include "wolfhsm/wh_error.h"
#include "wolfhsm/wh_comm.h"
#include <string.h>

/* Generic crypto header request translation */
int wh_MessageCrypto_TranslateGenericRequestHeader(
    uint16_t magic, const whMessageCrypto_GenericRequestHeader* src,
    whMessageCrypto_GenericRequestHeader* dest)
{
    if ((src == NULL) || (dest == NULL)) {
        return WH_ERROR_BADARGS;
    }
    WH_T32(magic, dest, src, algoType);
    WH_T32(magic, dest, src, algoSubType);
    WH_T32(magic, dest, src, affinity);
    return 0;
}

/* Generic crypto header response translation */
int wh_MessageCrypto_TranslateGenericResponseHeader(
    uint16_t magic, const whMessageCrypto_GenericResponseHeader* src,
    whMessageCrypto_GenericResponseHeader* dest)
{
    if ((src == NULL) || (dest == NULL)) {
        return WH_ERROR_BADARGS;
    }
    WH_T32(magic, dest, src, algoType);
    WH_T32(magic, dest, src, rc);
    WH_T32(magic, dest, src, reserved);
    return 0;
}

/* RNG Request translation */
int wh_MessageCrypto_TranslateRngRequest(uint16_t magic,
                                         const whMessageCrypto_RngRequest* src,
                                         whMessageCrypto_RngRequest*       dest)
{
    if ((src == NULL) || (dest == NULL)) {
        return WH_ERROR_BADARGS;
    }
    WH_T32(magic, dest, src, sz);
    return 0;
}

/* RNG Response translation */
int wh_MessageCrypto_TranslateRngResponse(
    uint16_t magic, const whMessageCrypto_RngResponse* src,
    whMessageCrypto_RngResponse* dest)
{
    if ((src == NULL) || (dest == NULL)) {
        return WH_ERROR_BADARGS;
    }
    WH_T32(magic, dest, src, sz);
    return 0;
}

/* AES CTR Request translation */
int wh_MessageCrypto_TranslateAesCtrRequest(
    uint16_t magic, const whMessageCrypto_AesCtrRequest* src,
    whMessageCrypto_AesCtrRequest* dest)
{
    if ((src == NULL) || (dest == NULL)) {
        return WH_ERROR_BADARGS;
    }
    WH_T32(magic, dest, src, enc);
    WH_T32(magic, dest, src, keyLen);
    WH_T32(magic, dest, src, sz);
    WH_T16(magic, dest, src, keyId);
    WH_T32(magic, dest, src, left);
    return 0;
}
/* AES CTR Response translation */
int wh_MessageCrypto_TranslateAesCtrResponse(
    uint16_t magic, const whMessageCrypto_AesCtrResponse* src,
    whMessageCrypto_AesCtrResponse* dest)
{
    if ((src == NULL) || (dest == NULL)) {
        return WH_ERROR_BADARGS;
    }
    WH_T32(magic, dest, src, sz);
    WH_T32(magic, dest, src, left);
    return 0;
}
/* AES Ecb Request translation */
int wh_MessageCrypto_TranslateAesEcbRequest(
    uint16_t magic, const whMessageCrypto_AesEcbRequest* src,
    whMessageCrypto_AesEcbRequest* dest)
{
    if ((src == NULL) || (dest == NULL)) {
        return WH_ERROR_BADARGS;
    }
    WH_T32(magic, dest, src, enc);
    WH_T32(magic, dest, src, keyLen);
    WH_T32(magic, dest, src, sz);
    WH_T16(magic, dest, src, keyId);
    return 0;
}

/* AES ECB Response translation */
int wh_MessageCrypto_TranslateAesEcbResponse(
    uint16_t magic, const whMessageCrypto_AesEcbResponse* src,
    whMessageCrypto_AesEcbResponse* dest)
{
    if ((src == NULL) || (dest == NULL)) {
        return WH_ERROR_BADARGS;
    }
    WH_T32(magic, dest, src, sz);
    return 0;
}

/* AES CBC Request translation */
int wh_MessageCrypto_TranslateAesCbcRequest(
    uint16_t magic, const whMessageCrypto_AesCbcRequest* src,
    whMessageCrypto_AesCbcRequest* dest)
{
    if ((src == NULL) || (dest == NULL)) {
        return WH_ERROR_BADARGS;
    }
    WH_T32(magic, dest, src, enc);
    WH_T32(magic, dest, src, keyLen);
    WH_T32(magic, dest, src, sz);
    WH_T16(magic, dest, src, keyId);
    return 0;
}

/* AES CBC Response translation */
int wh_MessageCrypto_TranslateAesCbcResponse(
    uint16_t magic, const whMessageCrypto_AesCbcResponse* src,
    whMessageCrypto_AesCbcResponse* dest)
{
    if ((src == NULL) || (dest == NULL)) {
        return WH_ERROR_BADARGS;
    }
    WH_T32(magic, dest, src, sz);
    return 0;
}

/* AES GCM Request translation */
int wh_MessageCrypto_TranslateAesGcmRequest(
    uint16_t magic, const whMessageCrypto_AesGcmRequest* src,
    whMessageCrypto_AesGcmRequest* dest)
{
    if ((src == NULL) || (dest == NULL)) {
        return WH_ERROR_BADARGS;
    }
    WH_T32(magic, dest, src, enc);
    WH_T32(magic, dest, src, keyLen);
    WH_T32(magic, dest, src, sz);
    WH_T32(magic, dest, src, ivSz);
    WH_T32(magic, dest, src, authInSz);
    WH_T32(magic, dest, src, authTagSz);
    WH_T16(magic, dest, src, keyId);
    return 0;
}

/* AES GCM Response translation */
int wh_MessageCrypto_TranslateAesGcmResponse(
    uint16_t magic, const whMessageCrypto_AesGcmResponse* src,
    whMessageCrypto_AesGcmResponse* dest)
{
    if ((src == NULL) || (dest == NULL)) {
        return WH_ERROR_BADARGS;
    }
    WH_T32(magic, dest, src, sz);
    WH_T32(magic, dest, src, authTagSz);
    return 0;
}
/* RSA Key Generation Request translation */
int wh_MessageCrypto_TranslateRsaKeyGenRequest(
    uint16_t magic, const whMessageCrypto_RsaKeyGenRequest* src,
    whMessageCrypto_RsaKeyGenRequest* dest)
{
    if ((src == NULL) || (dest == NULL)) {
        return WH_ERROR_BADARGS;
    }
    WH_T32(magic, dest, src, flags);
    WH_T32(magic, dest, src, keyId);
    WH_T32(magic, dest, src, size);
    WH_T32(magic, dest, src, e);
    /* Label is just a byte array, no translation needed */
    if (src != dest) {
        memcpy(dest->label, src->label, WH_NVM_LABEL_LEN);
    }
    return 0;
}

/* RSA Key Generation Response translation */
int wh_MessageCrypto_TranslateRsaKeyGenResponse(
    uint16_t magic, const whMessageCrypto_RsaKeyGenResponse* src,
    whMessageCrypto_RsaKeyGenResponse* dest)
{
    if ((src == NULL) || (dest == NULL)) {
        return WH_ERROR_BADARGS;
    }
    WH_T32(magic, dest, src, keyId);
    WH_T32(magic, dest, src, len);
    return 0;
}

/* RSA Request translation */
int wh_MessageCrypto_TranslateRsaRequest(uint16_t magic,
                                         const whMessageCrypto_RsaRequest* src,
                                         whMessageCrypto_RsaRequest*       dest)
{
    if ((src == NULL) || (dest == NULL)) {
        return WH_ERROR_BADARGS;
    }
    WH_T32(magic, dest, src, opType);
    WH_T32(magic, dest, src, options);
    WH_T32(magic, dest, src, keyId);
    WH_T32(magic, dest, src, inLen);
    WH_T32(magic, dest, src, outLen);
    return 0;
}

/* RSA Response translation */
int wh_MessageCrypto_TranslateRsaResponse(
    uint16_t magic, const whMessageCrypto_RsaResponse* src,
    whMessageCrypto_RsaResponse* dest)
{
    if ((src == NULL) || (dest == NULL)) {
        return WH_ERROR_BADARGS;
    }
    WH_T32(magic, dest, src, outLen);
    return 0;
}

/* RSA Get Size Request translation */
int wh_MessageCrypto_TranslateRsaGetSizeRequest(
    uint16_t magic, const whMessageCrypto_RsaGetSizeRequest* src,
    whMessageCrypto_RsaGetSizeRequest* dest)
{
    if ((src == NULL) || (dest == NULL)) {
        return WH_ERROR_BADARGS;
    }
    WH_T32(magic, dest, src, options);
    WH_T32(magic, dest, src, keyId);
    return 0;
}

/* RSA Get Size Response translation */
int wh_MessageCrypto_TranslateRsaGetSizeResponse(
    uint16_t magic, const whMessageCrypto_RsaGetSizeResponse* src,
    whMessageCrypto_RsaGetSizeResponse* dest)
{
    if ((src == NULL) || (dest == NULL)) {
        return WH_ERROR_BADARGS;
    }
    WH_T32(magic, dest, src, keySize);
    return 0;
}

/* HKDF Request translation */
int wh_MessageCrypto_TranslateHkdfRequest(
    uint16_t magic, const whMessageCrypto_HkdfRequest* src,
    whMessageCrypto_HkdfRequest* dest)
{
    if ((src == NULL) || (dest == NULL)) {
        return WH_ERROR_BADARGS;
    }
    WH_T32(magic, dest, src, flags);
    WH_T32(magic, dest, src, keyIdOut);
    WH_T32(magic, dest, src, keyIdIn);
    WH_T32(magic, dest, src, hashType);
    WH_T32(magic, dest, src, inKeySz);
    WH_T32(magic, dest, src, saltSz);
    WH_T32(magic, dest, src, infoSz);
    WH_T32(magic, dest, src, outSz);
    /* Label is just a byte array, no translation needed */
    if (src != dest) {
        memcpy(dest->label, src->label, WH_NVM_LABEL_LEN);
    }
    return 0;
}

/* HKDF Response translation */
int wh_MessageCrypto_TranslateHkdfResponse(
    uint16_t magic, const whMessageCrypto_HkdfResponse* src,
    whMessageCrypto_HkdfResponse* dest)
{
    if ((src == NULL) || (dest == NULL)) {
        return WH_ERROR_BADARGS;
    }
    WH_T32(magic, dest, src, keyIdOut);
    WH_T32(magic, dest, src, outSz);
    return 0;
}

int wh_MessageCrypto_TranslateCmacKdfRequest(
    uint16_t magic, const whMessageCrypto_CmacKdfRequest* src,
    whMessageCrypto_CmacKdfRequest* dest)
{
    if ((src == NULL) || (dest == NULL)) {
        return WH_ERROR_BADARGS;
    }
    WH_T32(magic, dest, src, flags);
    WH_T32(magic, dest, src, keyIdSalt);
    WH_T32(magic, dest, src, keyIdZ);
    WH_T32(magic, dest, src, keyIdOut);
    WH_T32(magic, dest, src, saltSz);
    WH_T32(magic, dest, src, zSz);
    WH_T32(magic, dest, src, fixedInfoSz);
    WH_T32(magic, dest, src, outSz);
    if (src != dest) {
        memcpy(dest->label, src->label, WH_NVM_LABEL_LEN);
    }
    return 0;
}

int wh_MessageCrypto_TranslateCmacKdfResponse(
    uint16_t magic, const whMessageCrypto_CmacKdfResponse* src,
    whMessageCrypto_CmacKdfResponse* dest)
{
    if ((src == NULL) || (dest == NULL)) {
        return WH_ERROR_BADARGS;
    }
    WH_T32(magic, dest, src, keyIdOut);
    WH_T32(magic, dest, src, outSz);
    return 0;
}

/* ECC Key Generation Request translation */
int wh_MessageCrypto_TranslateEccKeyGenRequest(
    uint16_t magic, const whMessageCrypto_EccKeyGenRequest* src,
    whMessageCrypto_EccKeyGenRequest* dest)
{
    if ((src == NULL) || (dest == NULL)) {
        return WH_ERROR_BADARGS;
    }
    WH_T32(magic, dest, src, sz);
    WH_T32(magic, dest, src, curveId);
    WH_T32(magic, dest, src, keyId);
    WH_T32(magic, dest, src, flags);
    WH_T32(magic, dest, src, access);
    /* Label is just a byte array, no translation needed */
    if (src != dest) {
        memcpy(dest->label, src->label, sizeof(src->label));
    }
    return 0;
}

/* ECC Key Generation Response translation */
int wh_MessageCrypto_TranslateEccKeyGenResponse(
    uint16_t magic, const whMessageCrypto_EccKeyGenResponse* src,
    whMessageCrypto_EccKeyGenResponse* dest)
{
    if ((src == NULL) || (dest == NULL)) {
        return WH_ERROR_BADARGS;
    }
    WH_T32(magic, dest, src, keyId);
    WH_T32(magic, dest, src, len);
    return 0;
}

/* ECDH Request translation */
int wh_MessageCrypto_TranslateEcdhRequest(
    uint16_t magic, const whMessageCrypto_EcdhRequest* src,
    whMessageCrypto_EcdhRequest* dest)
{
    if ((src == NULL) || (dest == NULL)) {
        return WH_ERROR_BADARGS;
    }
    WH_T32(magic, dest, src, options);
    WH_T32(magic, dest, src, privateKeyId);
    WH_T32(magic, dest, src, publicKeyId);
    WH_T32(magic, dest, src, flags);
    WH_T32(magic, dest, src, keyId);
    if (src != dest) {
        memcpy(dest->label, src->label, sizeof(src->label));
    }
    return 0;
}

/* ECDH Response translation */
int wh_MessageCrypto_TranslateEcdhResponse(
    uint16_t magic, const whMessageCrypto_EcdhResponse* src,
    whMessageCrypto_EcdhResponse* dest)
{
    if ((src == NULL) || (dest == NULL)) {
        return WH_ERROR_BADARGS;
    }
    WH_T32(magic, dest, src, sz);
    WH_T32(magic, dest, src, keyId);
    return 0;
}

/* ECC Sign Request translation */
int wh_MessageCrypto_TranslateEccSignRequest(
    uint16_t magic, const whMessageCrypto_EccSignRequest* src,
    whMessageCrypto_EccSignRequest* dest)
{
    if ((src == NULL) || (dest == NULL)) {
        return WH_ERROR_BADARGS;
    }
    WH_T32(magic, dest, src, options);
    WH_T32(magic, dest, src, keyId);
    WH_T32(magic, dest, src, sz);
    return 0;
}

/* ECC Sign Response translation */
int wh_MessageCrypto_TranslateEccSignResponse(
    uint16_t magic, const whMessageCrypto_EccSignResponse* src,
    whMessageCrypto_EccSignResponse* dest)
{
    if ((src == NULL) || (dest == NULL)) {
        return WH_ERROR_BADARGS;
    }
    WH_T32(magic, dest, src, sz);
    return 0;
}

/* ECC Verify Request translation */
int wh_MessageCrypto_TranslateEccVerifyRequest(
    uint16_t magic, const whMessageCrypto_EccVerifyRequest* src,
    whMessageCrypto_EccVerifyRequest* dest)
{
    if ((src == NULL) || (dest == NULL)) {
        return WH_ERROR_BADARGS;
    }
    WH_T32(magic, dest, src, options);
    WH_T32(magic, dest, src, keyId);
    WH_T32(magic, dest, src, sigSz);
    WH_T32(magic, dest, src, hashSz);
    return 0;
}

/* ECC Verify Response translation */
int wh_MessageCrypto_TranslateEccVerifyResponse(
    uint16_t magic, const whMessageCrypto_EccVerifyResponse* src,
    whMessageCrypto_EccVerifyResponse* dest)
{
    if ((src == NULL) || (dest == NULL)) {
        return WH_ERROR_BADARGS;
    }
    WH_T32(magic, dest, src, res);
    WH_T32(magic, dest, src, pubSz);
    return 0;
}

/* ECC Check Request translation */
int wh_MessageCrypto_TranslateEccCheckRequest(
    uint16_t magic, const whMessageCrypto_EccCheckRequest* src,
    whMessageCrypto_EccCheckRequest* dest)
{
    if ((src == NULL) || (dest == NULL)) {
        return WH_ERROR_BADARGS;
    }
    WH_T32(magic, dest, src, keyId);
    WH_T32(magic, dest, src, curveId);
    return 0;
}

/* ECC Check Response translation */
int wh_MessageCrypto_TranslateEccCheckResponse(
    uint16_t magic, const whMessageCrypto_EccCheckResponse* src,
    whMessageCrypto_EccCheckResponse* dest)
{
    if ((src == NULL) || (dest == NULL)) {
        return WH_ERROR_BADARGS;
    }
    WH_T32(magic, dest, src, ok);
    return 0;
}

/* Curve25519 Key Generation Request translation */
int wh_MessageCrypto_TranslateCurve25519KeyGenRequest(
    uint16_t magic, const whMessageCrypto_Curve25519KeyGenRequest* src,
    whMessageCrypto_Curve25519KeyGenRequest* dest)
{
    if ((src == NULL) || (dest == NULL)) {
        return WH_ERROR_BADARGS;
    }
    WH_T32(magic, dest, src, sz);
    WH_T32(magic, dest, src, flags);
    WH_T32(magic, dest, src, keyId);
    /* Label is just a byte array, no translation needed */
    if (src != dest) {
        memcpy(dest->label, src->label, sizeof(src->label));
    }
    return 0;
}

/* Curve25519 Key Generation Response translation */
int wh_MessageCrypto_TranslateCurve25519KeyGenResponse(
    uint16_t magic, const whMessageCrypto_Curve25519KeyGenResponse* src,
    whMessageCrypto_Curve25519KeyGenResponse* dest)
{
    if ((src == NULL) || (dest == NULL)) {
        return WH_ERROR_BADARGS;
    }
    WH_T32(magic, dest, src, keyId);
    WH_T32(magic, dest, src, len);
    return 0;
}

/* Curve25519 Request translation */
int wh_MessageCrypto_TranslateCurve25519Request(
    uint16_t magic, const whMessageCrypto_Curve25519Request* src,
    whMessageCrypto_Curve25519Request* dest)
{
    if ((src == NULL) || (dest == NULL)) {
        return WH_ERROR_BADARGS;
    }
    WH_T32(magic, dest, src, options);
    WH_T32(magic, dest, src, privateKeyId);
    WH_T32(magic, dest, src, publicKeyId);
    WH_T32(magic, dest, src, endian);
    WH_T32(magic, dest, src, flags);
    WH_T32(magic, dest, src, keyId);
    if (src != dest) {
        memcpy(dest->label, src->label, sizeof(src->label));
    }
    return 0;
}

/* Curve25519 Response translation */
int wh_MessageCrypto_TranslateCurve25519Response(
    uint16_t magic, const whMessageCrypto_Curve25519Response* src,
    whMessageCrypto_Curve25519Response* dest)
{
    if ((src == NULL) || (dest == NULL)) {
        return WH_ERROR_BADARGS;
    }
    WH_T32(magic, dest, src, sz);
    WH_T32(magic, dest, src, keyId);
    return 0;
}

/* Ed25519 Key Generation Request translation */
int wh_MessageCrypto_TranslateEd25519KeyGenRequest(
    uint16_t magic, const whMessageCrypto_Ed25519KeyGenRequest* src,
    whMessageCrypto_Ed25519KeyGenRequest* dest)
{
    if ((src == NULL) || (dest == NULL)) {
        return WH_ERROR_BADARGS;
    }
    WH_T32(magic, dest, src, flags);
    WH_T32(magic, dest, src, keyId);
    WH_T32(magic, dest, src, access);
    if (src != dest) {
        memcpy(dest->label, src->label, sizeof(src->label));
    }
    return 0;
}

/* Ed25519 Key Generation Response translation */
int wh_MessageCrypto_TranslateEd25519KeyGenResponse(
    uint16_t magic, const whMessageCrypto_Ed25519KeyGenResponse* src,
    whMessageCrypto_Ed25519KeyGenResponse* dest)
{
    if ((src == NULL) || (dest == NULL)) {
        return WH_ERROR_BADARGS;
    }
    WH_T32(magic, dest, src, keyId);
    WH_T32(magic, dest, src, outSz);
    return 0;
}

/* Ed25519 Sign Request translation */
int wh_MessageCrypto_TranslateEd25519SignRequest(
    uint16_t magic, const whMessageCrypto_Ed25519SignRequest* src,
    whMessageCrypto_Ed25519SignRequest* dest)
{
    if ((src == NULL) || (dest == NULL)) {
        return WH_ERROR_BADARGS;
    }
    WH_T32(magic, dest, src, options);
    WH_T32(magic, dest, src, keyId);
    WH_T32(magic, dest, src, msgSz);
    WH_T32(magic, dest, src, type);
    WH_T32(magic, dest, src, ctxSz);
    return 0;
}

/* Ed25519 Sign Response translation */
int wh_MessageCrypto_TranslateEd25519SignResponse(
    uint16_t magic, const whMessageCrypto_Ed25519SignResponse* src,
    whMessageCrypto_Ed25519SignResponse* dest)
{
    if ((src == NULL) || (dest == NULL)) {
        return WH_ERROR_BADARGS;
    }
    WH_T32(magic, dest, src, sigSz);
    return 0;
}

/* Ed25519 Verify Request translation */
int wh_MessageCrypto_TranslateEd25519VerifyRequest(
    uint16_t magic, const whMessageCrypto_Ed25519VerifyRequest* src,
    whMessageCrypto_Ed25519VerifyRequest* dest)
{
    if ((src == NULL) || (dest == NULL)) {
        return WH_ERROR_BADARGS;
    }
    WH_T32(magic, dest, src, options);
    WH_T32(magic, dest, src, keyId);
    WH_T32(magic, dest, src, sigSz);
    WH_T32(magic, dest, src, msgSz);
    WH_T32(magic, dest, src, type);
    WH_T32(magic, dest, src, ctxSz);
    return 0;
}

/* Ed25519 Verify Response translation */
int wh_MessageCrypto_TranslateEd25519VerifyResponse(
    uint16_t magic, const whMessageCrypto_Ed25519VerifyResponse* src,
    whMessageCrypto_Ed25519VerifyResponse* dest)
{
    if ((src == NULL) || (dest == NULL)) {
        return WH_ERROR_BADARGS;
    }
    WH_T32(magic, dest, src, res);
    return 0;
}

/* Number of chaining words in a SHA-2 intermediate state, for every variant */
#define WH_MESSAGE_CRYPTO_SHA2_STATE_WORDS 8

/* Swap the host-order chaining words of a serialized SHA-2 state. wordSize is
 * 4 (SHA-224/256) or 8 (SHA-384/512); any other value, including 0 for a
 * finalized digest, copies the array verbatim. */
static void _TranslateSha2State(uint16_t magic, uint8_t* dest,
                                const uint8_t* src, uint32_t hashSz,
                                uint32_t wordSize)
{
    uint32_t i;
    uint32_t stateSz = WH_MESSAGE_CRYPTO_SHA2_STATE_WORDS * wordSize;
    uint32_t w32;
    uint64_t w64;

    if (dest != src) {
        memcpy(dest, src, hashSz);
    }
    if (stateSz > hashSz) {
        return;
    }
    if (wordSize == sizeof(uint32_t)) {
        for (i = 0; i < stateSz; i += wordSize) {
            memcpy(&w32, dest + i, sizeof(w32));
            w32 = wh_Translate32(magic, w32);
            memcpy(dest + i, &w32, sizeof(w32));
        }
    }
    else if (wordSize == sizeof(uint64_t)) {
        for (i = 0; i < stateSz; i += wordSize) {
            memcpy(&w64, dest + i, sizeof(w64));
            w64 = wh_Translate64(magic, w64);
            memcpy(dest + i, &w64, sizeof(w64));
        }
    }
}

/* SHA256 Request translation. Only the fixed-size header is translated; any
 * trailing variable-length input bytes (uint8_t in[inSz]) are raw bytes that
 * do not need endian translation. */
int wh_MessageCrypto_TranslateSha256Request(
    uint16_t magic, const whMessageCrypto_Sha256Request* src,
    whMessageCrypto_Sha256Request* dest)
{
    if ((src == NULL) || (dest == NULL)) {
        return WH_ERROR_BADARGS;
    }
    WH_T32(magic, dest, src, resumeState.hiLen);
    WH_T32(magic, dest, src, resumeState.loLen);
    /* A request always carries intermediate state, even on the last block */
    _TranslateSha2State(magic, dest->resumeState.hash, src->resumeState.hash,
                        (uint32_t)sizeof(src->resumeState.hash),
                        (uint32_t)sizeof(uint32_t));
    WH_T32(magic, dest, src, isLastBlock);
    WH_T32(magic, dest, src, inSz);
    return 0;
}

#if defined(WOLFSSL_SHA512) || defined(WOLFSSL_SHA384)
/* SHA512 Request translation. Only the fixed-size header is translated; any
 * trailing variable-length input bytes (uint8_t in[inSz]) are raw bytes that
 * do not need endian translation. */
int wh_MessageCrypto_TranslateSha512Request(
    uint16_t magic, const whMessageCrypto_Sha512Request* src,
    whMessageCrypto_Sha512Request* dest)
{
    if ((src == NULL) || (dest == NULL)) {
        return WH_ERROR_BADARGS;
    }
    WH_T32(magic, dest, src, resumeState.hiLen);
    WH_T32(magic, dest, src, resumeState.loLen);
    WH_T32(magic, dest, src, resumeState.hashType);
    /* A request always carries intermediate state, even on the last block */
    _TranslateSha2State(magic, dest->resumeState.hash, src->resumeState.hash,
                        (uint32_t)sizeof(src->resumeState.hash),
                        (uint32_t)sizeof(uint64_t));
    WH_T32(magic, dest, src, isLastBlock);
    WH_T32(magic, dest, src, inSz);
    return 0;
}
#endif /* WOLFSSL_SHA512 || WOLFSSL_SHA384 */

/* SHA2 Response translation, treating hash as a finalized digest */
int wh_MessageCrypto_TranslateSha2Response(
    uint16_t magic, const whMessageCrypto_Sha2Response* src,
    whMessageCrypto_Sha2Response* dest)
{
    return wh_MessageCrypto_TranslateSha2Response_ex(magic, src, dest, 0);
}

/* SHA2 Response translation. stateWordSize is the chaining word size when hash
 * carries intermediate state, or 0 when it carries a finalized digest. */
int wh_MessageCrypto_TranslateSha2Response_ex(
    uint16_t magic, const whMessageCrypto_Sha2Response* src,
    whMessageCrypto_Sha2Response* dest, uint32_t stateWordSize)
{
    if ((src == NULL) || (dest == NULL)) {
        return WH_ERROR_BADARGS;
    }
    WH_T32(magic, dest, src, hiLen);
    WH_T32(magic, dest, src, loLen);
    WH_T32(magic, dest, src, hashType);
    _TranslateSha2State(magic, dest->hash, src->hash,
                        (uint32_t)sizeof(src->hash), stateWordSize);
    return 0;
}

/* SHA3 state translation - shared across all SHA3 variants and across the
 * non-DMA and DMA wire formats. */
int wh_MessageCrypto_TranslateSha3State(uint16_t                         magic,
                                        const whMessageCrypto_Sha3State* src,
                                        whMessageCrypto_Sha3State*       dest)
{
    int k;

    if ((src == NULL) || (dest == NULL)) {
        return WH_ERROR_BADARGS;
    }
    for (k = 0; k < 25; k++) {
        WH_T64(magic, dest, src, s[k]);
    }
    return 0;
}

/* SHA3 Request translation. Trailing input bytes are raw and need no
 * translation. */
int wh_MessageCrypto_TranslateSha3Request(
    uint16_t magic, const whMessageCrypto_Sha3Request* src,
    whMessageCrypto_Sha3Request* dest)
{
    if ((src == NULL) || (dest == NULL)) {
        return WH_ERROR_BADARGS;
    }
    WH_T32(magic, dest, src, isLastBlock);
    WH_T32(magic, dest, src, inSz);
    return wh_MessageCrypto_TranslateSha3State(magic, &src->resumeState,
                                               &dest->resumeState);
}

/* SHA3 Response translation */
int wh_MessageCrypto_TranslateSha3Response(
    uint16_t magic, const whMessageCrypto_Sha3Response* src,
    whMessageCrypto_Sha3Response* dest)
{
    int ret;

    if ((src == NULL) || (dest == NULL)) {
        return WH_ERROR_BADARGS;
    }
    ret = wh_MessageCrypto_TranslateSha3State(magic, &src->resumeState,
                                              &dest->resumeState);
    if (ret != 0) {
        return ret;
    }
    if (src != dest) {
        memcpy(dest->hash, src->hash, sizeof(src->hash));
    }
    return 0;
}


/* CMAC-AES State translation */
int wh_MessageCrypto_TranslateCmacAesState(
    uint16_t magic, const whMessageCrypto_CmacAesState* src,
    whMessageCrypto_CmacAesState* dest)
{
    if ((src == NULL) || (dest == NULL)) {
        return WH_ERROR_BADARGS;
    }
    /* buffer and digest are byte arrays - memcpy, no endian swap */
    memcpy(dest->buffer, src->buffer, sizeof(dest->buffer));
    memcpy(dest->digest, src->digest, sizeof(dest->digest));
    WH_T32(magic, dest, src, bufferSz);
    WH_T32(magic, dest, src, totalSz);
    return 0;
}

/* CMAC-AES Request translation */
int wh_MessageCrypto_TranslateCmacAesRequest(
    uint16_t magic, const whMessageCrypto_CmacAesRequest* src,
    whMessageCrypto_CmacAesRequest* dest)
{
    if ((src == NULL) || (dest == NULL)) {
        return WH_ERROR_BADARGS;
    }
    WH_T32(magic, dest, src, outSz);
    WH_T32(magic, dest, src, inSz);
    WH_T32(magic, dest, src, keySz);
    WH_T16(magic, dest, src, keyId);
    return wh_MessageCrypto_TranslateCmacAesState(magic, &src->resumeState,
                                                  &dest->resumeState);
}

/* CMAC-AES Response translation */
int wh_MessageCrypto_TranslateCmacAesResponse(
    uint16_t magic, const whMessageCrypto_CmacAesResponse* src,
    whMessageCrypto_CmacAesResponse* dest)
{
    if ((src == NULL) || (dest == NULL)) {
        return WH_ERROR_BADARGS;
    }
    WH_T32(magic, dest, src, outSz);
    WH_T16(magic, dest, src, keyId);
    return wh_MessageCrypto_TranslateCmacAesState(magic, &src->resumeState,
                                                  &dest->resumeState);
}

/* ML-DSA Key Generation Request translation */
int wh_MessageCrypto_TranslateMlDsaKeyGenRequest(
    uint16_t magic, const whMessageCrypto_MlDsaKeyGenRequest* src,
    whMessageCrypto_MlDsaKeyGenRequest* dest)
{
    if ((src == NULL) || (dest == NULL)) {
        return WH_ERROR_BADARGS;
    }
    WH_T32(magic, dest, src, sz);
    WH_T32(magic, dest, src, level);
    WH_T32(magic, dest, src, keyId);
    WH_T32(magic, dest, src, flags);
    WH_T32(magic, dest, src, access);
    /* Label is just a byte array, no translation needed */
    if (src != dest) {
        memcpy(dest->label, src->label, sizeof(src->label));
    }
    return 0;
}

/* ML-DSA Key Generation Response translation */
int wh_MessageCrypto_TranslateMlDsaKeyGenResponse(
    uint16_t magic, const whMessageCrypto_MlDsaKeyGenResponse* src,
    whMessageCrypto_MlDsaKeyGenResponse* dest)
{
    if ((src == NULL) || (dest == NULL)) {
        return WH_ERROR_BADARGS;
    }
    WH_T32(magic, dest, src, keyId);
    WH_T32(magic, dest, src, len);
    return 0;
}

/* ML-DSA Sign Request translation */
int wh_MessageCrypto_TranslateMlDsaSignRequest(
    uint16_t magic, const whMessageCrypto_MlDsaSignRequest* src,
    whMessageCrypto_MlDsaSignRequest* dest)
{
    if ((src == NULL) || (dest == NULL)) {
        return WH_ERROR_BADARGS;
    }
    WH_T32(magic, dest, src, options);
    WH_T32(magic, dest, src, level);
    WH_T32(magic, dest, src, keyId);
    WH_T32(magic, dest, src, sz);
    WH_T32(magic, dest, src, contextSz);
    WH_T32(magic, dest, src, preHashType);
    return 0;
}

/* ML-DSA Sign Response translation */
int wh_MessageCrypto_TranslateMlDsaSignResponse(
    uint16_t magic, const whMessageCrypto_MlDsaSignResponse* src,
    whMessageCrypto_MlDsaSignResponse* dest)
{
    if ((src == NULL) || (dest == NULL)) {
        return WH_ERROR_BADARGS;
    }
    WH_T32(magic, dest, src, sz);
    return 0;
}

/* ML-DSA Verify Request translation */
int wh_MessageCrypto_TranslateMlDsaVerifyRequest(
    uint16_t magic, const whMessageCrypto_MlDsaVerifyRequest* src,
    whMessageCrypto_MlDsaVerifyRequest* dest)
{
    if ((src == NULL) || (dest == NULL)) {
        return WH_ERROR_BADARGS;
    }
    WH_T32(magic, dest, src, options);
    WH_T32(magic, dest, src, level);
    WH_T32(magic, dest, src, keyId);
    WH_T32(magic, dest, src, sigSz);
    WH_T32(magic, dest, src, hashSz);
    WH_T32(magic, dest, src, contextSz);
    WH_T32(magic, dest, src, preHashType);
    return 0;
}

/* ML-DSA Verify Response translation */
int wh_MessageCrypto_TranslateMlDsaVerifyResponse(
    uint16_t magic, const whMessageCrypto_MlDsaVerifyResponse* src,
    whMessageCrypto_MlDsaVerifyResponse* dest)
{
    if ((src == NULL) || (dest == NULL)) {
        return WH_ERROR_BADARGS;
    }
    WH_T32(magic, dest, src, res);
    return 0;
}

/* ML-KEM Key Generation Request translation */
int wh_MessageCrypto_TranslateMlKemKeyGenRequest(
    uint16_t magic, const whMessageCrypto_MlKemKeyGenRequest* src,
    whMessageCrypto_MlKemKeyGenRequest* dest)
{
    if ((src == NULL) || (dest == NULL)) {
        return WH_ERROR_BADARGS;
    }
    WH_T32(magic, dest, src, level);
    WH_T32(magic, dest, src, keyId);
    WH_T32(magic, dest, src, flags);
    WH_T32(magic, dest, src, access);
    if (src != dest) {
        memcpy(dest->label, src->label, sizeof(src->label));
    }
    return 0;
}

/* ML-KEM Key Generation Response translation */
int wh_MessageCrypto_TranslateMlKemKeyGenResponse(
    uint16_t magic, const whMessageCrypto_MlKemKeyGenResponse* src,
    whMessageCrypto_MlKemKeyGenResponse* dest)
{
    if ((src == NULL) || (dest == NULL)) {
        return WH_ERROR_BADARGS;
    }
    WH_T32(magic, dest, src, keyId);
    WH_T32(magic, dest, src, len);
    return 0;
}

/* ML-KEM Encapsulation Request translation */
int wh_MessageCrypto_TranslateMlKemEncapsRequest(
    uint16_t magic, const whMessageCrypto_MlKemEncapsRequest* src,
    whMessageCrypto_MlKemEncapsRequest* dest)
{
    if ((src == NULL) || (dest == NULL)) {
        return WH_ERROR_BADARGS;
    }
    WH_T32(magic, dest, src, options);
    WH_T32(magic, dest, src, level);
    WH_T32(magic, dest, src, keyId);
    return 0;
}

/* ML-KEM Encapsulation Response translation */
int wh_MessageCrypto_TranslateMlKemEncapsResponse(
    uint16_t magic, const whMessageCrypto_MlKemEncapsResponse* src,
    whMessageCrypto_MlKemEncapsResponse* dest)
{
    if ((src == NULL) || (dest == NULL)) {
        return WH_ERROR_BADARGS;
    }
    WH_T32(magic, dest, src, ctSz);
    WH_T32(magic, dest, src, ssSz);
    return 0;
}

/* ML-KEM Decapsulation Request translation */
int wh_MessageCrypto_TranslateMlKemDecapsRequest(
    uint16_t magic, const whMessageCrypto_MlKemDecapsRequest* src,
    whMessageCrypto_MlKemDecapsRequest* dest)
{
    if ((src == NULL) || (dest == NULL)) {
        return WH_ERROR_BADARGS;
    }
    WH_T32(magic, dest, src, options);
    WH_T32(magic, dest, src, level);
    WH_T32(magic, dest, src, keyId);
    WH_T32(magic, dest, src, ctSz);
    return 0;
}

/* ML-KEM Decapsulation Response translation */
int wh_MessageCrypto_TranslateMlKemDecapsResponse(
    uint16_t magic, const whMessageCrypto_MlKemDecapsResponse* src,
    whMessageCrypto_MlKemDecapsResponse* dest)
{
    if ((src == NULL) || (dest == NULL)) {
        return WH_ERROR_BADARGS;
    }
    WH_T32(magic, dest, src, ssSz);
    return 0;
}

/*
 * DMA Messages
 */

/* DMA Buffer translation */
static int
wh_MessageCrypto_TranslateDmaBuffer(uint16_t                         magic,
                                    const whMessageCrypto_DmaBuffer* src,
                                    whMessageCrypto_DmaBuffer*       dest)
{
    if ((src == NULL) || (dest == NULL)) {
        return WH_ERROR_BADARGS;
    }
    WH_T64(magic, dest, src, addr);
    WH_T64(magic, dest, src, sz);
    return 0;
}

/* DMA Address status translation */
static int wh_MessageCrypto_TranslateDmaAddrStatus(
    uint16_t magic, const whMessageCrypto_DmaAddrStatus* src,
    whMessageCrypto_DmaAddrStatus* dest)
{
    if ((src == NULL) || (dest == NULL)) {
        return WH_ERROR_BADARGS;
    }
    return wh_MessageCrypto_TranslateDmaBuffer(magic, &src->badAddr,
                                               &dest->badAddr);
}

/* SHA256/SHA224 DMA Request translation */
int wh_MessageCrypto_TranslateSha256DmaRequest(
    uint16_t magic, const whMessageCrypto_Sha256DmaRequest* src,
    whMessageCrypto_Sha256DmaRequest* dest)
{
    int ret;

    if ((src == NULL) || (dest == NULL)) {
        return WH_ERROR_BADARGS;
    }

    WH_T32(magic, dest, src, resumeState.hiLen);
    WH_T32(magic, dest, src, resumeState.loLen);
    _TranslateSha2State(magic, dest->resumeState.hash, src->resumeState.hash,
                        (uint32_t)sizeof(src->resumeState.hash),
                        (uint32_t)sizeof(uint32_t));

    ret = wh_MessageCrypto_TranslateDmaBuffer(magic, &src->input, &dest->input);
    if (ret != 0) {
        return ret;
    }

    WH_T32(magic, dest, src, isLastBlock);
    WH_T32(magic, dest, src, inSz);

    return 0;
}

/* SHA512/SHA384 DMA Request translation */
int wh_MessageCrypto_TranslateSha512DmaRequest(
    uint16_t magic, const whMessageCrypto_Sha512DmaRequest* src,
    whMessageCrypto_Sha512DmaRequest* dest)
{
    int ret;

    if ((src == NULL) || (dest == NULL)) {
        return WH_ERROR_BADARGS;
    }

    WH_T32(magic, dest, src, resumeState.hiLen);
    WH_T32(magic, dest, src, resumeState.loLen);
    _TranslateSha2State(magic, dest->resumeState.hash, src->resumeState.hash,
                        (uint32_t)sizeof(src->resumeState.hash),
                        (uint32_t)sizeof(uint64_t));
    WH_T32(magic, dest, src, resumeState.hashType);

    ret = wh_MessageCrypto_TranslateDmaBuffer(magic, &src->input, &dest->input);
    if (ret != 0) {
        return ret;
    }

    WH_T32(magic, dest, src, isLastBlock);
    WH_T32(magic, dest, src, inSz);

    return 0;
}

/* SHA2 DMA Response translation, treating hash as a finalized digest */
int wh_MessageCrypto_TranslateSha2DmaResponse(
    uint16_t magic, const whMessageCrypto_Sha2DmaResponse* src,
    whMessageCrypto_Sha2DmaResponse* dest)
{
    return wh_MessageCrypto_TranslateSha2DmaResponse_ex(magic, src, dest, 0);
}

/* SHA2 DMA Response translation. stateWordSize is the chaining word size when
 * hash carries intermediate state, or 0 when it carries a finalized digest. */
int wh_MessageCrypto_TranslateSha2DmaResponse_ex(
    uint16_t magic, const whMessageCrypto_Sha2DmaResponse* src,
    whMessageCrypto_Sha2DmaResponse* dest, uint32_t stateWordSize)
{
    if ((src == NULL) || (dest == NULL)) {
        return WH_ERROR_BADARGS;
    }

    WH_T32(magic, dest, src, hiLen);
    WH_T32(magic, dest, src, loLen);
    _TranslateSha2State(magic, dest->hash, src->hash,
                        (uint32_t)sizeof(src->hash), stateWordSize);
    WH_T32(magic, dest, src, hashType);

    return wh_MessageCrypto_TranslateDmaAddrStatus(magic, &src->dmaAddrStatus,
                                                   &dest->dmaAddrStatus);
}

/* SHA3 DMA Request translation */
int wh_MessageCrypto_TranslateSha3DmaRequest(
    uint16_t magic, const whMessageCrypto_Sha3DmaRequest* src,
    whMessageCrypto_Sha3DmaRequest* dest)
{
    int ret;

    if ((src == NULL) || (dest == NULL)) {
        return WH_ERROR_BADARGS;
    }
    ret = wh_MessageCrypto_TranslateDmaBuffer(magic, &src->input, &dest->input);
    if (ret != 0) {
        return ret;
    }
    WH_T32(magic, dest, src, isLastBlock);
    WH_T32(magic, dest, src, inSz);
    return wh_MessageCrypto_TranslateSha3State(magic, &src->resumeState,
                                               &dest->resumeState);
}

/* SHA3 DMA Response translation */
int wh_MessageCrypto_TranslateSha3DmaResponse(
    uint16_t magic, const whMessageCrypto_Sha3DmaResponse* src,
    whMessageCrypto_Sha3DmaResponse* dest)
{
    int ret;

    if ((src == NULL) || (dest == NULL)) {
        return WH_ERROR_BADARGS;
    }
    ret = wh_MessageCrypto_TranslateSha3State(magic, &src->resumeState,
                                              &dest->resumeState);
    if (ret != 0) {
        return ret;
    }
    if (src != dest) {
        memcpy(dest->hash, src->hash, sizeof(src->hash));
    }
    return wh_MessageCrypto_TranslateDmaAddrStatus(magic, &src->dmaAddrStatus,
                                                   &dest->dmaAddrStatus);
}

/* CMAC-AES DMA Request translation */
int wh_MessageCrypto_TranslateCmacAesDmaRequest(
    uint16_t magic, const whMessageCrypto_CmacAesDmaRequest* src,
    whMessageCrypto_CmacAesDmaRequest* dest)
{
    int ret;

    if ((src == NULL) || (dest == NULL)) {
        return WH_ERROR_BADARGS;
    }

    ret = wh_MessageCrypto_TranslateDmaBuffer(magic, &src->input, &dest->input);
    if (ret != 0) {
        return ret;
    }

    WH_T32(magic, dest, src, outSz);
    WH_T32(magic, dest, src, keySz);
    WH_T32(magic, dest, src, inlineInSz);
    WH_T16(magic, dest, src, keyId);

    ret = wh_MessageCrypto_TranslateCmacAesState(magic, &src->resumeState,
                                                 &dest->resumeState);
    return ret;
}

/* CMAC-AES DMA Response translation */
int wh_MessageCrypto_TranslateCmacAesDmaResponse(
    uint16_t magic, const whMessageCrypto_CmacAesDmaResponse* src,
    whMessageCrypto_CmacAesDmaResponse* dest)
{
    int ret;

    if ((src == NULL) || (dest == NULL)) {
        return WH_ERROR_BADARGS;
    }

    ret = wh_MessageCrypto_TranslateDmaAddrStatus(magic, &src->dmaAddrStatus,
                                                  &dest->dmaAddrStatus);
    if (ret != 0) {
        return ret;
    }

    WH_T32(magic, dest, src, outSz);
    WH_T16(magic, dest, src, keyId);

    ret = wh_MessageCrypto_TranslateCmacAesState(magic, &src->resumeState,
                                                 &dest->resumeState);
    return ret;
}

/* ML-DSA DMA Key Generation Request translation */
int wh_MessageCrypto_TranslateMlDsaKeyGenDmaRequest(
    uint16_t magic, const whMessageCrypto_MlDsaKeyGenDmaRequest* src,
    whMessageCrypto_MlDsaKeyGenDmaRequest* dest)
{
    int ret;

    if ((src == NULL) || (dest == NULL)) {
        return WH_ERROR_BADARGS;
    }

    ret = wh_MessageCrypto_TranslateDmaBuffer(magic, &src->key, &dest->key);
    if (ret != 0) {
        return ret;
    }

    WH_T32(magic, dest, src, level);
    WH_T32(magic, dest, src, flags);
    WH_T32(magic, dest, src, keyId);
    WH_T32(magic, dest, src, access);
    WH_T32(magic, dest, src, labelSize);
    /* Label is just a byte array, no translation needed */
    if (src != dest) {
        memcpy(dest->label, src->label, sizeof(src->label));
    }

    return 0;
}

/* ML-DSA DMA Response translation */
int wh_MessageCrypto_TranslateMlDsaKeyGenDmaResponse(
    uint16_t magic, const whMessageCrypto_MlDsaKeyGenDmaResponse* src,
    whMessageCrypto_MlDsaKeyGenDmaResponse* dest)
{
    int ret;

    if ((src == NULL) || (dest == NULL)) {
        return WH_ERROR_BADARGS;
    }

    ret = wh_MessageCrypto_TranslateDmaAddrStatus(magic, &src->dmaAddrStatus,
                                                  &dest->dmaAddrStatus);
    if (ret != 0) {
        return ret;
    }

    WH_T32(magic, dest, src, keyId);
    WH_T32(magic, dest, src, keySize);
    return 0;
}

/* ML-DSA DMA Sign Request translation */
int wh_MessageCrypto_TranslateMlDsaSignDmaRequest(
    uint16_t magic, const whMessageCrypto_MlDsaSignDmaRequest* src,
    whMessageCrypto_MlDsaSignDmaRequest* dest)
{
    int ret;

    if ((src == NULL) || (dest == NULL)) {
        return WH_ERROR_BADARGS;
    }

    ret = wh_MessageCrypto_TranslateDmaBuffer(magic, &src->msg, &dest->msg);
    if (ret != 0) {
        return ret;
    }

    ret = wh_MessageCrypto_TranslateDmaBuffer(magic, &src->sig, &dest->sig);
    if (ret != 0) {
        return ret;
    }

    WH_T32(magic, dest, src, options);
    WH_T32(magic, dest, src, level);
    WH_T32(magic, dest, src, keyId);
    WH_T32(magic, dest, src, contextSz);
    WH_T32(magic, dest, src, preHashType);

    return 0;
}

/* ML-DSA DMA Sign Response translation */
int wh_MessageCrypto_TranslateMlDsaSignDmaResponse(
    uint16_t magic, const whMessageCrypto_MlDsaSignDmaResponse* src,
    whMessageCrypto_MlDsaSignDmaResponse* dest)
{
    int ret;

    if ((src == NULL) || (dest == NULL)) {
        return WH_ERROR_BADARGS;
    }

    ret = wh_MessageCrypto_TranslateDmaAddrStatus(magic, &src->dmaAddrStatus,
                                                  &dest->dmaAddrStatus);
    if (ret != 0) {
        return ret;
    }

    WH_T32(magic, dest, src, sigLen);
    return 0;
}

/* ML-DSA DMA Verify Request translation */
int wh_MessageCrypto_TranslateMlDsaVerifyDmaRequest(
    uint16_t magic, const whMessageCrypto_MlDsaVerifyDmaRequest* src,
    whMessageCrypto_MlDsaVerifyDmaRequest* dest)
{
    int ret;

    if ((src == NULL) || (dest == NULL)) {
        return WH_ERROR_BADARGS;
    }

    ret = wh_MessageCrypto_TranslateDmaBuffer(magic, &src->sig, &dest->sig);
    if (ret != 0) {
        return ret;
    }

    ret = wh_MessageCrypto_TranslateDmaBuffer(magic, &src->msg, &dest->msg);
    if (ret != 0) {
        return ret;
    }

    WH_T32(magic, dest, src, options);
    WH_T32(magic, dest, src, level);
    WH_T32(magic, dest, src, keyId);
    WH_T32(magic, dest, src, contextSz);
    WH_T32(magic, dest, src, preHashType);

    return 0;
}

/* ML-DSA DMA Verify Response translation */
int wh_MessageCrypto_TranslateMlDsaVerifyDmaResponse(
    uint16_t magic, const whMessageCrypto_MlDsaVerifyDmaResponse* src,
    whMessageCrypto_MlDsaVerifyDmaResponse* dest)
{
    int ret;

    if ((src == NULL) || (dest == NULL)) {
        return WH_ERROR_BADARGS;
    }

    ret = wh_MessageCrypto_TranslateDmaAddrStatus(magic, &src->dmaAddrStatus,
                                                  &dest->dmaAddrStatus);
    if (ret != 0) {
        return ret;
    }

    WH_T32(magic, dest, src, verifyResult);
    return 0;
}

/* ML-KEM DMA Key Generation Request translation */
int wh_MessageCrypto_TranslateMlKemKeyGenDmaRequest(
    uint16_t magic, const whMessageCrypto_MlKemKeyGenDmaRequest* src,
    whMessageCrypto_MlKemKeyGenDmaRequest* dest)
{
    int ret;

    if ((src == NULL) || (dest == NULL)) {
        return WH_ERROR_BADARGS;
    }

    ret = wh_MessageCrypto_TranslateDmaBuffer(magic, &src->key, &dest->key);
    if (ret != 0) {
        return ret;
    }

    WH_T32(magic, dest, src, level);
    WH_T32(magic, dest, src, flags);
    WH_T32(magic, dest, src, keyId);
    WH_T32(magic, dest, src, access);
    WH_T32(magic, dest, src, labelSize);
    if (src != dest) {
        memcpy(dest->label, src->label, sizeof(src->label));
    }

    return 0;
}

/* ML-KEM DMA Key Generation Response translation */
int wh_MessageCrypto_TranslateMlKemKeyGenDmaResponse(
    uint16_t magic, const whMessageCrypto_MlKemKeyGenDmaResponse* src,
    whMessageCrypto_MlKemKeyGenDmaResponse* dest)
{
    int ret;

    if ((src == NULL) || (dest == NULL)) {
        return WH_ERROR_BADARGS;
    }

    ret = wh_MessageCrypto_TranslateDmaAddrStatus(magic, &src->dmaAddrStatus,
                                                  &dest->dmaAddrStatus);
    if (ret != 0) {
        return ret;
    }

    WH_T32(magic, dest, src, keyId);
    WH_T32(magic, dest, src, keySize);
    return 0;
}

/* ML-KEM DMA Encapsulation Request translation */
int wh_MessageCrypto_TranslateMlKemEncapsDmaRequest(
    uint16_t magic, const whMessageCrypto_MlKemEncapsDmaRequest* src,
    whMessageCrypto_MlKemEncapsDmaRequest* dest)
{
    int ret;

    if ((src == NULL) || (dest == NULL)) {
        return WH_ERROR_BADARGS;
    }

    ret = wh_MessageCrypto_TranslateDmaBuffer(magic, &src->ct, &dest->ct);
    if (ret != 0) {
        return ret;
    }

    WH_T32(magic, dest, src, options);
    WH_T32(magic, dest, src, level);
    WH_T32(magic, dest, src, keyId);
    return 0;
}

/* ML-KEM DMA Encapsulation Response translation */
int wh_MessageCrypto_TranslateMlKemEncapsDmaResponse(
    uint16_t magic, const whMessageCrypto_MlKemEncapsDmaResponse* src,
    whMessageCrypto_MlKemEncapsDmaResponse* dest)
{
    int ret;

    if ((src == NULL) || (dest == NULL)) {
        return WH_ERROR_BADARGS;
    }

    ret = wh_MessageCrypto_TranslateDmaAddrStatus(magic, &src->dmaAddrStatus,
                                                  &dest->dmaAddrStatus);
    if (ret != 0) {
        return ret;
    }

    WH_T32(magic, dest, src, ctLen);
    WH_T32(magic, dest, src, ssLen);
    return 0;
}

/* ML-KEM DMA Decapsulation Request translation */
int wh_MessageCrypto_TranslateMlKemDecapsDmaRequest(
    uint16_t magic, const whMessageCrypto_MlKemDecapsDmaRequest* src,
    whMessageCrypto_MlKemDecapsDmaRequest* dest)
{
    int ret;

    if ((src == NULL) || (dest == NULL)) {
        return WH_ERROR_BADARGS;
    }

    ret = wh_MessageCrypto_TranslateDmaBuffer(magic, &src->ct, &dest->ct);
    if (ret != 0) {
        return ret;
    }

    WH_T32(magic, dest, src, options);
    WH_T32(magic, dest, src, level);
    WH_T32(magic, dest, src, keyId);
    return 0;
}

/* ML-KEM DMA Decapsulation Response translation */
int wh_MessageCrypto_TranslateMlKemDecapsDmaResponse(
    uint16_t magic, const whMessageCrypto_MlKemDecapsDmaResponse* src,
    whMessageCrypto_MlKemDecapsDmaResponse* dest)
{
    int ret;

    if ((src == NULL) || (dest == NULL)) {
        return WH_ERROR_BADARGS;
    }

    ret = wh_MessageCrypto_TranslateDmaAddrStatus(magic, &src->dmaAddrStatus,
                                                  &dest->dmaAddrStatus);
    if (ret != 0) {
        return ret;
    }

    WH_T32(magic, dest, src, ssLen);
    return 0;
}

/* Stateful sig DMA Key Generation Request translation */
int wh_MessageCrypto_TranslatePqcStatefulSigKeyGenDmaRequest(
    uint16_t magic,
    const whMessageCrypto_PqcStatefulSigKeyGenDmaRequest* src,
    whMessageCrypto_PqcStatefulSigKeyGenDmaRequest* dest)
{
    int ret;

    if ((src == NULL) || (dest == NULL)) {
        return WH_ERROR_BADARGS;
    }

    ret = wh_MessageCrypto_TranslateDmaBuffer(magic, &src->pub, &dest->pub);
    if (ret != 0) {
        return ret;
    }

    WH_T32(magic, dest, src, flags);
    WH_T32(magic, dest, src, keyId);
    WH_T32(magic, dest, src, access);
    WH_T32(magic, dest, src, labelSize);
    WH_T32(magic, dest, src, lmsLevels);
    WH_T32(magic, dest, src, lmsHeight);
    WH_T32(magic, dest, src, lmsWinternitz);
    if (src != dest) {
        memcpy(dest->label, src->label, sizeof(src->label));
        memcpy(dest->xmssParamStr, src->xmssParamStr,
               sizeof(src->xmssParamStr));
    }
    return 0;
}

/* Stateful sig DMA Key Generation Response translation */
int wh_MessageCrypto_TranslatePqcStatefulSigKeyGenDmaResponse(
    uint16_t magic,
    const whMessageCrypto_PqcStatefulSigKeyGenDmaResponse* src,
    whMessageCrypto_PqcStatefulSigKeyGenDmaResponse* dest)
{
    int ret;

    if ((src == NULL) || (dest == NULL)) {
        return WH_ERROR_BADARGS;
    }

    ret = wh_MessageCrypto_TranslateDmaAddrStatus(magic, &src->dmaAddrStatus,
                                                  &dest->dmaAddrStatus);
    if (ret != 0) {
        return ret;
    }

    WH_T32(magic, dest, src, keyId);
    WH_T32(magic, dest, src, pubSize);
    return 0;
}

/* Stateful sig DMA Sign Request translation */
int wh_MessageCrypto_TranslatePqcStatefulSigSignDmaRequest(
    uint16_t magic,
    const whMessageCrypto_PqcStatefulSigSignDmaRequest* src,
    whMessageCrypto_PqcStatefulSigSignDmaRequest* dest)
{
    int ret;

    if ((src == NULL) || (dest == NULL)) {
        return WH_ERROR_BADARGS;
    }

    ret = wh_MessageCrypto_TranslateDmaBuffer(magic, &src->msg, &dest->msg);
    if (ret != 0) {
        return ret;
    }
    ret = wh_MessageCrypto_TranslateDmaBuffer(magic, &src->sig, &dest->sig);
    if (ret != 0) {
        return ret;
    }

    WH_T32(magic, dest, src, options);
    WH_T32(magic, dest, src, keyId);
    return 0;
}

/* Stateful sig DMA Sign Response translation */
int wh_MessageCrypto_TranslatePqcStatefulSigSignDmaResponse(
    uint16_t magic,
    const whMessageCrypto_PqcStatefulSigSignDmaResponse* src,
    whMessageCrypto_PqcStatefulSigSignDmaResponse* dest)
{
    int ret;

    if ((src == NULL) || (dest == NULL)) {
        return WH_ERROR_BADARGS;
    }

    ret = wh_MessageCrypto_TranslateDmaAddrStatus(magic, &src->dmaAddrStatus,
                                                  &dest->dmaAddrStatus);
    if (ret != 0) {
        return ret;
    }

    WH_T32(magic, dest, src, sigLen);
    return 0;
}

/* Stateful sig DMA Verify Request translation */
int wh_MessageCrypto_TranslatePqcStatefulSigVerifyDmaRequest(
    uint16_t magic,
    const whMessageCrypto_PqcStatefulSigVerifyDmaRequest* src,
    whMessageCrypto_PqcStatefulSigVerifyDmaRequest* dest)
{
    int ret;

    if ((src == NULL) || (dest == NULL)) {
        return WH_ERROR_BADARGS;
    }

    ret = wh_MessageCrypto_TranslateDmaBuffer(magic, &src->sig, &dest->sig);
    if (ret != 0) {
        return ret;
    }
    ret = wh_MessageCrypto_TranslateDmaBuffer(magic, &src->msg, &dest->msg);
    if (ret != 0) {
        return ret;
    }

    WH_T32(magic, dest, src, options);
    WH_T32(magic, dest, src, keyId);
    return 0;
}

/* Stateful sig DMA Verify Response translation */
int wh_MessageCrypto_TranslatePqcStatefulSigVerifyDmaResponse(
    uint16_t magic,
    const whMessageCrypto_PqcStatefulSigVerifyDmaResponse* src,
    whMessageCrypto_PqcStatefulSigVerifyDmaResponse* dest)
{
    int ret;

    if ((src == NULL) || (dest == NULL)) {
        return WH_ERROR_BADARGS;
    }

    ret = wh_MessageCrypto_TranslateDmaAddrStatus(magic, &src->dmaAddrStatus,
                                                  &dest->dmaAddrStatus);
    if (ret != 0) {
        return ret;
    }

    WH_T32(magic, dest, src, res);
    return 0;
}

/* Stateful sig DMA Signatures-Left Request translation */
int wh_MessageCrypto_TranslatePqcStatefulSigSigsLeftDmaRequest(
    uint16_t magic,
    const whMessageCrypto_PqcStatefulSigSigsLeftDmaRequest* src,
    whMessageCrypto_PqcStatefulSigSigsLeftDmaRequest* dest)
{
    if ((src == NULL) || (dest == NULL)) {
        return WH_ERROR_BADARGS;
    }

    WH_T32(magic, dest, src, keyId);
    return 0;
}

/* Stateful sig DMA Signatures-Left Response translation */
int wh_MessageCrypto_TranslatePqcStatefulSigSigsLeftDmaResponse(
    uint16_t magic,
    const whMessageCrypto_PqcStatefulSigSigsLeftDmaResponse* src,
    whMessageCrypto_PqcStatefulSigSigsLeftDmaResponse* dest)
{
    if ((src == NULL) || (dest == NULL)) {
        return WH_ERROR_BADARGS;
    }

    WH_T32(magic, dest, src, sigsLeft);
    return 0;
}

/* Ed25519 DMA Sign Request translation */
int wh_MessageCrypto_TranslateEd25519SignDmaRequest(
    uint16_t magic, const whMessageCrypto_Ed25519SignDmaRequest* src,
    whMessageCrypto_Ed25519SignDmaRequest* dest)
{
    int ret;

    if ((src == NULL) || (dest == NULL)) {
        return WH_ERROR_BADARGS;
    }

    ret = wh_MessageCrypto_TranslateDmaBuffer(magic, &src->msg, &dest->msg);
    if (ret != 0) {
        return ret;
    }

    ret = wh_MessageCrypto_TranslateDmaBuffer(magic, &src->sig, &dest->sig);
    if (ret != 0) {
        return ret;
    }

    ret = wh_MessageCrypto_TranslateDmaBuffer(magic, &src->pub, &dest->pub);
    if (ret != 0) {
        return ret;
    }

    WH_T32(magic, dest, src, options);
    WH_T32(magic, dest, src, keyId);
    WH_T32(magic, dest, src, type);
    WH_T32(magic, dest, src, ctxSz);
    return 0;
}

/* Ed25519 DMA Sign Response translation */
int wh_MessageCrypto_TranslateEd25519SignDmaResponse(
    uint16_t magic, const whMessageCrypto_Ed25519SignDmaResponse* src,
    whMessageCrypto_Ed25519SignDmaResponse* dest)
{
    int ret;

    if ((src == NULL) || (dest == NULL)) {
        return WH_ERROR_BADARGS;
    }

    ret = wh_MessageCrypto_TranslateDmaAddrStatus(magic, &src->dmaAddrStatus,
                                                  &dest->dmaAddrStatus);
    if (ret != 0) {
        return ret;
    }

    WH_T32(magic, dest, src, sigSz);
    WH_T32(magic, dest, src, pubSz);
    return 0;
}

/* Ed25519 DMA Verify Request translation */
int wh_MessageCrypto_TranslateEd25519VerifyDmaRequest(
    uint16_t magic, const whMessageCrypto_Ed25519VerifyDmaRequest* src,
    whMessageCrypto_Ed25519VerifyDmaRequest* dest)
{
    int ret;

    if ((src == NULL) || (dest == NULL)) {
        return WH_ERROR_BADARGS;
    }

    ret = wh_MessageCrypto_TranslateDmaBuffer(magic, &src->sig, &dest->sig);
    if (ret != 0) {
        return ret;
    }

    ret = wh_MessageCrypto_TranslateDmaBuffer(magic, &src->msg, &dest->msg);
    if (ret != 0) {
        return ret;
    }

    ret = wh_MessageCrypto_TranslateDmaBuffer(magic, &src->pub, &dest->pub);
    if (ret != 0) {
        return ret;
    }

    WH_T32(magic, dest, src, options);
    WH_T32(magic, dest, src, keyId);
    WH_T32(magic, dest, src, type);
    WH_T32(magic, dest, src, ctxSz);
    return 0;
}

/* Ed25519 DMA Verify Response translation */
int wh_MessageCrypto_TranslateEd25519VerifyDmaResponse(
    uint16_t magic, const whMessageCrypto_Ed25519VerifyDmaResponse* src,
    whMessageCrypto_Ed25519VerifyDmaResponse* dest)
{
    int ret;

    if ((src == NULL) || (dest == NULL)) {
        return WH_ERROR_BADARGS;
    }

    ret = wh_MessageCrypto_TranslateDmaAddrStatus(magic, &src->dmaAddrStatus,
                                                  &dest->dmaAddrStatus);
    if (ret != 0) {
        return ret;
    }

    WH_T32(magic, dest, src, verifyResult);
    WH_T32(magic, dest, src, pubSz);
    return 0;
}

/* AES-ECB DMA translation functions */
int wh_MessageCrypto_TranslateAesEcbDmaRequest(
    uint16_t magic, const whMessageCrypto_AesEcbDmaRequest* src,
    whMessageCrypto_AesEcbDmaRequest* dest)
{
    if ((src == NULL) || (dest == NULL)) {
        return WH_ERROR_BADARGS;
    }

    WH_T32(magic, dest, src, enc);
    WH_T32(magic, dest, src, keyId);
    WH_T32(magic, dest, src, keySz);

    (void)wh_MessageCrypto_TranslateDmaBuffer(magic, &src->input, &dest->input);
    (void)wh_MessageCrypto_TranslateDmaBuffer(magic, &src->output,
                                              &dest->output);

    return WH_ERROR_OK;
}

int wh_MessageCrypto_TranslateAesEcbDmaResponse(
    uint16_t magic, const whMessageCrypto_AesEcbDmaResponse* src,
    whMessageCrypto_AesEcbDmaResponse* dest)
{
    if ((src == NULL) || (dest == NULL)) {
        return WH_ERROR_BADARGS;
    }

    (void)wh_MessageCrypto_TranslateDmaAddrStatus(magic, &src->dmaAddrStatus,
                                                  &dest->dmaAddrStatus);

    WH_T32(magic, dest, src, outSz);

    return WH_ERROR_OK;
}

/* AES-CBC DMA translation functions */
int wh_MessageCrypto_TranslateAesCbcDmaRequest(
    uint16_t magic, const whMessageCrypto_AesCbcDmaRequest* src,
    whMessageCrypto_AesCbcDmaRequest* dest)
{
    if ((src == NULL) || (dest == NULL)) {
        return WH_ERROR_BADARGS;
    }

    WH_T32(magic, dest, src, enc);
    WH_T32(magic, dest, src, keyId);
    WH_T32(magic, dest, src, keySz);

    (void)wh_MessageCrypto_TranslateDmaBuffer(magic, &src->input, &dest->input);
    (void)wh_MessageCrypto_TranslateDmaBuffer(magic, &src->output,
                                              &dest->output);

    return WH_ERROR_OK;
}

int wh_MessageCrypto_TranslateAesCbcDmaResponse(
    uint16_t magic, const whMessageCrypto_AesCbcDmaResponse* src,
    whMessageCrypto_AesCbcDmaResponse* dest)
{
    if ((src == NULL) || (dest == NULL)) {
        return WH_ERROR_BADARGS;
    }

    (void)wh_MessageCrypto_TranslateDmaAddrStatus(magic, &src->dmaAddrStatus,
                                                  &dest->dmaAddrStatus);
    WH_T32(magic, dest, src, outSz);

    return WH_ERROR_OK;
}

/* AES-CTR DMA Request translation */
int wh_MessageCrypto_TranslateAesCtrDmaRequest(
    uint16_t magic, const whMessageCrypto_AesCtrDmaRequest* src,
    whMessageCrypto_AesCtrDmaRequest* dest)
{
    if ((src == NULL) || (dest == NULL)) {
        return WH_ERROR_BADARGS;
    }

    WH_T32(magic, dest, src, enc);
    WH_T32(magic, dest, src, left);
    WH_T32(magic, dest, src, keyId);
    WH_T32(magic, dest, src, keySz);

    (void)wh_MessageCrypto_TranslateDmaBuffer(magic, &src->input, &dest->input);
    (void)wh_MessageCrypto_TranslateDmaBuffer(magic, &src->output,
                                              &dest->output);

    return WH_ERROR_OK;
}

/* AES-CTR DMA Response translation */
int wh_MessageCrypto_TranslateAesCtrDmaResponse(
    uint16_t magic, const whMessageCrypto_AesCtrDmaResponse* src,
    whMessageCrypto_AesCtrDmaResponse* dest)
{
    if ((src == NULL) || (dest == NULL)) {
        return WH_ERROR_BADARGS;
    }

    (void)wh_MessageCrypto_TranslateDmaAddrStatus(magic, &src->dmaAddrStatus,
                                                  &dest->dmaAddrStatus);

    WH_T32(magic, dest, src, outSz);
    WH_T32(magic, dest, src, left);

    return WH_ERROR_OK;
}

/* AES-GCM DMA Request translation */
int wh_MessageCrypto_TranslateAesGcmDmaRequest(
    uint16_t magic, const whMessageCrypto_AesGcmDmaRequest* src,
    whMessageCrypto_AesGcmDmaRequest* dest)
{
    if ((src == NULL) || (dest == NULL)) {
        return WH_ERROR_BADARGS;
    }

    WH_T32(magic, dest, src, enc);
    WH_T32(magic, dest, src, keyId);
    WH_T32(magic, dest, src, keySz);
    WH_T32(magic, dest, src, ivSz);
    WH_T32(magic, dest, src, authTagSz);

    (void)wh_MessageCrypto_TranslateDmaBuffer(magic, &src->input, &dest->input);
    (void)wh_MessageCrypto_TranslateDmaBuffer(magic, &src->output, &dest->output);
    (void)wh_MessageCrypto_TranslateDmaBuffer(magic, &src->aad, &dest->aad);

    return WH_ERROR_OK;
}

/* AES-GCM DMA Response translation */
int wh_MessageCrypto_TranslateAesGcmDmaResponse(
    uint16_t magic, const whMessageCrypto_AesGcmDmaResponse* src,
    whMessageCrypto_AesGcmDmaResponse* dest)
{
    if ((src == NULL) || (dest == NULL)) {
        return WH_ERROR_BADARGS;
    }

    (void)wh_MessageCrypto_TranslateDmaAddrStatus(magic, &src->dmaAddrStatus,
                                                  &dest->dmaAddrStatus);

    WH_T32(magic, dest, src, outSz);
    WH_T32(magic, dest, src, authTagSz);

    return WH_ERROR_OK;
}

/* RNG DMA Request translation */
int wh_MessageCrypto_TranslateRngDmaRequest(
    uint16_t magic, const whMessageCrypto_RngDmaRequest* src,
    whMessageCrypto_RngDmaRequest* dest)
{
    if ((src == NULL) || (dest == NULL)) {
        return WH_ERROR_BADARGS;
    }

    return wh_MessageCrypto_TranslateDmaBuffer(magic, &src->output,
                                               &dest->output);
}

/* RNG DMA Response translation */
int wh_MessageCrypto_TranslateRngDmaResponse(
    uint16_t magic, const whMessageCrypto_RngDmaResponse* src,
    whMessageCrypto_RngDmaResponse* dest)
{
    if ((src == NULL) || (dest == NULL)) {
        return WH_ERROR_BADARGS;
    }

    return wh_MessageCrypto_TranslateDmaAddrStatus(magic, &src->dmaAddrStatus,
                                                   &dest->dmaAddrStatus);
}