luna - wolfssl/wolfcrypt/src/cryptocb.c

   1/* cryptocb.c
   2 *
   3 * Copyright (C) 2006-2026 wolfSSL Inc.
   4 *
   5 * This file is part of wolfSSL.
   6 *
   7 * wolfSSL is free software; you can redistribute it and/or modify
   8 * it under the terms of the GNU General Public License as published by
   9 * the Free Software Foundation; either version 3 of the License, or
  10 * (at your option) any later version.
  11 *
  12 * wolfSSL is distributed in the hope that it will be useful,
  13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 * GNU General Public License for more details.
  16 *
  17 * You should have received a copy of the GNU General Public License
  18 * along with this program; if not, write to the Free Software
  19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335, USA
  20 */
  21
  22/* This framework provides a central place for crypto hardware integration
  23   using the devId scheme. If not supported return `CRYPTOCB_UNAVAILABLE`. */
  24
  25/*
  26Crypto Callback Build Options:
  27 * WOLF_CRYPTO_CB:      Master enable for crypto callback       default: off
  28 *                      framework. Required for all options below.
  29 * WOLF_CRYPTO_CB_FIND: Enable find device callback functions   default: off
  30 *                      Allows lookup of registered crypto devices.
  31 * WOLF_CRYPTO_CB_CMD:  Enable command callbacks invoked during default: off
  32 *                      register and unregister of crypto devices.
  33 * WOLF_CRYPTO_CB_COPY: Enable copy callback for algorithm      default: off
  34 *                      structures (hash, cipher state copying).
  35 * WOLF_CRYPTO_CB_FREE: Enable free callback for algorithm      default: off
  36 *                      structures (cleanup of crypto objects).
  37 * WOLF_CRYPTO_CB_AES_SETKEY: Enable callback for AES key setup default: off
  38 * WOLF_CRYPTO_CB_RSA_PAD: Enable callback for RSA padding      default: off
  39 *                      operations (custom padding handling).
  40 * DEBUG_CRYPTOCB:      Enable debug InfoString functions        default: off
  41 *
  42 * Device ID options:
  43 * WC_USE_DEVID:        Specify a default device ID to use      default: off
  44 *                      when no hardware device is detected.
  45 * WC_NO_DEFAULT_DEVID: Disable automatic default device ID     default: off
  46 *                      selection. Requires explicit devId passing.
  47 * WOLFSSL_CAAM_DEVID:  Device ID constant (value 7) for NXP    default: off
  48 *                      CAAM hardware crypto.
  49 *
  50 * Algorithm-specific callback options:
  51 * NO_SHA2_CRYPTO_CB:   Disable crypto callbacks for SHA-384    default: off
  52 *                      and SHA-512 operations.
  53 * WOLF_CRYPTO_CB_ONLY_ECC: Use only callbacks for ECC          default: off
  54 * WOLF_CRYPTO_CB_ONLY_RSA: Use only callbacks for RSA          default: off
  55 * WOLF_CRYPTO_CB_ONLY_SHA256: Use only callbacks for SHA-256   default: off
  56 * WOLF_CRYPTO_CB_ONLY_AES: Use only callbacks for AES          default: off
  57 */
  58
  59#include <wolfssl/wolfcrypt/libwolfssl_sources.h>
  60
  61#ifdef WOLF_CRYPTO_CB
  62
  63#include <wolfssl/wolfcrypt/cryptocb.h>
  64
  65#ifdef HAVE_ARIA
  66    #include <wolfssl/wolfcrypt/port/aria/aria-cryptocb.h>
  67#endif
  68
  69#ifdef WOLFSSL_CAAM
  70    #include <wolfssl/wolfcrypt/port/caam/wolfcaam.h>
  71#endif
  72/* TODO: Consider linked list with mutex */
  73#ifndef MAX_CRYPTO_DEVID_CALLBACKS
  74#define MAX_CRYPTO_DEVID_CALLBACKS 8
  75#endif
  76
  77typedef struct CryptoCb {
  78    int devId;
  79    CryptoDevCallbackFunc cb;
  80    void* ctx;
  81} CryptoCb;
  82static WC_THREADSHARED CryptoCb gCryptoDev[MAX_CRYPTO_DEVID_CALLBACKS];
  83
  84#ifdef WOLF_CRYPTO_CB_FIND
  85static CryptoDevCallbackFind CryptoCb_FindCb = NULL;
  86#endif
  87
  88#ifdef DEBUG_CRYPTOCB
  89static const char* GetAlgoTypeStr(int algo)
  90{
  91    switch (algo) { /* enum wc_AlgoType */
  92#ifdef WOLF_CRYPTO_CB_CMD
  93        case WC_ALGO_TYPE_NONE:   return "None-Command";
  94#endif
  95        case WC_ALGO_TYPE_HASH:   return "Hash";
  96        case WC_ALGO_TYPE_CIPHER: return "Cipher";
  97        case WC_ALGO_TYPE_PK:     return "PK";
  98        case WC_ALGO_TYPE_RNG:    return "RNG";
  99        case WC_ALGO_TYPE_SEED:   return "Seed";
 100        case WC_ALGO_TYPE_HMAC:   return "HMAC";
 101        case WC_ALGO_TYPE_CMAC:   return "CMAC";
 102        case WC_ALGO_TYPE_CERT:   return "Cert";
 103        case WC_ALGO_TYPE_KDF:    return "KDF";
 104#ifdef WOLF_CRYPTO_CB_COPY
 105        case WC_ALGO_TYPE_COPY:   return "Copy";
 106#endif /* WOLF_CRYPTO_CB_COPY */
 107#ifdef WOLF_CRYPTO_CB_FREE
 108        case WC_ALGO_TYPE_FREE:   return "Free";
 109#endif /* WOLF_CRYPTO_CB_FREE */
 110#ifdef WOLF_CRYPTO_CB_SETKEY
 111        case WC_ALGO_TYPE_SETKEY: return "SetKey";
 112#endif /* WOLF_CRYPTO_CB_SETKEY */
 113#ifdef WOLF_CRYPTO_CB_EXPORT_KEY
 114        case WC_ALGO_TYPE_EXPORT_KEY: return "ExportKey";
 115#endif /* WOLF_CRYPTO_CB_EXPORT_KEY */
 116    }
 117    return NULL;
 118}
 119#ifdef WOLF_CRYPTO_CB_SETKEY
 120static const char* GetSetKeyTypeStr(int type)
 121{
 122    switch (type) {
 123        case WC_SETKEY_NONE:      return "None";
 124        case WC_SETKEY_HMAC:      return "HMAC";
 125        case WC_SETKEY_RSA_PUB:   return "RSA-Pub";
 126        case WC_SETKEY_RSA_PRIV:  return "RSA-Priv";
 127        case WC_SETKEY_ECC_PUB:   return "ECC-Pub";
 128        case WC_SETKEY_ECC_PRIV:  return "ECC-Priv";
 129        case WC_SETKEY_AES:       return "AES";
 130        default:                  break;
 131    }
 132    return NULL;
 133}
 134#endif /* WOLF_CRYPTO_CB_SETKEY */
 135static const char* GetPkTypeStr(int pk)
 136{
 137    switch (pk) {
 138        case WC_PK_TYPE_RSA: return "RSA";
 139        case WC_PK_TYPE_DH: return "DH";
 140        case WC_PK_TYPE_ECDH: return "ECDH";
 141        case WC_PK_TYPE_ECDSA_SIGN: return "ECDSA-Sign";
 142        case WC_PK_TYPE_ECDSA_VERIFY: return "ECDSA-Verify";
 143        case WC_PK_TYPE_ED25519_SIGN: return "ED25519-Sign";
 144        case WC_PK_TYPE_ED25519_VERIFY: return "ED25519-Verify";
 145        case WC_PK_TYPE_CURVE25519: return "CURVE25519";
 146        case WC_PK_TYPE_RSA_KEYGEN: return "RSA KeyGen";
 147        case WC_PK_TYPE_EC_KEYGEN: return "ECC KeyGen";
 148        case WC_PK_TYPE_EC_GET_SIZE: return "ECC GetSize";
 149        case WC_PK_TYPE_EC_GET_SIG_SIZE: return "ECC GetSigSize";
 150    }
 151    return NULL;
 152}
 153#if !defined(NO_AES) || !defined(NO_DES3)
 154static const char* GetCipherTypeStr(int cipher)
 155{
 156    switch (cipher) {
 157        case WC_CIPHER_AES: return "AES ECB";
 158        case WC_CIPHER_AES_CBC: return "AES CBC";
 159        case WC_CIPHER_AES_GCM: return "AES GCM";
 160        case WC_CIPHER_AES_CTR: return "AES CTR";
 161        case WC_CIPHER_AES_XTS: return "AES XTS";
 162        case WC_CIPHER_AES_CFB: return "AES CFB";
 163        case WC_CIPHER_DES3: return "DES3";
 164        case WC_CIPHER_DES: return "DES";
 165        case WC_CIPHER_CHACHA: return "ChaCha20";
 166    }
 167    return NULL;
 168}
 169#endif /* !NO_AES || !NO_DES3 */
 170static const char* GetHashTypeStr(int hash)
 171{
 172    switch (hash) {
 173        case WC_HASH_TYPE_MD2: return "MD2";
 174        case WC_HASH_TYPE_MD4: return "MD4";
 175        case WC_HASH_TYPE_MD5: return "MD5";
 176        case WC_HASH_TYPE_SHA: return "SHA-1";
 177        case WC_HASH_TYPE_SHA224: return "SHA-224";
 178        case WC_HASH_TYPE_SHA256: return "SHA-256";
 179        case WC_HASH_TYPE_SHA384: return "SHA-384";
 180        case WC_HASH_TYPE_SHA512: return "SHA-512";
 181        case WC_HASH_TYPE_MD5_SHA: return "MD5-SHA1";
 182        case WC_HASH_TYPE_SHA3_224: return "SHA3-224";
 183        case WC_HASH_TYPE_SHA3_256: return "SHA3-256";
 184        case WC_HASH_TYPE_SHA3_384: return "SHA3-384";
 185        case WC_HASH_TYPE_SHA3_512: return "SHA3-512";
 186        case WC_HASH_TYPE_BLAKE2B: return "Blake2B";
 187        case WC_HASH_TYPE_BLAKE2S: return "Blake2S";
 188    }
 189    return NULL;
 190}
 191
 192#ifdef WOLFSSL_CMAC
 193static const char* GetCmacTypeStr(int type)
 194{
 195    switch (type) {
 196        case WC_CMAC_AES: return "AES";
 197    }
 198    return NULL;
 199}
 200#endif  /* WOLFSSL_CMAC */
 201
 202#ifndef NO_RSA
 203static const char* GetRsaType(int type)
 204{
 205    switch (type) {
 206        case RSA_PUBLIC_ENCRYPT:  return "Public Encrypt";
 207        case RSA_PUBLIC_DECRYPT:  return "Public Decrypt";
 208        case RSA_PRIVATE_ENCRYPT: return "Private Encrypt";
 209        case RSA_PRIVATE_DECRYPT: return "Private Decrypt";
 210    }
 211    return NULL;
 212}
 213#endif
 214
 215#ifdef WOLF_CRYPTO_CB_CMD
 216static const char* GetCryptoCbCmdTypeStr(int type)
 217{
 218    switch (type) {
 219        case WC_CRYPTOCB_CMD_TYPE_REGISTER:   return "Register";
 220        case WC_CRYPTOCB_CMD_TYPE_UNREGISTER: return "UnRegister";
 221    }
 222    return NULL;
 223}
 224#endif
 225
 226
 227#if (defined(HAVE_HKDF) && !defined(NO_HMAC)) || defined(HAVE_CMAC_KDF)
 228static const char* GetKdfTypeStr(int type)
 229{
 230    switch (type) {
 231        case WC_KDF_TYPE_HKDF:
 232            return "HKDF";
 233        case WC_KDF_TYPE_TWOSTEP_CMAC:
 234            return "TWOSTEP_CMAC";
 235    }
 236    return NULL;
 237}
 238#endif
 239
 240void wc_CryptoCb_InfoString(wc_CryptoInfo* info)
 241{
 242    if (info == NULL)
 243        return;
 244
 245    if (info->algo_type == WC_ALGO_TYPE_PK) {
 246    #ifndef NO_RSA
 247        if (info->pk.type == WC_PK_TYPE_RSA) {
 248            printf("Crypto CB: %s %s (%d), %s, Len %d\n",
 249                GetAlgoTypeStr(info->algo_type),
 250                GetPkTypeStr(info->pk.type), info->pk.type,
 251                GetRsaType(info->pk.rsa.type), info->pk.rsa.inLen);
 252        }
 253        else
 254    #endif
 255        {
 256            printf("Crypto CB: %s %s (%d)\n",
 257                GetAlgoTypeStr(info->algo_type),
 258                GetPkTypeStr(info->pk.type), info->pk.type);
 259        }
 260    }
 261#if !defined(NO_AES) || !defined(NO_DES3)
 262    else if (info->algo_type == WC_ALGO_TYPE_CIPHER) {
 263        printf("Crypto CB: %s %s (%d) (%p ctx)\n",
 264            GetAlgoTypeStr(info->algo_type),
 265            GetCipherTypeStr(info->cipher.type),
 266            info->cipher.type, (void*)info->cipher.ctx);
 267    }
 268#endif /* !NO_AES || !NO_DES3 */
 269#if !defined(NO_SHA) || !defined(NO_SHA256) || \
 270    defined(WOLFSSL_SHA512) || defined(WOLFSSL_SHA384) || defined(WOLFSSL_SHA3)
 271    else if (info->algo_type == WC_ALGO_TYPE_HASH) {
 272        printf("Crypto CB: %s %s (%d) (%p ctx) %s\n",
 273            GetAlgoTypeStr(info->algo_type),
 274            GetHashTypeStr(info->hash.type),
 275            info->hash.type, (void*)info->hash.ctx,
 276            (info->hash.in != NULL) ? "Update" : "Final");
 277    }
 278#endif
 279#ifndef NO_HMAC
 280    else if (info->algo_type == WC_ALGO_TYPE_HMAC) {
 281        printf("Crypto CB: %s %s (%d) (%p ctx) %s\n",
 282            GetAlgoTypeStr(info->algo_type),
 283            GetHashTypeStr(info->hmac.macType),
 284            info->hmac.macType, (void*)info->hmac.hmac,
 285            (info->hmac.in != NULL) ? "Update" : "Final");
 286    }
 287#endif
 288#ifdef WOLFSSL_CMAC
 289    else if (info->algo_type == WC_ALGO_TYPE_CMAC) {
 290        printf("Crypto CB: %s %s (%d) (%p ctx) %s %s %s\n",
 291            GetAlgoTypeStr(info->algo_type),
 292            GetCmacTypeStr(info->cmac.type),
 293            info->cmac.type, (void*)info->cmac.cmac,
 294            (info->cmac.key != NULL) ? "Init " : "",
 295            (info->cmac.in != NULL) ? "Update " : "",
 296            (info->cmac.out != NULL) ? "Final" : "");
 297    }
 298#endif
 299#ifdef WOLF_CRYPTO_CB_CMD
 300    else if (info->algo_type == WC_ALGO_TYPE_NONE) {
 301        printf("Crypto CB: %s %s (%d)\n",
 302            GetAlgoTypeStr(info->algo_type),
 303            GetCryptoCbCmdTypeStr(info->cmd.type), info->cmd.type);
 304    }
 305#endif
 306#ifdef WOLF_CRYPTO_CB_COPY
 307    else if (info->algo_type == WC_ALGO_TYPE_COPY) {
 308        printf("Crypto CB: %s %s Type=%d\n",
 309            GetAlgoTypeStr(info->algo_type),
 310            GetAlgoTypeStr(info->copy.algo), info->copy.type);
 311    }
 312#endif /* WOLF_CRYPTO_CB_COPY */
 313#ifdef WOLF_CRYPTO_CB_FREE
 314    else if (info->algo_type == WC_ALGO_TYPE_FREE) {
 315        printf("Crypto CB: %s %s Type=%d\n",
 316            GetAlgoTypeStr(info->algo_type),
 317            GetAlgoTypeStr(info->free.algo), info->free.type);
 318    }
 319#endif /* WOLF_CRYPTO_CB_FREE */
 320#ifdef WOLF_CRYPTO_CB_SETKEY
 321    else if (info->algo_type == WC_ALGO_TYPE_SETKEY) {
 322        printf("Crypto CB: %s %s KeySz=%u\n",
 323            GetAlgoTypeStr(info->algo_type),
 324            GetSetKeyTypeStr(info->setkey.type), info->setkey.keySz);
 325    }
 326#endif /* WOLF_CRYPTO_CB_SETKEY */
 327#ifdef WOLF_CRYPTO_CB_EXPORT_KEY
 328    else if (info->algo_type == WC_ALGO_TYPE_EXPORT_KEY) {
 329        printf("Crypto CB: %s Type=%d\n",
 330            GetAlgoTypeStr(info->algo_type), info->export_key.type);
 331    }
 332#endif /* WOLF_CRYPTO_CB_EXPORT_KEY */
 333#if (defined(HAVE_HKDF) && !defined(NO_HMAC)) || \
 334    defined(HAVE_CMAC_KDF)
 335    else if (info->algo_type == WC_ALGO_TYPE_KDF) {
 336        printf("Crypto CB: %s %s (%d)\n", GetAlgoTypeStr(info->algo_type),
 337               GetKdfTypeStr(info->kdf.type), info->kdf.type);
 338    }
 339#endif
 340    else {
 341        printf("CryptoCb: %s \n", GetAlgoTypeStr(info->algo_type));
 342    }
 343}
 344#endif /* DEBUG_CRYPTOCB */
 345
 346/* Search through listed devices and return the first matching device ID
 347 * found. */
 348static CryptoCb* wc_CryptoCb_GetDevice(int devId)
 349{
 350    int i;
 351    for (i = 0; i < MAX_CRYPTO_DEVID_CALLBACKS; i++) {
 352        if (gCryptoDev[i].devId == devId)
 353            return &gCryptoDev[i];
 354    }
 355    return NULL;
 356}
 357
 358
 359/* Filters through find callback set when trying to get the device,
 360 * returns the device found on success and null if not found. */
 361static CryptoCb* wc_CryptoCb_FindDevice(int devId, int algoType)
 362{
 363    int localDevId = devId;
 364
 365#ifdef WOLF_CRYPTO_CB_FIND
 366    if (CryptoCb_FindCb != NULL) {
 367        localDevId = CryptoCb_FindCb(devId, algoType);
 368    }
 369#endif /* WOLF_CRYPTO_CB_FIND */
 370    (void)algoType;
 371    return wc_CryptoCb_GetDevice(localDevId);
 372}
 373
 374
 375static CryptoCb* wc_CryptoCb_FindDeviceByIndex(int startIdx)
 376{
 377    int i;
 378    for (i=startIdx; i<MAX_CRYPTO_DEVID_CALLBACKS; i++) {
 379        if (gCryptoDev[i].devId != INVALID_DEVID)
 380            return &gCryptoDev[i];
 381    }
 382    return NULL;
 383}
 384
 385static WC_INLINE int wc_CryptoCb_TranslateErrorCode(int ret)
 386{
 387    if (ret == WC_NO_ERR_TRACE(NOT_COMPILED_IN)) {
 388        /* backwards compatibility for older NOT_COMPILED_IN syntax */
 389        ret = WC_NO_ERR_TRACE(CRYPTOCB_UNAVAILABLE);
 390    }
 391    return ret;
 392}
 393
 394/* Helper function to reset a device entry to invalid */
 395static WC_INLINE void wc_CryptoCb_ClearDev(CryptoCb *dev)
 396{
 397    XMEMSET(dev, 0, sizeof(*dev));
 398    dev->devId = INVALID_DEVID;
 399}
 400
 401void wc_CryptoCb_Init(void)
 402{
 403    int i;
 404    for (i = 0; i < MAX_CRYPTO_DEVID_CALLBACKS; i++) {
 405        wc_CryptoCb_ClearDev(&gCryptoDev[i]);
 406    }
 407}
 408
 409void wc_CryptoCb_Cleanup(void)
 410{
 411    int i;
 412    for (i = 0; i < MAX_CRYPTO_DEVID_CALLBACKS; i++) {
 413        if(gCryptoDev[i].devId != INVALID_DEVID) {
 414            wc_CryptoCb_UnRegisterDevice(gCryptoDev[i].devId);
 415        }
 416    }
 417}
 418
 419int wc_CryptoCb_GetDevIdAtIndex(int startIdx)
 420{
 421    int devId = INVALID_DEVID;
 422    CryptoCb* dev = wc_CryptoCb_FindDeviceByIndex(startIdx);
 423    if (dev) {
 424        devId = dev->devId;
 425    }
 426    return devId;
 427}
 428
 429
 430#ifdef WOLF_CRYPTO_CB_FIND
 431/* Used to register a find device function. Useful for cases where the
 432 * device ID in the struct may not have been set but still wanting to use
 433 * a specific crypto callback device ID. The find callback is global and
 434 * not thread safe. */
 435void wc_CryptoCb_SetDeviceFindCb(CryptoDevCallbackFind cb)
 436{
 437    CryptoCb_FindCb = cb;
 438}
 439#endif
 440
 441int wc_CryptoCb_RegisterDevice(int devId, CryptoDevCallbackFunc cb, void* ctx)
 442{
 443    int rc = 0;
 444
 445    /* find existing or new */
 446    CryptoCb* dev = wc_CryptoCb_GetDevice(devId);
 447    if (dev == NULL)
 448        dev = wc_CryptoCb_GetDevice(INVALID_DEVID);
 449
 450    if (dev == NULL)
 451        return BUFFER_E; /* out of devices */
 452
 453    dev->devId = devId;
 454    dev->cb    = cb;
 455    dev->ctx   = ctx;
 456
 457#ifdef WOLF_CRYPTO_CB_CMD
 458    if (cb != NULL) {
 459        /* Invoke callback with register command */
 460        wc_CryptoInfo info;
 461        XMEMSET(&info, 0, sizeof(info));
 462        info.algo_type = WC_ALGO_TYPE_NONE;
 463        info.cmd.type  = WC_CRYPTOCB_CMD_TYPE_REGISTER;
 464        info.cmd.ctx   = ctx;  /* cb may update on success */
 465
 466        rc = cb(devId, &info, ctx);
 467        if (rc == 0) {
 468            /* Success.  Update dev->ctx */
 469            dev->ctx = info.cmd.ctx;
 470        }
 471        else if ((rc == WC_NO_ERR_TRACE(CRYPTOCB_UNAVAILABLE)) ||
 472                 (rc == WC_NO_ERR_TRACE(NOT_COMPILED_IN))) {
 473            /* Not implemented.  Return success*/
 474            rc = 0;
 475        }
 476        else {
 477            /* Error in callback register cmd. Don't register */
 478            wc_CryptoCb_ClearDev(dev);
 479        }
 480    }
 481#endif
 482    return rc;
 483}
 484
 485void wc_CryptoCb_UnRegisterDevice(int devId)
 486{
 487    CryptoCb* dev = NULL;
 488
 489    /* Can't unregister the invalid device */
 490    if (devId == INVALID_DEVID)
 491        return;
 492
 493    /* Find the matching dev */
 494    dev = wc_CryptoCb_GetDevice(devId);
 495    if (dev == NULL)
 496        return;
 497
 498#ifdef WOLF_CRYPTO_CB_CMD
 499    if (dev->cb != NULL) {
 500        /* Invoke callback with unregister command.*/
 501        wc_CryptoInfo info;
 502        XMEMSET(&info, 0, sizeof(info));
 503        info.algo_type = WC_ALGO_TYPE_NONE;
 504        info.cmd.type  = WC_CRYPTOCB_CMD_TYPE_UNREGISTER;
 505        info.cmd.ctx   = NULL;  /* Not used */
 506
 507        /* Ignore errors here */
 508        dev->cb(devId, &info, dev->ctx);
 509    }
 510#endif
 511    wc_CryptoCb_ClearDev(dev);
 512}
 513
 514#ifndef NO_RSA
 515int wc_CryptoCb_Rsa(const byte* in, word32 inLen, byte* out,
 516    word32* outLen, int type, RsaKey* key, WC_RNG* rng)
 517{
 518    int ret = WC_NO_ERR_TRACE(CRYPTOCB_UNAVAILABLE);
 519    CryptoCb* dev;
 520
 521    if (key == NULL)
 522        return ret;
 523
 524    /* locate registered callback */
 525    dev = wc_CryptoCb_FindDevice(key->devId, WC_ALGO_TYPE_PK);
 526    if (dev && dev->cb) {
 527        wc_CryptoInfo cryptoInfo;
 528        XMEMSET(&cryptoInfo, 0, sizeof(cryptoInfo));
 529        cryptoInfo.algo_type = WC_ALGO_TYPE_PK;
 530        cryptoInfo.pk.type = WC_PK_TYPE_RSA;
 531        cryptoInfo.pk.rsa.in = in;
 532        cryptoInfo.pk.rsa.inLen = inLen;
 533        cryptoInfo.pk.rsa.out = out;
 534        cryptoInfo.pk.rsa.outLen = outLen;
 535        cryptoInfo.pk.rsa.type = type;
 536        cryptoInfo.pk.rsa.key = key;
 537        cryptoInfo.pk.rsa.rng = rng;
 538
 539        ret = dev->cb(dev->devId, &cryptoInfo, dev->ctx);
 540    }
 541
 542    return wc_CryptoCb_TranslateErrorCode(ret);
 543}
 544
 545#ifdef WOLF_CRYPTO_CB_RSA_PAD
 546int wc_CryptoCb_RsaPad(const byte* in, word32 inLen, byte* out,
 547                       word32* outLen, int type, RsaKey* key, WC_RNG* rng,
 548                       RsaPadding *padding)
 549{
 550    int ret = WC_NO_ERR_TRACE(CRYPTOCB_UNAVAILABLE);
 551    CryptoCb* dev;
 552    int pk_type;
 553
 554    if (key == NULL)
 555        return ret;
 556
 557    /* locate registered callback */
 558    dev = wc_CryptoCb_FindDevice(key->devId, WC_ALGO_TYPE_PK);
 559
 560    if (padding != NULL) {
 561        switch (padding->pad_type) {
 562        case WC_RSA_PKCSV15_PAD:
 563            pk_type = WC_PK_TYPE_RSA_PKCS;
 564            break;
 565        case WC_RSA_PSS_PAD:
 566            pk_type = WC_PK_TYPE_RSA_PSS;
 567            break;
 568        case WC_RSA_OAEP_PAD:
 569            pk_type = WC_PK_TYPE_RSA_OAEP;
 570            break;
 571        default:
 572            pk_type = WC_PK_TYPE_RSA;
 573        }
 574    } else {
 575        pk_type = WC_PK_TYPE_RSA;
 576    }
 577
 578    if (dev && dev->cb) {
 579        wc_CryptoInfo cryptoInfo;
 580        XMEMSET(&cryptoInfo, 0, sizeof(cryptoInfo));
 581        cryptoInfo.algo_type = WC_ALGO_TYPE_PK;
 582        cryptoInfo.pk.type = pk_type;
 583        cryptoInfo.pk.rsa.in = in;
 584        cryptoInfo.pk.rsa.inLen = inLen;
 585        cryptoInfo.pk.rsa.out = out;
 586        cryptoInfo.pk.rsa.outLen = outLen;
 587        cryptoInfo.pk.rsa.type = type;
 588        cryptoInfo.pk.rsa.key = key;
 589        cryptoInfo.pk.rsa.rng = rng;
 590        cryptoInfo.pk.rsa.padding = padding;
 591
 592        ret = dev->cb(dev->devId, &cryptoInfo, dev->ctx);
 593    }
 594
 595    return wc_CryptoCb_TranslateErrorCode(ret);
 596}
 597#endif /* WOLF_CRYPTO_CB_RSA_PAD */
 598
 599#ifdef WOLFSSL_KEY_GEN
 600int wc_CryptoCb_MakeRsaKey(RsaKey* key, int size, long e, WC_RNG* rng)
 601{
 602    int ret = WC_NO_ERR_TRACE(CRYPTOCB_UNAVAILABLE);
 603    CryptoCb* dev;
 604
 605    if (key == NULL)
 606        return ret;
 607
 608    /* locate registered callback */
 609    dev = wc_CryptoCb_FindDevice(key->devId, WC_ALGO_TYPE_PK);
 610    if (dev && dev->cb) {
 611        wc_CryptoInfo cryptoInfo;
 612        XMEMSET(&cryptoInfo, 0, sizeof(cryptoInfo));
 613        cryptoInfo.algo_type = WC_ALGO_TYPE_PK;
 614        cryptoInfo.pk.type = WC_PK_TYPE_RSA_KEYGEN;
 615        cryptoInfo.pk.rsakg.key = key;
 616        cryptoInfo.pk.rsakg.size = size;
 617        cryptoInfo.pk.rsakg.e = e;
 618        cryptoInfo.pk.rsakg.rng = rng;
 619
 620        ret = dev->cb(dev->devId, &cryptoInfo, dev->ctx);
 621    }
 622
 623    return wc_CryptoCb_TranslateErrorCode(ret);
 624}
 625#endif
 626
 627int wc_CryptoCb_RsaCheckPrivKey(RsaKey* key, const byte* pubKey,
 628    word32 pubKeySz)
 629{
 630    int ret = WC_NO_ERR_TRACE(CRYPTOCB_UNAVAILABLE);
 631    CryptoCb* dev;
 632
 633    if (key == NULL)
 634        return ret;
 635
 636    /* locate registered callback */
 637    dev = wc_CryptoCb_FindDevice(key->devId, WC_ALGO_TYPE_PK);
 638    if (dev && dev->cb) {
 639        wc_CryptoInfo cryptoInfo;
 640        XMEMSET(&cryptoInfo, 0, sizeof(cryptoInfo));
 641        cryptoInfo.algo_type = WC_ALGO_TYPE_PK;
 642        cryptoInfo.pk.type = WC_PK_TYPE_RSA_CHECK_PRIV_KEY;
 643        cryptoInfo.pk.rsa_check.key = key;
 644        cryptoInfo.pk.rsa_check.pubKey = pubKey;
 645        cryptoInfo.pk.rsa_check.pubKeySz = pubKeySz;
 646
 647        ret = dev->cb(dev->devId, &cryptoInfo, dev->ctx);
 648    }
 649
 650    return wc_CryptoCb_TranslateErrorCode(ret);
 651}
 652
 653int wc_CryptoCb_RsaGetSize(const RsaKey* key, int* keySize)
 654{
 655    int ret = WC_NO_ERR_TRACE(CRYPTOCB_UNAVAILABLE);
 656    CryptoCb* dev;
 657
 658    if (key == NULL)
 659        return ret;
 660
 661    /* locate registered callback */
 662    dev = wc_CryptoCb_FindDevice(key->devId, WC_ALGO_TYPE_PK);
 663    if (dev && dev->cb) {
 664        wc_CryptoInfo cryptoInfo;
 665        XMEMSET(&cryptoInfo, 0, sizeof(cryptoInfo));
 666        cryptoInfo.algo_type = WC_ALGO_TYPE_PK;
 667        cryptoInfo.pk.type = WC_PK_TYPE_RSA_GET_SIZE;
 668        cryptoInfo.pk.rsa_get_size.key = key;
 669        cryptoInfo.pk.rsa_get_size.keySize = keySize;
 670
 671        ret = dev->cb(dev->devId, &cryptoInfo, dev->ctx);
 672    }
 673
 674    return wc_CryptoCb_TranslateErrorCode(ret);
 675}
 676#endif /* !NO_RSA */
 677
 678#ifdef HAVE_ECC
 679#ifdef HAVE_ECC_DHE
 680int wc_CryptoCb_MakeEccKey(WC_RNG* rng, int keySize, ecc_key* key, int curveId)
 681{
 682    int ret = WC_NO_ERR_TRACE(CRYPTOCB_UNAVAILABLE);
 683    CryptoCb* dev;
 684
 685    if (key == NULL)
 686        return ret;
 687
 688    /* locate registered callback */
 689    dev = wc_CryptoCb_FindDevice(key->devId, WC_ALGO_TYPE_PK);
 690    if (dev && dev->cb) {
 691        wc_CryptoInfo cryptoInfo;
 692        XMEMSET(&cryptoInfo, 0, sizeof(cryptoInfo));
 693        cryptoInfo.algo_type = WC_ALGO_TYPE_PK;
 694        cryptoInfo.pk.type = WC_PK_TYPE_EC_KEYGEN;
 695        cryptoInfo.pk.eckg.rng = rng;
 696        cryptoInfo.pk.eckg.size = keySize;
 697        cryptoInfo.pk.eckg.key = key;
 698        cryptoInfo.pk.eckg.curveId = curveId;
 699
 700        ret = dev->cb(dev->devId, &cryptoInfo, dev->ctx);
 701    }
 702
 703    return wc_CryptoCb_TranslateErrorCode(ret);
 704}
 705
 706int wc_CryptoCb_Ecdh(ecc_key* private_key, ecc_key* public_key,
 707    byte* out, word32* outlen)
 708{
 709    int ret = WC_NO_ERR_TRACE(CRYPTOCB_UNAVAILABLE);
 710    CryptoCb* dev;
 711
 712    if (private_key == NULL)
 713        return ret;
 714
 715    /* locate registered callback */
 716    dev = wc_CryptoCb_FindDevice(private_key->devId, WC_ALGO_TYPE_PK);
 717    if (dev && dev->cb) {
 718        wc_CryptoInfo cryptoInfo;
 719        XMEMSET(&cryptoInfo, 0, sizeof(cryptoInfo));
 720        cryptoInfo.algo_type = WC_ALGO_TYPE_PK;
 721        cryptoInfo.pk.type = WC_PK_TYPE_ECDH;
 722        cryptoInfo.pk.ecdh.private_key = private_key;
 723        cryptoInfo.pk.ecdh.public_key = public_key;
 724        cryptoInfo.pk.ecdh.out = out;
 725        cryptoInfo.pk.ecdh.outlen = outlen;
 726
 727        ret = dev->cb(dev->devId, &cryptoInfo, dev->ctx);
 728    }
 729
 730    return wc_CryptoCb_TranslateErrorCode(ret);
 731}
 732#endif
 733
 734#ifdef HAVE_ECC_SIGN
 735int wc_CryptoCb_EccSign(const byte* in, word32 inlen, byte* out,
 736    word32 *outlen, WC_RNG* rng, ecc_key* key)
 737{
 738    int ret = WC_NO_ERR_TRACE(CRYPTOCB_UNAVAILABLE);
 739    CryptoCb* dev;
 740
 741    if (key == NULL)
 742        return ret;
 743
 744    /* locate registered callback */
 745    dev = wc_CryptoCb_FindDevice(key->devId, WC_ALGO_TYPE_PK);
 746    if (dev && dev->cb) {
 747        wc_CryptoInfo cryptoInfo;
 748        XMEMSET(&cryptoInfo, 0, sizeof(cryptoInfo));
 749        cryptoInfo.algo_type = WC_ALGO_TYPE_PK;
 750        cryptoInfo.pk.type = WC_PK_TYPE_ECDSA_SIGN;
 751        cryptoInfo.pk.eccsign.in = in;
 752        cryptoInfo.pk.eccsign.inlen = inlen;
 753        cryptoInfo.pk.eccsign.out = out;
 754        cryptoInfo.pk.eccsign.outlen = outlen;
 755        cryptoInfo.pk.eccsign.rng = rng;
 756        cryptoInfo.pk.eccsign.key = key;
 757
 758        ret = dev->cb(dev->devId, &cryptoInfo, dev->ctx);
 759    }
 760
 761    return wc_CryptoCb_TranslateErrorCode(ret);
 762}
 763#endif
 764
 765#ifdef HAVE_ECC_VERIFY
 766int wc_CryptoCb_EccVerify(const byte* sig, word32 siglen,
 767    const byte* hash, word32 hashlen, int* res, ecc_key* key)
 768{
 769    int ret = WC_NO_ERR_TRACE(CRYPTOCB_UNAVAILABLE);
 770    CryptoCb* dev;
 771
 772    if (key == NULL)
 773        return ret;
 774
 775    /* locate registered callback */
 776    dev = wc_CryptoCb_FindDevice(key->devId, WC_ALGO_TYPE_PK);
 777    if (dev && dev->cb) {
 778        wc_CryptoInfo cryptoInfo;
 779        XMEMSET(&cryptoInfo, 0, sizeof(cryptoInfo));
 780        cryptoInfo.algo_type = WC_ALGO_TYPE_PK;
 781        cryptoInfo.pk.type = WC_PK_TYPE_ECDSA_VERIFY;
 782        cryptoInfo.pk.eccverify.sig = sig;
 783        cryptoInfo.pk.eccverify.siglen = siglen;
 784        cryptoInfo.pk.eccverify.hash = hash;
 785        cryptoInfo.pk.eccverify.hashlen = hashlen;
 786        cryptoInfo.pk.eccverify.res = res;
 787        cryptoInfo.pk.eccverify.key = key;
 788
 789        ret = dev->cb(dev->devId, &cryptoInfo, dev->ctx);
 790    }
 791
 792    return wc_CryptoCb_TranslateErrorCode(ret);
 793}
 794#endif
 795
 796#ifdef HAVE_ECC_CHECK_KEY
 797int wc_CryptoCb_EccCheckPrivKey(ecc_key* key, const byte* pubKey,
 798    word32 pubKeySz)
 799{
 800    int ret = WC_NO_ERR_TRACE(CRYPTOCB_UNAVAILABLE);
 801    CryptoCb* dev;
 802
 803    if (key == NULL)
 804        return ret;
 805
 806    /* locate registered callback */
 807    dev = wc_CryptoCb_FindDevice(key->devId, WC_ALGO_TYPE_PK);
 808    if (dev && dev->cb) {
 809        wc_CryptoInfo cryptoInfo;
 810        XMEMSET(&cryptoInfo, 0, sizeof(cryptoInfo));
 811        cryptoInfo.algo_type = WC_ALGO_TYPE_PK;
 812        cryptoInfo.pk.type = WC_PK_TYPE_EC_CHECK_PRIV_KEY;
 813        cryptoInfo.pk.ecc_check.key = key;
 814        cryptoInfo.pk.ecc_check.pubKey = pubKey;
 815        cryptoInfo.pk.ecc_check.pubKeySz = pubKeySz;
 816
 817        ret = dev->cb(dev->devId, &cryptoInfo, dev->ctx);
 818    }
 819
 820    return wc_CryptoCb_TranslateErrorCode(ret);
 821}
 822#endif
 823
 824int wc_CryptoCb_EccGetSize(const ecc_key* key, int* keySize)
 825{
 826    int ret = WC_NO_ERR_TRACE(CRYPTOCB_UNAVAILABLE);
 827    CryptoCb* dev;
 828
 829    if (key == NULL)
 830        return ret;
 831
 832    /* locate registered callback */
 833    dev = wc_CryptoCb_FindDevice(key->devId, WC_ALGO_TYPE_PK);
 834    if (dev && dev->cb) {
 835        wc_CryptoInfo cryptoInfo;
 836        XMEMSET(&cryptoInfo, 0, sizeof(cryptoInfo));
 837        cryptoInfo.algo_type = WC_ALGO_TYPE_PK;
 838        cryptoInfo.pk.type = WC_PK_TYPE_EC_GET_SIZE;
 839        cryptoInfo.pk.ecc_get_size.key = key;
 840        cryptoInfo.pk.ecc_get_size.keySize = keySize;
 841
 842        ret = dev->cb(dev->devId, &cryptoInfo, dev->ctx);
 843    }
 844
 845    return wc_CryptoCb_TranslateErrorCode(ret);
 846}
 847
 848int wc_CryptoCb_EccGetSigSize(const ecc_key* key, int* sigSize)
 849{
 850    int ret = WC_NO_ERR_TRACE(CRYPTOCB_UNAVAILABLE);
 851    CryptoCb* dev;
 852
 853    if (key == NULL)
 854        return ret;
 855
 856    /* locate registered callback */
 857    dev = wc_CryptoCb_FindDevice(key->devId, WC_ALGO_TYPE_PK);
 858    if (dev && dev->cb) {
 859        wc_CryptoInfo cryptoInfo;
 860        XMEMSET(&cryptoInfo, 0, sizeof(cryptoInfo));
 861        cryptoInfo.algo_type = WC_ALGO_TYPE_PK;
 862        cryptoInfo.pk.type = WC_PK_TYPE_EC_GET_SIG_SIZE;
 863        cryptoInfo.pk.ecc_get_sig_size.key = key;
 864        cryptoInfo.pk.ecc_get_sig_size.sigSize = sigSize;
 865
 866        ret = dev->cb(dev->devId, &cryptoInfo, dev->ctx);
 867    }
 868
 869    return wc_CryptoCb_TranslateErrorCode(ret);
 870}
 871#endif /* HAVE_ECC */
 872
 873#ifdef HAVE_CURVE25519
 874int wc_CryptoCb_Curve25519Gen(WC_RNG* rng, int keySize,
 875    curve25519_key* key)
 876{
 877    int ret = WC_NO_ERR_TRACE(CRYPTOCB_UNAVAILABLE);
 878    CryptoCb* dev;
 879
 880    if (key == NULL)
 881        return ret;
 882
 883    /* locate registered callback */
 884    dev = wc_CryptoCb_FindDevice(key->devId, WC_ALGO_TYPE_PK);
 885    if (dev && dev->cb) {
 886        wc_CryptoInfo cryptoInfo;
 887        XMEMSET(&cryptoInfo, 0, sizeof(cryptoInfo));
 888        cryptoInfo.algo_type = WC_ALGO_TYPE_PK;
 889        cryptoInfo.pk.type = WC_PK_TYPE_CURVE25519_KEYGEN;
 890        cryptoInfo.pk.curve25519kg.rng = rng;
 891        cryptoInfo.pk.curve25519kg.size = keySize;
 892        cryptoInfo.pk.curve25519kg.key = key;
 893
 894        ret = dev->cb(dev->devId, &cryptoInfo, dev->ctx);
 895    }
 896
 897    return wc_CryptoCb_TranslateErrorCode(ret);
 898}
 899
 900int wc_CryptoCb_Curve25519(curve25519_key* private_key,
 901    curve25519_key* public_key, byte* out, word32* outlen, int endian)
 902{
 903    int ret = WC_NO_ERR_TRACE(CRYPTOCB_UNAVAILABLE);
 904    CryptoCb* dev;
 905
 906    if (private_key == NULL)
 907        return ret;
 908
 909    /* locate registered callback */
 910    dev = wc_CryptoCb_FindDevice(private_key->devId, WC_ALGO_TYPE_PK);
 911    if (dev && dev->cb) {
 912        wc_CryptoInfo cryptoInfo;
 913        XMEMSET(&cryptoInfo, 0, sizeof(cryptoInfo));
 914        cryptoInfo.algo_type = WC_ALGO_TYPE_PK;
 915        cryptoInfo.pk.type = WC_PK_TYPE_CURVE25519;
 916        cryptoInfo.pk.curve25519.private_key = private_key;
 917        cryptoInfo.pk.curve25519.public_key = public_key;
 918        cryptoInfo.pk.curve25519.out = out;
 919        cryptoInfo.pk.curve25519.outlen = outlen;
 920        cryptoInfo.pk.curve25519.endian = endian;
 921
 922        ret = dev->cb(dev->devId, &cryptoInfo, dev->ctx);
 923    }
 924
 925    return wc_CryptoCb_TranslateErrorCode(ret);
 926}
 927#endif /* HAVE_CURVE25519 */
 928
 929#ifdef HAVE_ED25519
 930int wc_CryptoCb_Ed25519Gen(WC_RNG* rng, int keySize,
 931    ed25519_key* key)
 932{
 933    int ret = WC_NO_ERR_TRACE(CRYPTOCB_UNAVAILABLE);
 934    CryptoCb* dev;
 935
 936    if (key == NULL)
 937        return ret;
 938
 939    /* locate registered callback */
 940    dev = wc_CryptoCb_FindDevice(key->devId, WC_ALGO_TYPE_PK);
 941    if (dev && dev->cb) {
 942        wc_CryptoInfo cryptoInfo;
 943        XMEMSET(&cryptoInfo, 0, sizeof(cryptoInfo));
 944        cryptoInfo.algo_type = WC_ALGO_TYPE_PK;
 945        cryptoInfo.pk.type = WC_PK_TYPE_ED25519_KEYGEN;
 946        cryptoInfo.pk.ed25519kg.rng = rng;
 947        cryptoInfo.pk.ed25519kg.size = keySize;
 948        cryptoInfo.pk.ed25519kg.key = key;
 949
 950        ret = dev->cb(dev->devId, &cryptoInfo, dev->ctx);
 951    }
 952
 953    return wc_CryptoCb_TranslateErrorCode(ret);
 954}
 955
 956int wc_CryptoCb_Ed25519Sign(const byte* in, word32 inLen, byte* out,
 957                            word32 *outLen, ed25519_key* key, byte type,
 958                            const byte* context, byte contextLen)
 959{
 960    int ret = WC_NO_ERR_TRACE(CRYPTOCB_UNAVAILABLE);
 961    CryptoCb* dev;
 962
 963    if (key == NULL)
 964        return ret;
 965
 966    /* locate registered callback */
 967    dev = wc_CryptoCb_FindDevice(key->devId, WC_ALGO_TYPE_PK);
 968    if (dev && dev->cb) {
 969        wc_CryptoInfo cryptoInfo;
 970        XMEMSET(&cryptoInfo, 0, sizeof(cryptoInfo));
 971        cryptoInfo.algo_type = WC_ALGO_TYPE_PK;
 972        cryptoInfo.pk.type = WC_PK_TYPE_ED25519_SIGN;
 973        cryptoInfo.pk.ed25519sign.in = in;
 974        cryptoInfo.pk.ed25519sign.inLen = inLen;
 975        cryptoInfo.pk.ed25519sign.out = out;
 976        cryptoInfo.pk.ed25519sign.outLen = outLen;
 977        cryptoInfo.pk.ed25519sign.key = key;
 978        cryptoInfo.pk.ed25519sign.type = type;
 979        cryptoInfo.pk.ed25519sign.context = context;
 980        cryptoInfo.pk.ed25519sign.contextLen = contextLen;
 981
 982        ret = dev->cb(dev->devId, &cryptoInfo, dev->ctx);
 983    }
 984
 985    return wc_CryptoCb_TranslateErrorCode(ret);
 986}
 987
 988int wc_CryptoCb_Ed25519Verify(const byte* sig, word32 sigLen,
 989    const byte* msg, word32 msgLen, int* res, ed25519_key* key, byte type,
 990    const byte* context, byte contextLen)
 991{
 992    int ret = WC_NO_ERR_TRACE(CRYPTOCB_UNAVAILABLE);
 993    CryptoCb* dev;
 994
 995    if (key == NULL)
 996        return ret;
 997
 998    /* locate registered callback */
 999    dev = wc_CryptoCb_FindDevice(key->devId, WC_ALGO_TYPE_PK);
1000    if (dev && dev->cb) {
1001        wc_CryptoInfo cryptoInfo;
1002        XMEMSET(&cryptoInfo, 0, sizeof(cryptoInfo));
1003        cryptoInfo.algo_type = WC_ALGO_TYPE_PK;
1004        cryptoInfo.pk.type = WC_PK_TYPE_ED25519_VERIFY;
1005        cryptoInfo.pk.ed25519verify.sig = sig;
1006        cryptoInfo.pk.ed25519verify.sigLen = sigLen;
1007        cryptoInfo.pk.ed25519verify.msg = msg;
1008        cryptoInfo.pk.ed25519verify.msgLen = msgLen;
1009        cryptoInfo.pk.ed25519verify.res = res;
1010        cryptoInfo.pk.ed25519verify.key = key;
1011        cryptoInfo.pk.ed25519verify.type = type;
1012        cryptoInfo.pk.ed25519verify.context = context;
1013        cryptoInfo.pk.ed25519verify.contextLen = contextLen;
1014
1015        ret = dev->cb(dev->devId, &cryptoInfo, dev->ctx);
1016    }
1017
1018    return wc_CryptoCb_TranslateErrorCode(ret);
1019}
1020#endif /* HAVE_ED25519 */
1021
1022#if defined(WOLFSSL_HAVE_LMS) || defined(WOLFSSL_HAVE_XMSS)
1023int wc_CryptoCb_PqcStatefulSigGetDevId(int type, void* key)
1024{
1025    int devId = INVALID_DEVID;
1026
1027    if (key == NULL)
1028        return devId;
1029
1030#if defined(WOLFSSL_HAVE_LMS)
1031    if (type == WC_PQC_STATEFUL_SIG_TYPE_LMS) {
1032        devId = ((LmsKey*)key)->devId;
1033    }
1034#endif
1035#if defined(WOLFSSL_HAVE_XMSS)
1036    if (type == WC_PQC_STATEFUL_SIG_TYPE_XMSS) {
1037        devId = ((XmssKey*)key)->devId;
1038    }
1039#endif
1040
1041    return devId;
1042}
1043
1044int wc_CryptoCb_PqcStatefulSigKeyGen(int type, void* key, WC_RNG* rng)
1045{
1046    int ret = WC_NO_ERR_TRACE(CRYPTOCB_UNAVAILABLE);
1047    int devId = INVALID_DEVID;
1048    CryptoCb* dev;
1049
1050    if (key == NULL)
1051        return ret;
1052
1053    devId = wc_CryptoCb_PqcStatefulSigGetDevId(type, key);
1054    if (devId == INVALID_DEVID)
1055        return ret;
1056
1057    dev = wc_CryptoCb_FindDevice(devId, WC_ALGO_TYPE_PK);
1058    if (dev && dev->cb) {
1059        wc_CryptoInfo cryptoInfo;
1060        XMEMSET(&cryptoInfo, 0, sizeof(cryptoInfo));
1061        cryptoInfo.algo_type = WC_ALGO_TYPE_PK;
1062        cryptoInfo.pk.type = WC_PK_TYPE_PQC_STATEFUL_SIG_KEYGEN;
1063        cryptoInfo.pk.pqc_stateful_sig_kg.rng = rng;
1064        cryptoInfo.pk.pqc_stateful_sig_kg.key = key;
1065        cryptoInfo.pk.pqc_stateful_sig_kg.type = type;
1066
1067        ret = dev->cb(dev->devId, &cryptoInfo, dev->ctx);
1068    }
1069
1070    return wc_CryptoCb_TranslateErrorCode(ret);
1071}
1072
1073int wc_CryptoCb_PqcStatefulSigSign(const byte* msg, word32 msgSz, byte* out,
1074    word32* outSz, int type, void* key)
1075{
1076    int ret = WC_NO_ERR_TRACE(CRYPTOCB_UNAVAILABLE);
1077    int devId = INVALID_DEVID;
1078    CryptoCb* dev;
1079
1080    if (key == NULL)
1081        return ret;
1082
1083    devId = wc_CryptoCb_PqcStatefulSigGetDevId(type, key);
1084    if (devId == INVALID_DEVID)
1085        return ret;
1086
1087    dev = wc_CryptoCb_FindDevice(devId, WC_ALGO_TYPE_PK);
1088    if (dev && dev->cb) {
1089        wc_CryptoInfo cryptoInfo;
1090        XMEMSET(&cryptoInfo, 0, sizeof(cryptoInfo));
1091        cryptoInfo.algo_type = WC_ALGO_TYPE_PK;
1092        cryptoInfo.pk.type = WC_PK_TYPE_PQC_STATEFUL_SIG_SIGN;
1093        cryptoInfo.pk.pqc_stateful_sig_sign.msg = msg;
1094        cryptoInfo.pk.pqc_stateful_sig_sign.msgSz = msgSz;
1095        cryptoInfo.pk.pqc_stateful_sig_sign.out = out;
1096        cryptoInfo.pk.pqc_stateful_sig_sign.outSz = outSz;
1097        cryptoInfo.pk.pqc_stateful_sig_sign.key = key;
1098        cryptoInfo.pk.pqc_stateful_sig_sign.type = type;
1099
1100        ret = dev->cb(dev->devId, &cryptoInfo, dev->ctx);
1101    }
1102
1103    return wc_CryptoCb_TranslateErrorCode(ret);
1104}
1105
1106int wc_CryptoCb_PqcStatefulSigVerify(const byte* sig, word32 sigSz,
1107    const byte* msg, word32 msgSz, int* res, int type, void* key)
1108{
1109    int ret = WC_NO_ERR_TRACE(CRYPTOCB_UNAVAILABLE);
1110    int devId = INVALID_DEVID;
1111    CryptoCb* dev;
1112
1113    if (key == NULL)
1114        return ret;
1115
1116    devId = wc_CryptoCb_PqcStatefulSigGetDevId(type, key);
1117    if (devId == INVALID_DEVID)
1118        return ret;
1119
1120    dev = wc_CryptoCb_FindDevice(devId, WC_ALGO_TYPE_PK);
1121    if (dev && dev->cb) {
1122        wc_CryptoInfo cryptoInfo;
1123        XMEMSET(&cryptoInfo, 0, sizeof(cryptoInfo));
1124        cryptoInfo.algo_type = WC_ALGO_TYPE_PK;
1125        cryptoInfo.pk.type = WC_PK_TYPE_PQC_STATEFUL_SIG_VERIFY;
1126        cryptoInfo.pk.pqc_stateful_sig_verify.sig = sig;
1127        cryptoInfo.pk.pqc_stateful_sig_verify.sigSz = sigSz;
1128        cryptoInfo.pk.pqc_stateful_sig_verify.msg = msg;
1129        cryptoInfo.pk.pqc_stateful_sig_verify.msgSz = msgSz;
1130        cryptoInfo.pk.pqc_stateful_sig_verify.res = res;
1131        cryptoInfo.pk.pqc_stateful_sig_verify.key = key;
1132        cryptoInfo.pk.pqc_stateful_sig_verify.type = type;
1133
1134        ret = dev->cb(dev->devId, &cryptoInfo, dev->ctx);
1135    }
1136
1137    return wc_CryptoCb_TranslateErrorCode(ret);
1138}
1139
1140int wc_CryptoCb_PqcStatefulSigSigsLeft(int type, void* key, word32* sigsLeft)
1141{
1142    int ret = WC_NO_ERR_TRACE(CRYPTOCB_UNAVAILABLE);
1143    int devId = INVALID_DEVID;
1144    CryptoCb* dev;
1145
1146    if (key == NULL)
1147        return ret;
1148
1149    devId = wc_CryptoCb_PqcStatefulSigGetDevId(type, key);
1150    if (devId == INVALID_DEVID)
1151        return ret;
1152
1153    dev = wc_CryptoCb_FindDevice(devId, WC_ALGO_TYPE_PK);
1154    if (dev && dev->cb) {
1155        wc_CryptoInfo cryptoInfo;
1156        XMEMSET(&cryptoInfo, 0, sizeof(cryptoInfo));
1157        cryptoInfo.algo_type = WC_ALGO_TYPE_PK;
1158        cryptoInfo.pk.type = WC_PK_TYPE_PQC_STATEFUL_SIG_SIGS_LEFT;
1159        cryptoInfo.pk.pqc_stateful_sig_sigs_left.key = key;
1160        cryptoInfo.pk.pqc_stateful_sig_sigs_left.sigsLeft = sigsLeft;
1161        cryptoInfo.pk.pqc_stateful_sig_sigs_left.type = type;
1162
1163        ret = dev->cb(dev->devId, &cryptoInfo, dev->ctx);
1164    }
1165
1166    return wc_CryptoCb_TranslateErrorCode(ret);
1167}
1168#endif /* WOLFSSL_HAVE_LMS || WOLFSSL_HAVE_XMSS */
1169
1170#if defined(WOLFSSL_HAVE_MLKEM)
1171int wc_CryptoCb_PqcKemGetDevId(int type, void* key)
1172{
1173    int devId = INVALID_DEVID;
1174
1175    if (key == NULL)
1176        return devId;
1177
1178    /* get devId */
1179    if (type == WC_PQC_KEM_TYPE_KYBER) {
1180        devId = ((KyberKey*) key)->devId;
1181    }
1182
1183    return devId;
1184}
1185
1186int wc_CryptoCb_MakePqcKemKey(WC_RNG* rng, int type, int keySize, void* key)
1187{
1188    int ret = WC_NO_ERR_TRACE(CRYPTOCB_UNAVAILABLE);
1189    int devId = INVALID_DEVID;
1190    CryptoCb* dev;
1191
1192    if (key == NULL)
1193        return ret;
1194
1195    /* get devId */
1196    devId = wc_CryptoCb_PqcKemGetDevId(type, key);
1197    if (devId == INVALID_DEVID)
1198        return ret;
1199
1200    /* locate registered callback */
1201    dev = wc_CryptoCb_FindDevice(devId, WC_ALGO_TYPE_PK);
1202    if (dev && dev->cb) {
1203        wc_CryptoInfo cryptoInfo;
1204        XMEMSET(&cryptoInfo, 0, sizeof(cryptoInfo));
1205        cryptoInfo.algo_type = WC_ALGO_TYPE_PK;
1206        cryptoInfo.pk.type = WC_PK_TYPE_PQC_KEM_KEYGEN;
1207        cryptoInfo.pk.pqc_kem_kg.rng = rng;
1208        cryptoInfo.pk.pqc_kem_kg.size = keySize;
1209        cryptoInfo.pk.pqc_kem_kg.key = key;
1210        cryptoInfo.pk.pqc_kem_kg.type = type;
1211
1212        ret = dev->cb(dev->devId, &cryptoInfo, dev->ctx);
1213    }
1214
1215    return wc_CryptoCb_TranslateErrorCode(ret);
1216}
1217
1218int wc_CryptoCb_PqcEncapsulate(byte* ciphertext, word32 ciphertextLen,
1219    byte* sharedSecret, word32 sharedSecretLen, WC_RNG* rng, int type,
1220    void* key)
1221{
1222    int ret = WC_NO_ERR_TRACE(CRYPTOCB_UNAVAILABLE);
1223    int devId = INVALID_DEVID;
1224    CryptoCb* dev;
1225
1226    if (key == NULL)
1227        return ret;
1228
1229    /* get devId */
1230    devId = wc_CryptoCb_PqcKemGetDevId(type, key);
1231    if (devId == INVALID_DEVID)
1232        return ret;
1233
1234    /* locate registered callback */
1235    dev = wc_CryptoCb_FindDevice(devId, WC_ALGO_TYPE_PK);
1236    if (dev && dev->cb) {
1237        wc_CryptoInfo cryptoInfo;
1238        XMEMSET(&cryptoInfo, 0, sizeof(cryptoInfo));
1239        cryptoInfo.algo_type = WC_ALGO_TYPE_PK;
1240        cryptoInfo.pk.type = WC_PK_TYPE_PQC_KEM_ENCAPS;
1241        cryptoInfo.pk.pqc_encaps.ciphertext = ciphertext;
1242        cryptoInfo.pk.pqc_encaps.ciphertextLen = ciphertextLen;
1243        cryptoInfo.pk.pqc_encaps.sharedSecret = sharedSecret;
1244        cryptoInfo.pk.pqc_encaps.sharedSecretLen = sharedSecretLen;
1245        cryptoInfo.pk.pqc_encaps.rng = rng;
1246        cryptoInfo.pk.pqc_encaps.key = key;
1247        cryptoInfo.pk.pqc_encaps.type = type;
1248
1249        ret = dev->cb(dev->devId, &cryptoInfo, dev->ctx);
1250    }
1251
1252    return wc_CryptoCb_TranslateErrorCode(ret);
1253}
1254
1255int wc_CryptoCb_PqcDecapsulate(const byte* ciphertext, word32 ciphertextLen,
1256    byte* sharedSecret, word32 sharedSecretLen, int type, void* key)
1257{
1258    int ret = WC_NO_ERR_TRACE(CRYPTOCB_UNAVAILABLE);
1259    int devId = INVALID_DEVID;
1260    CryptoCb* dev;
1261
1262    if (key == NULL)
1263        return ret;
1264
1265    /* get devId */
1266    devId = wc_CryptoCb_PqcKemGetDevId(type, key);
1267    if (devId == INVALID_DEVID)
1268        return ret;
1269
1270    /* locate registered callback */
1271    dev = wc_CryptoCb_FindDevice(devId, WC_ALGO_TYPE_PK);
1272    if (dev && dev->cb) {
1273        wc_CryptoInfo cryptoInfo;
1274        XMEMSET(&cryptoInfo, 0, sizeof(cryptoInfo));
1275        cryptoInfo.algo_type = WC_ALGO_TYPE_PK;
1276        cryptoInfo.pk.type = WC_PK_TYPE_PQC_KEM_DECAPS;
1277        cryptoInfo.pk.pqc_decaps.ciphertext = ciphertext;
1278        cryptoInfo.pk.pqc_decaps.ciphertextLen = ciphertextLen;
1279        cryptoInfo.pk.pqc_decaps.sharedSecret = sharedSecret;
1280        cryptoInfo.pk.pqc_decaps.sharedSecretLen = sharedSecretLen;
1281        cryptoInfo.pk.pqc_decaps.key = key;
1282        cryptoInfo.pk.pqc_decaps.type = type;
1283
1284        ret = dev->cb(dev->devId, &cryptoInfo, dev->ctx);
1285    }
1286
1287    return wc_CryptoCb_TranslateErrorCode(ret);
1288}
1289#endif /* WOLFSSL_HAVE_MLKEM */
1290
1291#if defined(HAVE_FALCON) || defined(HAVE_DILITHIUM)
1292int wc_CryptoCb_PqcSigGetDevId(int type, void* key)
1293{
1294    int devId = INVALID_DEVID;
1295
1296    if (key == NULL)
1297        return devId;
1298
1299    /* get devId */
1300#if defined(HAVE_DILITHIUM)
1301    if (type == WC_PQC_SIG_TYPE_DILITHIUM) {
1302        devId = ((dilithium_key*) key)->devId;
1303    }
1304#endif
1305#if defined(HAVE_FALCON)
1306    if (type == WC_PQC_SIG_TYPE_FALCON) {
1307        devId = ((falcon_key*) key)->devId;
1308    }
1309#endif
1310
1311    return devId;
1312}
1313
1314int wc_CryptoCb_MakePqcSignatureKey(WC_RNG* rng, int type, int keySize,
1315    void* key)
1316{
1317    int ret = WC_NO_ERR_TRACE(CRYPTOCB_UNAVAILABLE);
1318    int devId = INVALID_DEVID;
1319    CryptoCb* dev;
1320
1321    if (key == NULL)
1322        return ret;
1323
1324    /* get devId */
1325    devId = wc_CryptoCb_PqcSigGetDevId(type, key);
1326    if (devId == INVALID_DEVID)
1327        return ret;
1328
1329    /* locate registered callback */
1330    dev = wc_CryptoCb_FindDevice(devId, WC_ALGO_TYPE_PK);
1331    if (dev && dev->cb) {
1332        wc_CryptoInfo cryptoInfo;
1333        XMEMSET(&cryptoInfo, 0, sizeof(cryptoInfo));
1334        cryptoInfo.algo_type = WC_ALGO_TYPE_PK;
1335        cryptoInfo.pk.type = WC_PK_TYPE_PQC_SIG_KEYGEN;
1336        cryptoInfo.pk.pqc_sig_kg.rng = rng;
1337        cryptoInfo.pk.pqc_sig_kg.size = keySize;
1338        cryptoInfo.pk.pqc_sig_kg.key = key;
1339        cryptoInfo.pk.pqc_sig_kg.type = type;
1340
1341        ret = dev->cb(dev->devId, &cryptoInfo, dev->ctx);
1342    }
1343
1344    return wc_CryptoCb_TranslateErrorCode(ret);
1345}
1346
1347int wc_CryptoCb_PqcSign(const byte* in, word32 inlen, byte* out, word32 *outlen,
1348    const byte* context, byte contextLen, word32 preHashType, WC_RNG* rng,
1349    int type, void* key)
1350{
1351    int ret = WC_NO_ERR_TRACE(CRYPTOCB_UNAVAILABLE);
1352    int devId = INVALID_DEVID;
1353    CryptoCb* dev;
1354
1355    if (key == NULL)
1356        return ret;
1357
1358    /* get devId */
1359    devId = wc_CryptoCb_PqcSigGetDevId(type, key);
1360    if (devId == INVALID_DEVID)
1361        return ret;
1362
1363    /* locate registered callback */
1364    dev = wc_CryptoCb_FindDevice(devId, WC_ALGO_TYPE_PK);
1365    if (dev && dev->cb) {
1366        wc_CryptoInfo cryptoInfo;
1367        XMEMSET(&cryptoInfo, 0, sizeof(cryptoInfo));
1368        cryptoInfo.algo_type = WC_ALGO_TYPE_PK;
1369        cryptoInfo.pk.type = WC_PK_TYPE_PQC_SIG_SIGN;
1370        cryptoInfo.pk.pqc_sign.in = in;
1371        cryptoInfo.pk.pqc_sign.inlen = inlen;
1372        cryptoInfo.pk.pqc_sign.out = out;
1373        cryptoInfo.pk.pqc_sign.outlen = outlen;
1374        cryptoInfo.pk.pqc_sign.context = context;
1375        cryptoInfo.pk.pqc_sign.contextLen = contextLen;
1376        cryptoInfo.pk.pqc_sign.preHashType = preHashType;
1377        cryptoInfo.pk.pqc_sign.rng = rng;
1378        cryptoInfo.pk.pqc_sign.key = key;
1379        cryptoInfo.pk.pqc_sign.type = type;
1380
1381        ret = dev->cb(dev->devId, &cryptoInfo, dev->ctx);
1382    }
1383
1384    return wc_CryptoCb_TranslateErrorCode(ret);
1385}
1386
1387int wc_CryptoCb_PqcVerify(const byte* sig, word32 siglen, const byte* msg,
1388    word32 msglen, const byte* context, byte contextLen, word32 preHashType,
1389    int* res, int type, void* key)
1390{
1391    int ret = WC_NO_ERR_TRACE(CRYPTOCB_UNAVAILABLE);
1392    int devId = INVALID_DEVID;
1393    CryptoCb* dev;
1394
1395    if (key == NULL)
1396        return ret;
1397
1398    /* get devId */
1399    devId = wc_CryptoCb_PqcSigGetDevId(type, key);
1400    if (devId == INVALID_DEVID)
1401        return ret;
1402
1403    /* locate registered callback */
1404    dev = wc_CryptoCb_FindDevice(devId, WC_ALGO_TYPE_PK);
1405    if (dev && dev->cb) {
1406        wc_CryptoInfo cryptoInfo;
1407        XMEMSET(&cryptoInfo, 0, sizeof(cryptoInfo));
1408        cryptoInfo.algo_type = WC_ALGO_TYPE_PK;
1409        cryptoInfo.pk.type = WC_PK_TYPE_PQC_SIG_VERIFY;
1410        cryptoInfo.pk.pqc_verify.sig = sig;
1411        cryptoInfo.pk.pqc_verify.siglen = siglen;
1412        cryptoInfo.pk.pqc_verify.msg = msg;
1413        cryptoInfo.pk.pqc_verify.msglen = msglen;
1414        cryptoInfo.pk.pqc_verify.context = context;
1415        cryptoInfo.pk.pqc_verify.contextLen = contextLen;
1416        cryptoInfo.pk.pqc_verify.preHashType = preHashType;
1417        cryptoInfo.pk.pqc_verify.res = res;
1418        cryptoInfo.pk.pqc_verify.key = key;
1419        cryptoInfo.pk.pqc_verify.type = type;
1420
1421        ret = dev->cb(dev->devId, &cryptoInfo, dev->ctx);
1422    }
1423
1424    return wc_CryptoCb_TranslateErrorCode(ret);
1425}
1426
1427int wc_CryptoCb_PqcSignatureCheckPrivKey(void* key, int type,
1428    const byte* pubKey, word32 pubKeySz)
1429{
1430    int ret = WC_NO_ERR_TRACE(CRYPTOCB_UNAVAILABLE);
1431    int devId = INVALID_DEVID;
1432    CryptoCb* dev;
1433
1434    if (key == NULL)
1435        return ret;
1436
1437    /* get devId */
1438    devId = wc_CryptoCb_PqcSigGetDevId(type, key);
1439    if (devId == INVALID_DEVID)
1440        return ret;
1441
1442    /* locate registered callback */
1443    dev = wc_CryptoCb_FindDevice(devId, WC_ALGO_TYPE_PK);
1444    if (dev && dev->cb) {
1445        wc_CryptoInfo cryptoInfo;
1446        XMEMSET(&cryptoInfo, 0, sizeof(cryptoInfo));
1447        cryptoInfo.algo_type = WC_ALGO_TYPE_PK;
1448        cryptoInfo.pk.type = WC_PK_TYPE_PQC_SIG_CHECK_PRIV_KEY;
1449        cryptoInfo.pk.pqc_sig_check.key = key;
1450        cryptoInfo.pk.pqc_sig_check.pubKey = pubKey;
1451        cryptoInfo.pk.pqc_sig_check.pubKeySz = pubKeySz;
1452        cryptoInfo.pk.pqc_sig_check.type = type;
1453
1454        ret = dev->cb(dev->devId, &cryptoInfo, dev->ctx);
1455    }
1456
1457    return wc_CryptoCb_TranslateErrorCode(ret);
1458}
1459#endif /* HAVE_FALCON || HAVE_DILITHIUM */
1460
1461#ifndef NO_AES
1462#ifdef HAVE_AESGCM
1463int wc_CryptoCb_AesGcmEncrypt(Aes* aes, byte* out,
1464                               const byte* in, word32 sz,
1465                               const byte* iv, word32 ivSz,
1466                               byte* authTag, word32 authTagSz,
1467                               const byte* authIn, word32 authInSz)
1468{
1469    int ret = WC_NO_ERR_TRACE(CRYPTOCB_UNAVAILABLE);
1470    CryptoCb* dev;
1471
1472    /* locate registered callback */
1473    if (aes) {
1474        dev = wc_CryptoCb_FindDevice(aes->devId, WC_ALGO_TYPE_CIPHER);
1475    }
1476    else {
1477        /* locate first callback and try using it */
1478        dev = wc_CryptoCb_FindDeviceByIndex(0);
1479    }
1480
1481    if (dev && dev->cb) {
1482        wc_CryptoInfo cryptoInfo;
1483        XMEMSET(&cryptoInfo, 0, sizeof(cryptoInfo));
1484        cryptoInfo.algo_type = WC_ALGO_TYPE_CIPHER;
1485        cryptoInfo.cipher.type = WC_CIPHER_AES_GCM;
1486        cryptoInfo.cipher.enc = 1;
1487        cryptoInfo.cipher.aesgcm_enc.aes       = aes;
1488        cryptoInfo.cipher.aesgcm_enc.out       = out;
1489        cryptoInfo.cipher.aesgcm_enc.in        = in;
1490        cryptoInfo.cipher.aesgcm_enc.sz        = sz;
1491        cryptoInfo.cipher.aesgcm_enc.iv        = iv;
1492        cryptoInfo.cipher.aesgcm_enc.ivSz      = ivSz;
1493        cryptoInfo.cipher.aesgcm_enc.authTag   = authTag;
1494        cryptoInfo.cipher.aesgcm_enc.authTagSz = authTagSz;
1495        cryptoInfo.cipher.aesgcm_enc.authIn    = authIn;
1496        cryptoInfo.cipher.aesgcm_enc.authInSz  = authInSz;
1497
1498        ret = dev->cb(dev->devId, &cryptoInfo, dev->ctx);
1499    }
1500
1501    return wc_CryptoCb_TranslateErrorCode(ret);
1502}
1503
1504int wc_CryptoCb_AesGcmDecrypt(Aes* aes, byte* out,
1505                               const byte* in, word32 sz,
1506                               const byte* iv, word32 ivSz,
1507                               const byte* authTag, word32 authTagSz,
1508                               const byte* authIn, word32 authInSz)
1509{
1510    int ret = WC_NO_ERR_TRACE(CRYPTOCB_UNAVAILABLE);
1511    CryptoCb* dev;
1512
1513    /* locate registered callback */
1514    if (aes) {
1515        dev = wc_CryptoCb_FindDevice(aes->devId, WC_ALGO_TYPE_CIPHER);
1516    }
1517    else {
1518        /* locate first callback and try using it */
1519        dev = wc_CryptoCb_FindDeviceByIndex(0);
1520    }
1521
1522    if (dev && dev->cb) {
1523        wc_CryptoInfo cryptoInfo;
1524        XMEMSET(&cryptoInfo, 0, sizeof(cryptoInfo));
1525        cryptoInfo.algo_type = WC_ALGO_TYPE_CIPHER;
1526        cryptoInfo.cipher.type = WC_CIPHER_AES_GCM;
1527        cryptoInfo.cipher.enc = 0;
1528        cryptoInfo.cipher.aesgcm_dec.aes       = aes;
1529        cryptoInfo.cipher.aesgcm_dec.out       = out;
1530        cryptoInfo.cipher.aesgcm_dec.in        = in;
1531        cryptoInfo.cipher.aesgcm_dec.sz        = sz;
1532        cryptoInfo.cipher.aesgcm_dec.iv        = iv;
1533        cryptoInfo.cipher.aesgcm_dec.ivSz      = ivSz;
1534        cryptoInfo.cipher.aesgcm_dec.authTag   = authTag;
1535        cryptoInfo.cipher.aesgcm_dec.authTagSz = authTagSz;
1536        cryptoInfo.cipher.aesgcm_dec.authIn    = authIn;
1537        cryptoInfo.cipher.aesgcm_dec.authInSz  = authInSz;
1538
1539        ret = dev->cb(dev->devId, &cryptoInfo, dev->ctx);
1540    }
1541
1542    return wc_CryptoCb_TranslateErrorCode(ret);
1543}
1544#endif /* HAVE_AESGCM */
1545
1546#ifdef HAVE_AESCCM
1547int wc_CryptoCb_AesCcmEncrypt(Aes* aes, byte* out,
1548                               const byte* in, word32 sz,
1549                               const byte* nonce, word32 nonceSz,
1550                               byte* authTag, word32 authTagSz,
1551                               const byte* authIn, word32 authInSz)
1552{
1553    int ret = WC_NO_ERR_TRACE(CRYPTOCB_UNAVAILABLE);
1554    CryptoCb* dev;
1555
1556    /* locate registered callback */
1557    if (aes) {
1558        dev = wc_CryptoCb_FindDevice(aes->devId, WC_ALGO_TYPE_CIPHER);
1559    }
1560    else {
1561        /* locate first callback and try using it */
1562        dev = wc_CryptoCb_FindDeviceByIndex(0);
1563    }
1564
1565    if (dev && dev->cb) {
1566        wc_CryptoInfo cryptoInfo;
1567        XMEMSET(&cryptoInfo, 0, sizeof(cryptoInfo));
1568        cryptoInfo.algo_type = WC_ALGO_TYPE_CIPHER;
1569        cryptoInfo.cipher.type = WC_CIPHER_AES_CCM;
1570        cryptoInfo.cipher.enc = 1;
1571        cryptoInfo.cipher.aesccm_enc.aes       = aes;
1572        cryptoInfo.cipher.aesccm_enc.out       = out;
1573        cryptoInfo.cipher.aesccm_enc.in        = in;
1574        cryptoInfo.cipher.aesccm_enc.sz        = sz;
1575        cryptoInfo.cipher.aesccm_enc.nonce     = nonce;
1576        cryptoInfo.cipher.aesccm_enc.nonceSz   = nonceSz;
1577        cryptoInfo.cipher.aesccm_enc.authTag   = authTag;
1578        cryptoInfo.cipher.aesccm_enc.authTagSz = authTagSz;
1579        cryptoInfo.cipher.aesccm_enc.authIn    = authIn;
1580        cryptoInfo.cipher.aesccm_enc.authInSz  = authInSz;
1581
1582        ret = dev->cb(dev->devId, &cryptoInfo, dev->ctx);
1583    }
1584
1585    return wc_CryptoCb_TranslateErrorCode(ret);
1586}
1587
1588int wc_CryptoCb_AesCcmDecrypt(Aes* aes, byte* out,
1589                               const byte* in, word32 sz,
1590                               const byte* nonce, word32 nonceSz,
1591                               const byte* authTag, word32 authTagSz,
1592                               const byte* authIn, word32 authInSz)
1593{
1594    int ret = WC_NO_ERR_TRACE(CRYPTOCB_UNAVAILABLE);
1595    CryptoCb* dev;
1596
1597    /* locate registered callback */
1598    if (aes) {
1599        dev = wc_CryptoCb_FindDevice(aes->devId, WC_ALGO_TYPE_CIPHER);
1600    }
1601    else {
1602        /* locate first callback and try using it */
1603        dev = wc_CryptoCb_FindDeviceByIndex(0);
1604    }
1605
1606    if (dev && dev->cb) {
1607        wc_CryptoInfo cryptoInfo;
1608        XMEMSET(&cryptoInfo, 0, sizeof(cryptoInfo));
1609        cryptoInfo.algo_type = WC_ALGO_TYPE_CIPHER;
1610        cryptoInfo.cipher.type = WC_CIPHER_AES_CCM;
1611        cryptoInfo.cipher.enc = 0;
1612        cryptoInfo.cipher.aesccm_dec.aes       = aes;
1613        cryptoInfo.cipher.aesccm_dec.out       = out;
1614        cryptoInfo.cipher.aesccm_dec.in        = in;
1615        cryptoInfo.cipher.aesccm_dec.sz        = sz;
1616        cryptoInfo.cipher.aesccm_dec.nonce     = nonce;
1617        cryptoInfo.cipher.aesccm_dec.nonceSz   = nonceSz;
1618        cryptoInfo.cipher.aesccm_dec.authTag   = authTag;
1619        cryptoInfo.cipher.aesccm_dec.authTagSz = authTagSz;
1620        cryptoInfo.cipher.aesccm_dec.authIn    = authIn;
1621        cryptoInfo.cipher.aesccm_dec.authInSz  = authInSz;
1622
1623        ret = dev->cb(dev->devId, &cryptoInfo, dev->ctx);
1624    }
1625
1626    return wc_CryptoCb_TranslateErrorCode(ret);
1627}
1628#endif /* HAVE_AESCCM */
1629
1630#ifdef HAVE_AES_CBC
1631int wc_CryptoCb_AesCbcEncrypt(Aes* aes, byte* out,
1632                               const byte* in, word32 sz)
1633{
1634    int ret = WC_NO_ERR_TRACE(CRYPTOCB_UNAVAILABLE);
1635    CryptoCb* dev;
1636
1637    /* locate registered callback */
1638    if (aes) {
1639        dev = wc_CryptoCb_FindDevice(aes->devId, WC_ALGO_TYPE_CIPHER);
1640    }
1641    else {
1642        /* locate first callback and try using it */
1643        dev = wc_CryptoCb_FindDeviceByIndex(0);
1644    }
1645
1646    if (dev && dev->cb) {
1647        wc_CryptoInfo cryptoInfo;
1648        XMEMSET(&cryptoInfo, 0, sizeof(cryptoInfo));
1649        cryptoInfo.algo_type = WC_ALGO_TYPE_CIPHER;
1650        cryptoInfo.cipher.type = WC_CIPHER_AES_CBC;
1651        cryptoInfo.cipher.enc = 1;
1652        cryptoInfo.cipher.aescbc.aes = aes;
1653        cryptoInfo.cipher.aescbc.out = out;
1654        cryptoInfo.cipher.aescbc.in = in;
1655        cryptoInfo.cipher.aescbc.sz = sz;
1656
1657        ret = dev->cb(dev->devId, &cryptoInfo, dev->ctx);
1658    }
1659
1660    return wc_CryptoCb_TranslateErrorCode(ret);
1661}
1662
1663int wc_CryptoCb_AesCbcDecrypt(Aes* aes, byte* out,
1664                               const byte* in, word32 sz)
1665{
1666    int ret = WC_NO_ERR_TRACE(CRYPTOCB_UNAVAILABLE);
1667    CryptoCb* dev;
1668
1669    /* locate registered callback */
1670    if (aes) {
1671        dev = wc_CryptoCb_FindDevice(aes->devId, WC_ALGO_TYPE_CIPHER);
1672    }
1673    else {
1674        /* locate first callback and try using it */
1675        dev = wc_CryptoCb_FindDeviceByIndex(0);
1676    }
1677
1678    if (dev && dev->cb) {
1679        wc_CryptoInfo cryptoInfo;
1680        XMEMSET(&cryptoInfo, 0, sizeof(cryptoInfo));
1681        cryptoInfo.algo_type = WC_ALGO_TYPE_CIPHER;
1682        cryptoInfo.cipher.type = WC_CIPHER_AES_CBC;
1683        cryptoInfo.cipher.enc = 0;
1684        cryptoInfo.cipher.aescbc.aes = aes;
1685        cryptoInfo.cipher.aescbc.out = out;
1686        cryptoInfo.cipher.aescbc.in = in;
1687        cryptoInfo.cipher.aescbc.sz = sz;
1688
1689        ret = dev->cb(dev->devId, &cryptoInfo, dev->ctx);
1690    }
1691
1692    return wc_CryptoCb_TranslateErrorCode(ret);
1693}
1694#endif /* HAVE_AES_CBC */
1695#ifdef WOLFSSL_AES_COUNTER
1696int wc_CryptoCb_AesCtrEncrypt(Aes* aes, byte* out,
1697                               const byte* in, word32 sz)
1698{
1699    int ret = WC_NO_ERR_TRACE(CRYPTOCB_UNAVAILABLE);
1700    CryptoCb* dev;
1701
1702    /* locate registered callback */
1703    if (aes) {
1704        dev = wc_CryptoCb_FindDevice(aes->devId, WC_ALGO_TYPE_CIPHER);
1705    }
1706    else {
1707        /* locate first callback and try using it */
1708        dev = wc_CryptoCb_FindDeviceByIndex(0);
1709    }
1710
1711    if (dev && dev->cb) {
1712        wc_CryptoInfo cryptoInfo;
1713        XMEMSET(&cryptoInfo, 0, sizeof(cryptoInfo));
1714        cryptoInfo.algo_type = WC_ALGO_TYPE_CIPHER;
1715        cryptoInfo.cipher.type = WC_CIPHER_AES_CTR;
1716        cryptoInfo.cipher.enc = 1;
1717        cryptoInfo.cipher.aesctr.aes = aes;
1718        cryptoInfo.cipher.aesctr.out = out;
1719        cryptoInfo.cipher.aesctr.in = in;
1720        cryptoInfo.cipher.aesctr.sz = sz;
1721
1722        ret = dev->cb(dev->devId, &cryptoInfo, dev->ctx);
1723    }
1724
1725    return wc_CryptoCb_TranslateErrorCode(ret);
1726}
1727#endif /* WOLFSSL_AES_COUNTER */
1728#if defined(HAVE_AES_ECB) || defined(WOLFSSL_AES_DIRECT) || \
1729    defined(WOLF_CRYPTO_CB_ONLY_AES)
1730int wc_CryptoCb_AesEcbEncrypt(Aes* aes, byte* out,
1731                               const byte* in, word32 sz)
1732{
1733    int ret = WC_NO_ERR_TRACE(CRYPTOCB_UNAVAILABLE);
1734    CryptoCb* dev;
1735
1736    /* locate registered callback */
1737    if (aes) {
1738        dev = wc_CryptoCb_FindDevice(aes->devId, WC_ALGO_TYPE_CIPHER);
1739    }
1740    else {
1741        /* locate first callback and try using it */
1742        dev = wc_CryptoCb_FindDeviceByIndex(0);
1743    }
1744
1745    if (dev && dev->cb) {
1746        wc_CryptoInfo cryptoInfo;
1747        XMEMSET(&cryptoInfo, 0, sizeof(cryptoInfo));
1748        cryptoInfo.algo_type = WC_ALGO_TYPE_CIPHER;
1749        cryptoInfo.cipher.type = WC_CIPHER_AES_ECB;
1750        cryptoInfo.cipher.enc = 1;
1751        cryptoInfo.cipher.aesecb.aes = aes;
1752        cryptoInfo.cipher.aesecb.out = out;
1753        cryptoInfo.cipher.aesecb.in = in;
1754        cryptoInfo.cipher.aesecb.sz = sz;
1755
1756        ret = dev->cb(dev->devId, &cryptoInfo, dev->ctx);
1757    }
1758
1759    return wc_CryptoCb_TranslateErrorCode(ret);
1760}
1761
1762int wc_CryptoCb_AesEcbDecrypt(Aes* aes, byte* out,
1763                               const byte* in, word32 sz)
1764{
1765    int ret = WC_NO_ERR_TRACE(CRYPTOCB_UNAVAILABLE);
1766    CryptoCb* dev;
1767
1768    /* locate registered callback */
1769    if (aes) {
1770        dev = wc_CryptoCb_FindDevice(aes->devId, WC_ALGO_TYPE_CIPHER);
1771    }
1772    else {
1773        /* locate first callback and try using it */
1774        dev = wc_CryptoCb_FindDeviceByIndex(0);
1775    }
1776
1777    if (dev && dev->cb) {
1778        wc_CryptoInfo cryptoInfo;
1779        XMEMSET(&cryptoInfo, 0, sizeof(cryptoInfo));
1780        cryptoInfo.algo_type = WC_ALGO_TYPE_CIPHER;
1781        cryptoInfo.cipher.type = WC_CIPHER_AES_ECB;
1782        cryptoInfo.cipher.enc = 0;
1783        cryptoInfo.cipher.aesecb.aes = aes;
1784        cryptoInfo.cipher.aesecb.out = out;
1785        cryptoInfo.cipher.aesecb.in = in;
1786        cryptoInfo.cipher.aesecb.sz = sz;
1787
1788        ret = dev->cb(dev->devId, &cryptoInfo, dev->ctx);
1789    }
1790
1791    return wc_CryptoCb_TranslateErrorCode(ret);
1792}
1793#endif /* HAVE_AES_ECB || WOLFSSL_AES_DIRECT || WOLF_CRYPTO_CB_ONLY_AES */
1794
1795#ifdef WOLF_CRYPTO_CB_AES_SETKEY
1796int wc_CryptoCb_AesSetKey(Aes* aes, const byte* key, word32 keySz)
1797{
1798    int ret = WC_NO_ERR_TRACE(CRYPTOCB_UNAVAILABLE);
1799    CryptoCb* dev;
1800
1801    if (aes == NULL || key == NULL)
1802        return BAD_FUNC_ARG;
1803
1804    if (aes->devId == INVALID_DEVID)
1805        return CRYPTOCB_UNAVAILABLE;
1806
1807    /* locate registered callback */
1808    dev = wc_CryptoCb_FindDevice(aes->devId, WC_ALGO_TYPE_CIPHER);
1809    if (dev && dev->cb) {
1810        wc_CryptoInfo cryptoInfo;
1811        XMEMSET(&cryptoInfo, 0, sizeof(cryptoInfo));
1812        cryptoInfo.algo_type = WC_ALGO_TYPE_CIPHER;
1813        cryptoInfo.cipher.type = WC_CIPHER_AES;
1814        cryptoInfo.cipher.aessetkey.aes = aes;
1815        cryptoInfo.cipher.aessetkey.key = key;
1816        cryptoInfo.cipher.aessetkey.keySz = keySz;
1817
1818        ret = dev->cb(dev->devId, &cryptoInfo, dev->ctx);
1819    }
1820
1821    return wc_CryptoCb_TranslateErrorCode(ret);
1822}
1823#endif /* WOLF_CRYPTO_CB_AES_SETKEY */
1824#endif /* !NO_AES */
1825
1826#ifndef NO_DES3
1827int wc_CryptoCb_Des3Encrypt(Des3* des3, byte* out,
1828                               const byte* in, word32 sz)
1829{
1830    int ret = WC_NO_ERR_TRACE(CRYPTOCB_UNAVAILABLE);
1831    CryptoCb* dev;
1832
1833    /* locate registered callback */
1834    if (des3) {
1835        dev = wc_CryptoCb_FindDevice(des3->devId, WC_ALGO_TYPE_CIPHER);
1836    }
1837    else {
1838        /* locate first callback and try using it */
1839        dev = wc_CryptoCb_FindDeviceByIndex(0);
1840    }
1841
1842    if (dev && dev->cb) {
1843        wc_CryptoInfo cryptoInfo;
1844        XMEMSET(&cryptoInfo, 0, sizeof(cryptoInfo));
1845        cryptoInfo.algo_type = WC_ALGO_TYPE_CIPHER;
1846        cryptoInfo.cipher.type = WC_CIPHER_DES3;
1847        cryptoInfo.cipher.enc = 1;
1848        cryptoInfo.cipher.des3.des = des3;
1849        cryptoInfo.cipher.des3.out = out;
1850        cryptoInfo.cipher.des3.in = in;
1851        cryptoInfo.cipher.des3.sz = sz;
1852
1853        ret = dev->cb(dev->devId, &cryptoInfo, dev->ctx);
1854    }
1855
1856    return wc_CryptoCb_TranslateErrorCode(ret);
1857}
1858
1859int wc_CryptoCb_Des3Decrypt(Des3* des3, byte* out,
1860                               const byte* in, word32 sz)
1861{
1862    int ret = WC_NO_ERR_TRACE(CRYPTOCB_UNAVAILABLE);
1863    CryptoCb* dev;
1864
1865    /* locate registered callback */
1866    if (des3) {
1867        dev = wc_CryptoCb_FindDevice(des3->devId, WC_ALGO_TYPE_CIPHER);
1868    }
1869    else {
1870        /* locate first callback and try using it */
1871        dev = wc_CryptoCb_FindDeviceByIndex(0);
1872    }
1873
1874    if (dev && dev->cb) {
1875        wc_CryptoInfo cryptoInfo;
1876        XMEMSET(&cryptoInfo, 0, sizeof(cryptoInfo));
1877        cryptoInfo.algo_type = WC_ALGO_TYPE_CIPHER;
1878        cryptoInfo.cipher.type = WC_CIPHER_DES3;
1879        cryptoInfo.cipher.enc = 0;
1880        cryptoInfo.cipher.des3.des = des3;
1881        cryptoInfo.cipher.des3.out = out;
1882        cryptoInfo.cipher.des3.in = in;
1883        cryptoInfo.cipher.des3.sz = sz;
1884
1885        ret = dev->cb(dev->devId, &cryptoInfo, dev->ctx);
1886    }
1887
1888    return wc_CryptoCb_TranslateErrorCode(ret);
1889}
1890#endif /* !NO_DES3 */
1891
1892#ifndef NO_SHA
1893int wc_CryptoCb_ShaHash(wc_Sha* sha, const byte* in,
1894    word32 inSz, byte* digest)
1895{
1896    int ret = WC_NO_ERR_TRACE(CRYPTOCB_UNAVAILABLE);
1897    CryptoCb* dev;
1898
1899    /* locate registered callback */
1900    if (sha) {
1901        dev = wc_CryptoCb_FindDevice(sha->devId, WC_ALGO_TYPE_HASH);
1902    }
1903    else {
1904        /* locate first callback and try using it */
1905        dev = wc_CryptoCb_FindDeviceByIndex(0);
1906    }
1907
1908    if (dev && dev->cb) {
1909        wc_CryptoInfo cryptoInfo;
1910        XMEMSET(&cryptoInfo, 0, sizeof(cryptoInfo));
1911        cryptoInfo.algo_type = WC_ALGO_TYPE_HASH;
1912        cryptoInfo.hash.type = WC_HASH_TYPE_SHA;
1913        cryptoInfo.hash.sha1 = sha;
1914        cryptoInfo.hash.in = in;
1915        cryptoInfo.hash.inSz = inSz;
1916        cryptoInfo.hash.digest = digest;
1917
1918        ret = dev->cb(dev->devId, &cryptoInfo, dev->ctx);
1919    }
1920
1921    return wc_CryptoCb_TranslateErrorCode(ret);
1922}
1923#endif /* !NO_SHA */
1924
1925#ifdef WOLFSSL_SHA224
1926int wc_CryptoCb_Sha224Hash(wc_Sha224* sha224, const byte* in,
1927    word32 inSz, byte* digest)
1928{
1929    int ret = WC_NO_ERR_TRACE(CRYPTOCB_UNAVAILABLE);
1930    CryptoCb* dev;
1931
1932    /* locate registered callback */
1933    if (sha224) {
1934        dev = wc_CryptoCb_FindDevice(sha224->devId, WC_ALGO_TYPE_HASH);
1935    }
1936    else {
1937        /* locate first callback and try using it */
1938        dev = wc_CryptoCb_FindDeviceByIndex(0);
1939    }
1940
1941    if (dev && dev->cb) {
1942        wc_CryptoInfo cryptoInfo;
1943        XMEMSET(&cryptoInfo, 0, sizeof(cryptoInfo));
1944        cryptoInfo.algo_type = WC_ALGO_TYPE_HASH;
1945        cryptoInfo.hash.type = WC_HASH_TYPE_SHA224;
1946        cryptoInfo.hash.sha224 = sha224;
1947        cryptoInfo.hash.in = in;
1948        cryptoInfo.hash.inSz = inSz;
1949        cryptoInfo.hash.digest = digest;
1950
1951        ret = dev->cb(dev->devId, &cryptoInfo, dev->ctx);
1952    }
1953
1954    return wc_CryptoCb_TranslateErrorCode(ret);
1955}
1956#endif /* WOLFSSL_SHA224 */
1957
1958
1959#ifndef NO_SHA256
1960int wc_CryptoCb_Sha256Hash(wc_Sha256* sha256, const byte* in,
1961    word32 inSz, byte* digest)
1962{
1963    int ret = WC_NO_ERR_TRACE(CRYPTOCB_UNAVAILABLE);
1964    CryptoCb* dev;
1965
1966    /* locate registered callback */
1967    if (sha256) {
1968        dev = wc_CryptoCb_FindDevice(sha256->devId, WC_ALGO_TYPE_HASH);
1969    }
1970    else {
1971        /* locate first callback and try using it */
1972        dev = wc_CryptoCb_FindDeviceByIndex(0);
1973    }
1974
1975    if (dev && dev->cb) {
1976        wc_CryptoInfo cryptoInfo;
1977        XMEMSET(&cryptoInfo, 0, sizeof(cryptoInfo));
1978        cryptoInfo.algo_type = WC_ALGO_TYPE_HASH;
1979        cryptoInfo.hash.type = WC_HASH_TYPE_SHA256;
1980        cryptoInfo.hash.sha256 = sha256;
1981        cryptoInfo.hash.in = in;
1982        cryptoInfo.hash.inSz = inSz;
1983        cryptoInfo.hash.digest = digest;
1984
1985        ret = dev->cb(dev->devId, &cryptoInfo, dev->ctx);
1986    }
1987
1988    return wc_CryptoCb_TranslateErrorCode(ret);
1989}
1990#endif /* !NO_SHA256 */
1991
1992#ifdef WOLFSSL_SHA384
1993int wc_CryptoCb_Sha384Hash(wc_Sha384* sha384, const byte* in,
1994    word32 inSz, byte* digest)
1995{
1996    int ret = WC_NO_ERR_TRACE(CRYPTOCB_UNAVAILABLE);
1997    CryptoCb* dev;
1998
1999    /* locate registered callback */
2000    #ifndef NO_SHA2_CRYPTO_CB
2001    if (sha384) {
2002        dev = wc_CryptoCb_FindDevice(sha384->devId, WC_ALGO_TYPE_HASH);
2003    }
2004    else
2005    #endif
2006    {
2007        /* locate first callback and try using it */
2008        dev = wc_CryptoCb_FindDeviceByIndex(0);
2009    }
2010
2011    if (dev && dev->cb) {
2012        wc_CryptoInfo cryptoInfo;
2013        XMEMSET(&cryptoInfo, 0, sizeof(cryptoInfo));
2014        cryptoInfo.algo_type = WC_ALGO_TYPE_HASH;
2015        cryptoInfo.hash.type = WC_HASH_TYPE_SHA384;
2016        cryptoInfo.hash.sha384 = sha384;
2017        cryptoInfo.hash.in = in;
2018        cryptoInfo.hash.inSz = inSz;
2019        cryptoInfo.hash.digest = digest;
2020
2021        ret = dev->cb(dev->devId, &cryptoInfo, dev->ctx);
2022    }
2023
2024    return wc_CryptoCb_TranslateErrorCode(ret);
2025}
2026#endif /* WOLFSSL_SHA384 */
2027
2028#ifdef WOLFSSL_SHA512
2029int wc_CryptoCb_Sha512Hash(wc_Sha512* sha512, const byte* in,
2030    word32 inSz, byte* digest, size_t digestSz)
2031{
2032    int ret = WC_NO_ERR_TRACE(CRYPTOCB_UNAVAILABLE);
2033    CryptoCb* dev;
2034
2035    /* locate registered callback */
2036    #ifndef NO_SHA2_CRYPTO_CB
2037    if (sha512) {
2038        dev = wc_CryptoCb_FindDevice(sha512->devId, WC_ALGO_TYPE_HASH);
2039    }
2040    else
2041    #endif
2042    {
2043        /* locate first callback and try using it */
2044        dev = wc_CryptoCb_FindDeviceByIndex(0);
2045    }
2046
2047    if (dev && dev->cb) {
2048        byte localHash[WC_SHA512_DIGEST_SIZE];
2049        wc_CryptoInfo cryptoInfo;
2050        XMEMSET(&cryptoInfo, 0, sizeof(cryptoInfo));
2051        cryptoInfo.algo_type = WC_ALGO_TYPE_HASH;
2052        cryptoInfo.hash.sha512 = sha512;
2053        cryptoInfo.hash.in = in;
2054        cryptoInfo.hash.inSz = inSz;
2055        cryptoInfo.hash.digest = digest;
2056
2057        /* try the specific family callbacks first */
2058#if !defined(WOLFSSL_NOSHA512_224)
2059        if (digest != NULL && digestSz == WC_SHA512_224_DIGEST_SIZE) {
2060          cryptoInfo.hash.type = WC_HASH_TYPE_SHA512_224;
2061          ret = dev->cb(dev->devId, &cryptoInfo, dev->ctx);
2062          ret = wc_CryptoCb_TranslateErrorCode(ret);
2063          if (ret != WC_NO_ERR_TRACE(CRYPTOCB_UNAVAILABLE))
2064            return ret;
2065        }
2066#endif
2067#if !defined(WOLFSSL_NOSHA512_256)
2068        if (digest != NULL && digestSz == WC_SHA512_256_DIGEST_SIZE) {
2069          cryptoInfo.hash.type = WC_HASH_TYPE_SHA512_256;
2070          ret = dev->cb(dev->devId, &cryptoInfo, dev->ctx);
2071          ret = wc_CryptoCb_TranslateErrorCode(ret);
2072          if (ret != WC_NO_ERR_TRACE(CRYPTOCB_UNAVAILABLE))
2073            return ret;
2074        }
2075#endif
2076        cryptoInfo.hash.type = WC_HASH_TYPE_SHA512;
2077        /* use local buffer if not full size */
2078        if (digest != NULL && digestSz != WC_SHA512_DIGEST_SIZE)
2079            cryptoInfo.hash.digest = localHash;
2080        ret = dev->cb(dev->devId, &cryptoInfo, dev->ctx);
2081        ret = wc_CryptoCb_TranslateErrorCode(ret);
2082        if (ret == 0 && digest != NULL && digestSz != WC_SHA512_DIGEST_SIZE)
2083            XMEMCPY(digest, localHash, digestSz);
2084        return ret;
2085    }
2086
2087    return wc_CryptoCb_TranslateErrorCode(ret);
2088}
2089#endif /* WOLFSSL_SHA512 */
2090
2091#if defined(WOLFSSL_SHA3) && (!defined(HAVE_FIPS) || FIPS_VERSION_GE(6, 0))
2092int wc_CryptoCb_Sha3Hash(wc_Sha3* sha3, int type, const byte* in,
2093    word32 inSz, byte* digest)
2094{
2095    int ret = WC_NO_ERR_TRACE(CRYPTOCB_UNAVAILABLE);
2096    CryptoCb* dev;
2097
2098    /* locate registered callback */
2099    if (sha3) {
2100        dev = wc_CryptoCb_FindDevice(sha3->devId, WC_ALGO_TYPE_HASH);
2101    }
2102    else
2103    {
2104        /* locate first callback and try using it */
2105        dev = wc_CryptoCb_FindDeviceByIndex(0);
2106    }
2107
2108    if (dev && dev->cb) {
2109        wc_CryptoInfo cryptoInfo;
2110        XMEMSET(&cryptoInfo, 0, sizeof(cryptoInfo));
2111        cryptoInfo.algo_type = WC_ALGO_TYPE_HASH;
2112        cryptoInfo.hash.type = type;
2113        cryptoInfo.hash.sha3 = sha3;
2114        cryptoInfo.hash.in = in;
2115        cryptoInfo.hash.inSz = inSz;
2116        cryptoInfo.hash.digest = digest;
2117
2118        ret = dev->cb(dev->devId, &cryptoInfo, dev->ctx);
2119    }
2120
2121    return wc_CryptoCb_TranslateErrorCode(ret);
2122}
2123#endif /* WOLFSSL_SHA3 && (!HAVE_FIPS || FIPS_VERSION_GE(6, 0)) */
2124
2125#ifndef NO_HMAC
2126int wc_CryptoCb_Hmac(Hmac* hmac, int macType, const byte* in, word32 inSz,
2127    byte* digest)
2128{
2129    int ret = WC_NO_ERR_TRACE(CRYPTOCB_UNAVAILABLE);
2130    CryptoCb* dev;
2131
2132    if (hmac == NULL)
2133        return ret;
2134
2135    /* locate registered callback */
2136    dev = wc_CryptoCb_FindDevice(hmac->devId, WC_ALGO_TYPE_HMAC);
2137    if (dev && dev->cb) {
2138        wc_CryptoInfo cryptoInfo;
2139        XMEMSET(&cryptoInfo, 0, sizeof(cryptoInfo));
2140        cryptoInfo.algo_type = WC_ALGO_TYPE_HMAC;
2141        cryptoInfo.hmac.macType = macType;
2142        cryptoInfo.hmac.in = in;
2143        cryptoInfo.hmac.inSz = inSz;
2144        cryptoInfo.hmac.digest = digest;
2145        cryptoInfo.hmac.hmac = hmac;
2146
2147        ret = dev->cb(dev->devId, &cryptoInfo, dev->ctx);
2148    }
2149
2150    return wc_CryptoCb_TranslateErrorCode(ret);
2151}
2152#endif /* !NO_HMAC */
2153
2154#ifndef WC_NO_RNG
2155int wc_CryptoCb_RandomBlock(WC_RNG* rng, byte* out, word32 sz)
2156{
2157    int ret = WC_NO_ERR_TRACE(CRYPTOCB_UNAVAILABLE);
2158    CryptoCb* dev;
2159
2160    /* locate registered callback */
2161    if (rng) {
2162        dev = wc_CryptoCb_FindDevice(rng->devId, WC_ALGO_TYPE_RNG);
2163    }
2164    else {
2165        /* locate first callback and try using it */
2166        dev = wc_CryptoCb_FindDeviceByIndex(0);
2167    }
2168
2169    if (dev && dev->cb) {
2170        wc_CryptoInfo cryptoInfo;
2171        XMEMSET(&cryptoInfo, 0, sizeof(cryptoInfo));
2172        cryptoInfo.algo_type = WC_ALGO_TYPE_RNG;
2173        cryptoInfo.rng.rng = rng;
2174        cryptoInfo.rng.out = out;
2175        cryptoInfo.rng.sz = sz;
2176
2177        ret = dev->cb(dev->devId, &cryptoInfo, dev->ctx);
2178    }
2179
2180    return wc_CryptoCb_TranslateErrorCode(ret);
2181}
2182
2183int wc_CryptoCb_RandomSeed(OS_Seed* os, byte* seed, word32 sz)
2184{
2185    int ret = WC_NO_ERR_TRACE(CRYPTOCB_UNAVAILABLE);
2186    CryptoCb* dev;
2187
2188    /* locate registered callback */
2189    dev = wc_CryptoCb_FindDevice(os->devId, WC_ALGO_TYPE_SEED);
2190    if (dev && dev->cb) {
2191        wc_CryptoInfo cryptoInfo;
2192        XMEMSET(&cryptoInfo, 0, sizeof(cryptoInfo));
2193        cryptoInfo.algo_type = WC_ALGO_TYPE_SEED;
2194        cryptoInfo.seed.os = os;
2195        cryptoInfo.seed.seed = seed;
2196        cryptoInfo.seed.sz = sz;
2197
2198        ret = dev->cb(dev->devId, &cryptoInfo, dev->ctx);
2199    }
2200
2201    return wc_CryptoCb_TranslateErrorCode(ret);
2202}
2203#endif /* !WC_NO_RNG */
2204
2205#ifndef NO_CERTS
2206int wc_CryptoCb_GetCert(int devId, const char *label, word32 labelLen,
2207                        const byte *id, word32 idLen, byte** out,
2208                        word32* outSz, int *format, void *heap)
2209{
2210    int ret = WC_NO_ERR_TRACE(CRYPTOCB_UNAVAILABLE);
2211    CryptoCb* dev;
2212
2213    /* locate registered callback */
2214    dev = wc_CryptoCb_FindDevice(devId, WC_ALGO_TYPE_CERT);
2215    if (dev && dev->cb) {
2216        wc_CryptoInfo cryptoInfo;
2217        XMEMSET(&cryptoInfo, 0, sizeof(cryptoInfo));
2218        cryptoInfo.algo_type = WC_ALGO_TYPE_CERT;
2219        cryptoInfo.cert.label = label;
2220        cryptoInfo.cert.labelLen = labelLen;
2221        cryptoInfo.cert.id = id;
2222        cryptoInfo.cert.idLen = idLen;
2223        cryptoInfo.cert.heap = heap;
2224        cryptoInfo.cert.certDataOut = out;
2225        cryptoInfo.cert.certSz = outSz;
2226        cryptoInfo.cert.certFormatOut = format;
2227        cryptoInfo.cert.heap = heap;
2228
2229        ret = dev->cb(dev->devId, &cryptoInfo, dev->ctx);
2230    }
2231
2232    return wc_CryptoCb_TranslateErrorCode(ret);
2233}
2234#endif /* ifndef NO_CERTS */
2235
2236#if defined(WOLFSSL_CMAC)
2237int wc_CryptoCb_Cmac(Cmac* cmac, const byte* key, word32 keySz,
2238        const byte* in, word32 inSz, byte* out, word32* outSz, int type,
2239        void* ctx)
2240{
2241    int ret = WC_NO_ERR_TRACE(CRYPTOCB_UNAVAILABLE);
2242    CryptoCb* dev;
2243
2244    /* locate registered callback */
2245    if (cmac) {
2246        dev = wc_CryptoCb_FindDevice(cmac->devId, WC_ALGO_TYPE_CMAC);
2247    }
2248    else {
2249        /* locate first callback and try using it */
2250        dev = wc_CryptoCb_FindDeviceByIndex(0);
2251    }
2252    if (dev && dev->cb) {
2253        wc_CryptoInfo cryptoInfo;
2254        XMEMSET(&cryptoInfo, 0, sizeof(cryptoInfo));
2255        cryptoInfo.algo_type = WC_ALGO_TYPE_CMAC;
2256
2257        cryptoInfo.cmac.cmac  = cmac;
2258        cryptoInfo.cmac.ctx   = ctx;
2259        cryptoInfo.cmac.key   = key;
2260        cryptoInfo.cmac.in    = in;
2261        cryptoInfo.cmac.out   = out;
2262        cryptoInfo.cmac.outSz = outSz;
2263        cryptoInfo.cmac.keySz = keySz;
2264        cryptoInfo.cmac.inSz  = inSz;
2265        cryptoInfo.cmac.type  = type;
2266
2267        ret = dev->cb(dev->devId, &cryptoInfo, dev->ctx);
2268    }
2269
2270    return wc_CryptoCb_TranslateErrorCode(ret);
2271}
2272#endif /* WOLFSSL_CMAC */
2273
2274#ifdef WOLFSSL_SHE
2275int wc_CryptoCb_SheGetUid(wc_SHE* she, byte* uid, word32 uidSz,
2276                            const void* ctx)
2277{
2278    int ret = WC_NO_ERR_TRACE(CRYPTOCB_UNAVAILABLE);
2279    CryptoCb* dev;
2280
2281    if (she == NULL) {
2282        return BAD_FUNC_ARG;
2283    }
2284
2285    /* locate registered callback */
2286    dev = wc_CryptoCb_FindDevice(she->devId, WC_ALGO_TYPE_SHE);
2287    if (dev && dev->cb) {
2288        wc_CryptoInfo cryptoInfo;
2289        XMEMSET(&cryptoInfo, 0, sizeof(cryptoInfo));
2290        cryptoInfo.algo_type          = WC_ALGO_TYPE_SHE;
2291        cryptoInfo.she.she            = she;
2292        cryptoInfo.she.type           = WC_SHE_GET_UID;
2293        cryptoInfo.she.ctx            = ctx;
2294        cryptoInfo.she.op.getUid.uid  = uid;
2295        cryptoInfo.she.op.getUid.uidSz = uidSz;
2296
2297        ret = dev->cb(dev->devId, &cryptoInfo, dev->ctx);
2298    }
2299
2300    return wc_CryptoCb_TranslateErrorCode(ret);
2301}
2302
2303int wc_CryptoCb_SheGetCounter(wc_SHE* she, word32* counter, const void* ctx)
2304{
2305    int ret = WC_NO_ERR_TRACE(CRYPTOCB_UNAVAILABLE);
2306    CryptoCb* dev;
2307
2308    if (she == NULL || counter == NULL) {
2309        return BAD_FUNC_ARG;
2310    }
2311
2312    dev = wc_CryptoCb_FindDevice(she->devId, WC_ALGO_TYPE_SHE);
2313    if (dev && dev->cb) {
2314        wc_CryptoInfo cryptoInfo;
2315        XMEMSET(&cryptoInfo, 0, sizeof(cryptoInfo));
2316        cryptoInfo.algo_type                    = WC_ALGO_TYPE_SHE;
2317        cryptoInfo.she.she                      = she;
2318        cryptoInfo.she.type                     = WC_SHE_GET_COUNTER;
2319        cryptoInfo.she.ctx                      = ctx;
2320        cryptoInfo.she.op.getCounter.counter    = counter;
2321
2322        ret = dev->cb(dev->devId, &cryptoInfo, dev->ctx);
2323    }
2324
2325    return wc_CryptoCb_TranslateErrorCode(ret);
2326}
2327
2328int wc_CryptoCb_SheGenerateM1M2M3(wc_SHE* she,
2329                      const byte* uid, word32 uidSz,
2330                      byte authKeyId, const byte* authKey, word32 authKeySz,
2331                      byte targetKeyId, const byte* newKey, word32 newKeySz,
2332                      word32 counter, byte flags,
2333                      byte* m1, word32 m1Sz,
2334                      byte* m2, word32 m2Sz,
2335                      byte* m3, word32 m3Sz)
2336{
2337    int ret = WC_NO_ERR_TRACE(CRYPTOCB_UNAVAILABLE);
2338    CryptoCb* dev;
2339
2340    if (she == NULL) {
2341        return BAD_FUNC_ARG;
2342    }
2343
2344    dev = wc_CryptoCb_FindDevice(she->devId, WC_ALGO_TYPE_SHE);
2345    if (dev && dev->cb) {
2346        wc_CryptoInfo cryptoInfo;
2347        XMEMSET(&cryptoInfo, 0, sizeof(cryptoInfo));
2348        cryptoInfo.algo_type                          = WC_ALGO_TYPE_SHE;
2349        cryptoInfo.she.she                            = she;
2350        cryptoInfo.she.type                           = WC_SHE_GENERATE_M1M2M3;
2351        cryptoInfo.she.op.generateM1M2M3.uid          = uid;
2352        cryptoInfo.she.op.generateM1M2M3.uidSz        = uidSz;
2353        cryptoInfo.she.op.generateM1M2M3.authKeyId     = authKeyId;
2354        cryptoInfo.she.op.generateM1M2M3.authKey       = authKey;
2355        cryptoInfo.she.op.generateM1M2M3.authKeySz     = authKeySz;
2356        cryptoInfo.she.op.generateM1M2M3.targetKeyId   = targetKeyId;
2357        cryptoInfo.she.op.generateM1M2M3.newKey        = newKey;
2358        cryptoInfo.she.op.generateM1M2M3.newKeySz      = newKeySz;
2359        cryptoInfo.she.op.generateM1M2M3.counter       = counter;
2360        cryptoInfo.she.op.generateM1M2M3.flags         = flags;
2361        cryptoInfo.she.op.generateM1M2M3.m1            = m1;
2362        cryptoInfo.she.op.generateM1M2M3.m1Sz          = m1Sz;
2363        cryptoInfo.she.op.generateM1M2M3.m2            = m2;
2364        cryptoInfo.she.op.generateM1M2M3.m2Sz          = m2Sz;
2365        cryptoInfo.she.op.generateM1M2M3.m3            = m3;
2366        cryptoInfo.she.op.generateM1M2M3.m3Sz          = m3Sz;
2367
2368        ret = dev->cb(dev->devId, &cryptoInfo, dev->ctx);
2369    }
2370
2371    return wc_CryptoCb_TranslateErrorCode(ret);
2372}
2373
2374int wc_CryptoCb_SheGenerateM4M5(wc_SHE* she,
2375                      const byte* uid, word32 uidSz,
2376                      byte authKeyId, byte targetKeyId,
2377                      const byte* newKey, word32 newKeySz,
2378                      word32 counter,
2379                      byte* m4, word32 m4Sz,
2380                      byte* m5, word32 m5Sz)
2381{
2382    int ret = WC_NO_ERR_TRACE(CRYPTOCB_UNAVAILABLE);
2383    CryptoCb* dev;
2384
2385    if (she == NULL) {
2386        return BAD_FUNC_ARG;
2387    }
2388
2389    dev = wc_CryptoCb_FindDevice(she->devId, WC_ALGO_TYPE_SHE);
2390    if (dev && dev->cb) {
2391        wc_CryptoInfo cryptoInfo;
2392        XMEMSET(&cryptoInfo, 0, sizeof(cryptoInfo));
2393        cryptoInfo.algo_type                       = WC_ALGO_TYPE_SHE;
2394        cryptoInfo.she.she                         = she;
2395        cryptoInfo.she.type                        = WC_SHE_GENERATE_M4M5;
2396        cryptoInfo.she.op.generateM4M5.uid         = uid;
2397        cryptoInfo.she.op.generateM4M5.uidSz       = uidSz;
2398        cryptoInfo.she.op.generateM4M5.authKeyId    = authKeyId;
2399        cryptoInfo.she.op.generateM4M5.targetKeyId  = targetKeyId;
2400        cryptoInfo.she.op.generateM4M5.newKey       = newKey;
2401        cryptoInfo.she.op.generateM4M5.newKeySz     = newKeySz;
2402        cryptoInfo.she.op.generateM4M5.counter      = counter;
2403        cryptoInfo.she.op.generateM4M5.m4           = m4;
2404        cryptoInfo.she.op.generateM4M5.m4Sz         = m4Sz;
2405        cryptoInfo.she.op.generateM4M5.m5           = m5;
2406        cryptoInfo.she.op.generateM4M5.m5Sz         = m5Sz;
2407
2408        ret = dev->cb(dev->devId, &cryptoInfo, dev->ctx);
2409    }
2410
2411    return wc_CryptoCb_TranslateErrorCode(ret);
2412}
2413
2414int wc_CryptoCb_SheExportKey(wc_SHE* she,
2415                              byte* m1, word32 m1Sz,
2416                              byte* m2, word32 m2Sz,
2417                              byte* m3, word32 m3Sz,
2418                              byte* m4, word32 m4Sz,
2419                              byte* m5, word32 m5Sz,
2420                              const void* ctx)
2421{
2422    int ret = WC_NO_ERR_TRACE(CRYPTOCB_UNAVAILABLE);
2423    CryptoCb* dev;
2424
2425    if (she == NULL) {
2426        return BAD_FUNC_ARG;
2427    }
2428
2429    dev = wc_CryptoCb_FindDevice(she->devId, WC_ALGO_TYPE_SHE);
2430    if (dev && dev->cb) {
2431        wc_CryptoInfo cryptoInfo;
2432        XMEMSET(&cryptoInfo, 0, sizeof(cryptoInfo));
2433        cryptoInfo.algo_type                = WC_ALGO_TYPE_SHE;
2434        cryptoInfo.she.she                  = she;
2435        cryptoInfo.she.type                 = WC_SHE_EXPORT_KEY;
2436        cryptoInfo.she.ctx                  = ctx;
2437        cryptoInfo.she.op.exportKey.m1      = m1;
2438        cryptoInfo.she.op.exportKey.m1Sz    = m1Sz;
2439        cryptoInfo.she.op.exportKey.m2      = m2;
2440        cryptoInfo.she.op.exportKey.m2Sz    = m2Sz;
2441        cryptoInfo.she.op.exportKey.m3      = m3;
2442        cryptoInfo.she.op.exportKey.m3Sz    = m3Sz;
2443        cryptoInfo.she.op.exportKey.m4      = m4;
2444        cryptoInfo.she.op.exportKey.m4Sz    = m4Sz;
2445        cryptoInfo.she.op.exportKey.m5      = m5;
2446        cryptoInfo.she.op.exportKey.m5Sz    = m5Sz;
2447
2448        ret = dev->cb(dev->devId, &cryptoInfo, dev->ctx);
2449    }
2450
2451    return wc_CryptoCb_TranslateErrorCode(ret);
2452}
2453#endif /* WOLFSSL_SHE */
2454
2455/* returns the default dev id for the current build */
2456int wc_CryptoCb_DefaultDevID(void)
2457{
2458    int ret;
2459
2460/* Explicitly disable the "default devId" behavior. Ensures that any devId
2461 * will only be used if explicitly passed as an argument to crypto functions,
2462 * and never automatically selected. */
2463#ifdef WC_NO_DEFAULT_DEVID
2464    ret = INVALID_DEVID;
2465#else
2466    /* conditional macro selection based on build */
2467#ifdef WOLFSSL_CAAM_DEVID
2468    ret = WOLFSSL_CAAM_DEVID;
2469#elif defined(HAVE_ARIA)
2470    ret = WOLFSSL_ARIA_DEVID;
2471#elif defined(WC_USE_DEVID)
2472    ret = WC_USE_DEVID;
2473#else
2474    /* try first available */
2475    ret = wc_CryptoCb_GetDevIdAtIndex(0);
2476#endif
2477#endif /* WC_NO_DEFAULT_DEVID */
2478
2479    return ret;
2480}
2481
2482#if defined(HAVE_HKDF) && !defined(NO_HMAC)
2483int wc_CryptoCb_Hkdf(int hashType, const byte* inKey, word32 inKeySz,
2484                     const byte* salt, word32 saltSz, const byte* info,
2485                     word32 infoSz, byte* out, word32 outSz, int devId)
2486{
2487    int       ret = WC_NO_ERR_TRACE(CRYPTOCB_UNAVAILABLE);
2488    CryptoCb* dev;
2489
2490    /* Find registered callback device */
2491    dev = wc_CryptoCb_FindDevice(devId, WC_ALGO_TYPE_KDF);
2492
2493    if (dev && dev->cb) {
2494        wc_CryptoInfo cryptoInfo;
2495        XMEMSET(&cryptoInfo, 0, sizeof(cryptoInfo));
2496
2497        cryptoInfo.algo_type         = WC_ALGO_TYPE_KDF;
2498        cryptoInfo.kdf.type          = WC_KDF_TYPE_HKDF;
2499        cryptoInfo.kdf.hkdf.hashType = hashType;
2500        cryptoInfo.kdf.hkdf.inKey    = inKey;
2501        cryptoInfo.kdf.hkdf.inKeySz  = inKeySz;
2502        cryptoInfo.kdf.hkdf.salt     = salt;
2503        cryptoInfo.kdf.hkdf.saltSz   = saltSz;
2504        cryptoInfo.kdf.hkdf.info     = info;
2505        cryptoInfo.kdf.hkdf.infoSz   = infoSz;
2506        cryptoInfo.kdf.hkdf.out      = out;
2507        cryptoInfo.kdf.hkdf.outSz    = outSz;
2508
2509        ret = dev->cb(dev->devId, &cryptoInfo, dev->ctx);
2510    }
2511
2512    return wc_CryptoCb_TranslateErrorCode(ret);
2513}
2514#endif /* HAVE_HKDF && !NO_HMAC */
2515
2516#ifdef WOLF_CRYPTO_CB_COPY
2517/* General copy callback function for algorithm structures
2518 * devId: The device ID to use for the callback
2519 * algo: Algorithm type (enum wc_AlgoType) - WC_ALGO_TYPE_HASH,
2520 *       WC_ALGO_TYPE_CIPHER, etc
2521 * type: Specific type - for HASH: enum wc_HashType, for CIPHER:
2522 *       enum wc_CipherType
2523 * src: Pointer to source structure
2524 * dst: Pointer to destination structure
2525 * Returns: 0 on success, negative on error, CRYPTOCB_UNAVAILABLE if not
2526 *          handled
2527 */
2528int wc_CryptoCb_Copy(int devId, int algo, int type, void* src, void* dst)
2529{
2530    int ret = WC_NO_ERR_TRACE(CRYPTOCB_UNAVAILABLE);
2531    CryptoCb* dev;
2532
2533    /* Find registered callback device */
2534    dev = wc_CryptoCb_FindDevice(devId, WC_ALGO_TYPE_COPY);
2535    if (dev && dev->cb) {
2536        wc_CryptoInfo cryptoInfo;
2537        XMEMSET(&cryptoInfo, 0, sizeof(cryptoInfo));
2538        cryptoInfo.algo_type = WC_ALGO_TYPE_COPY;
2539        cryptoInfo.copy.algo = algo;
2540        cryptoInfo.copy.type = type;
2541        cryptoInfo.copy.src = src;
2542        cryptoInfo.copy.dst = dst;
2543
2544        ret = dev->cb(dev->devId, &cryptoInfo, dev->ctx);
2545    }
2546
2547    return wc_CryptoCb_TranslateErrorCode(ret);
2548}
2549#endif /* WOLF_CRYPTO_CB_COPY */
2550
2551#ifdef WOLF_CRYPTO_CB_FREE
2552/* General free callback function for algorithm structures
2553 * devId: The device ID to use for the callback
2554 * algo: Algorithm type (enum wc_AlgoType) - WC_ALGO_TYPE_HASH,
2555 *       WC_ALGO_TYPE_CIPHER, etc
2556 * type: Specific type - for HASH: enum wc_HashType, for CIPHER:
2557 *       enum wc_CipherType
2558 * subType: Specific subtype - for PQC: enum wc_PqcKemType,
2559 *       enum wc_PqcSignatureType
2560 * obj: Pointer to object structure to free
2561 * Returns: 0 on success, negative on error, CRYPTOCB_UNAVAILABLE if not
2562 *          handled
2563 */
2564int wc_CryptoCb_Free(int devId, int algo, int type, int subType, void* obj)
2565{
2566    int ret = WC_NO_ERR_TRACE(CRYPTOCB_UNAVAILABLE);
2567    CryptoCb* dev;
2568
2569    /* Find registered callback device */
2570    dev = wc_CryptoCb_FindDevice(devId, WC_ALGO_TYPE_FREE);
2571    if (dev && dev->cb) {
2572        wc_CryptoInfo cryptoInfo;
2573        XMEMSET(&cryptoInfo, 0, sizeof(cryptoInfo));
2574        cryptoInfo.algo_type = WC_ALGO_TYPE_FREE;
2575        cryptoInfo.free.algo = algo;
2576        cryptoInfo.free.type = type;
2577        cryptoInfo.free.subType = subType;
2578        cryptoInfo.free.obj = obj;
2579
2580        ret = dev->cb(dev->devId, &cryptoInfo, dev->ctx);
2581    }
2582
2583    return wc_CryptoCb_TranslateErrorCode(ret);
2584}
2585#endif /* WOLF_CRYPTO_CB_FREE */
2586
2587#ifdef WOLF_CRYPTO_CB_SETKEY
2588/* Generic SetKey callback for importing keys into hardware.
2589 * devId: Device ID for the registered callback
2590 * type:  enum wc_SetKeyType (AES, HMAC, RSA_PUB, RSA_PRIV, ECC_PUB, ECC_PRIV)
2591 * obj:   Context struct being operated on (Aes*, Hmac*, RsaKey*, ecc_key*)
2592 * key:   Key material: raw bytes (AES/HMAC) or temp struct to export from (RSA/ECC)
2593 * keySz: Key size in bytes (0 when key is a struct pointer)
2594 * aux:   Auxiliary data (IV, etc.) or NULL
2595 * auxSz: Aux data size, 0 if unused
2596 * flags: AES: direction (AES_ENCRYPTION/DECRYPTION). Others: 0
2597 * Returns: 0 on success, CRYPTOCB_UNAVAILABLE if not handled, negative on error
2598 */
2599int wc_CryptoCb_SetKey(int devId, int type, void* obj,
2600                         void* key, word32 keySz,
2601                         void* aux, word32 auxSz,
2602                         int flags)
2603{
2604    int ret = WC_NO_ERR_TRACE(CRYPTOCB_UNAVAILABLE);
2605    CryptoCb* dev;
2606
2607    /* Find registered callback device */
2608    dev = wc_CryptoCb_FindDevice(devId, WC_ALGO_TYPE_SETKEY);
2609    if (dev && dev->cb) {
2610        wc_CryptoInfo cryptoInfo;
2611        XMEMSET(&cryptoInfo, 0, sizeof(cryptoInfo));
2612        cryptoInfo.algo_type = WC_ALGO_TYPE_SETKEY;
2613        cryptoInfo.setkey.type = type;
2614        cryptoInfo.setkey.obj = obj;
2615        cryptoInfo.setkey.key = key;
2616        cryptoInfo.setkey.keySz = keySz;
2617        cryptoInfo.setkey.aux = aux;
2618        cryptoInfo.setkey.auxSz = auxSz;
2619        cryptoInfo.setkey.flags = flags;
2620
2621        ret = dev->cb(dev->devId, &cryptoInfo, dev->ctx);
2622    }
2623
2624    return wc_CryptoCb_TranslateErrorCode(ret);
2625}
2626#endif /* WOLF_CRYPTO_CB_SETKEY */
2627
2628#ifdef WOLF_CRYPTO_CB_EXPORT_KEY
2629/* Generic ExportKey callback for exporting key material from hardware.
2630 * devId: Device ID for the registered callback
2631 * type:  enum wc_PkType (WC_PK_TYPE_RSA, WC_PK_TYPE_ECDSA, etc.)
2632 * obj:   Hardware key object (has devCtx, id[], etc.)
2633 * out:   Software key object to fill (same type as obj, caller-allocated)
2634 * The callback exports from hardware into the software key. The caller then
2635 * uses normal software export functions on 'out' and frees it.
2636 * Returns: 0 on success, CRYPTOCB_UNAVAILABLE if not handled, negative on error
2637 */
2638int wc_CryptoCb_ExportKey(int devId, int type, const void* obj, void* out)
2639{
2640    int ret = WC_NO_ERR_TRACE(CRYPTOCB_UNAVAILABLE);
2641    CryptoCb* dev;
2642
2643    dev = wc_CryptoCb_FindDevice(devId, WC_ALGO_TYPE_EXPORT_KEY);
2644    if (dev && dev->cb) {
2645        wc_CryptoInfo cryptoInfo;
2646        XMEMSET(&cryptoInfo, 0, sizeof(cryptoInfo));
2647        cryptoInfo.algo_type = WC_ALGO_TYPE_EXPORT_KEY;
2648        cryptoInfo.export_key.type = type;
2649        cryptoInfo.export_key.obj = obj;
2650        cryptoInfo.export_key.out = out;
2651
2652        ret = dev->cb(dev->devId, &cryptoInfo, dev->ctx);
2653    }
2654
2655    return wc_CryptoCb_TranslateErrorCode(ret);
2656}
2657#endif /* WOLF_CRYPTO_CB_EXPORT_KEY */
2658
2659#if defined(HAVE_CMAC_KDF)
2660/* Crypto callback for NIST SP 800 56C two-step CMAC KDF. See software
2661 * implementation in wc_KDA_KDF_twostep_cmac for more comments.
2662 * */
2663int wc_CryptoCb_Kdf_TwostepCmac(const byte * salt, word32 saltSz,
2664                                const byte* z, word32 zSz,
2665                                const byte* fixedInfo, word32 fixedInfoSz,
2666                                byte* output, word32 outputSz, int devId)
2667{
2668    int       ret = WC_NO_ERR_TRACE(CRYPTOCB_UNAVAILABLE);
2669    CryptoCb* dev;
2670
2671    /* Find registered callback device */
2672    dev = wc_CryptoCb_FindDevice(devId, WC_ALGO_TYPE_KDF);
2673
2674    if (dev && dev->cb) {
2675        wc_CryptoInfo cryptoInfo;
2676        XMEMSET(&cryptoInfo, 0, sizeof(cryptoInfo));
2677
2678        cryptoInfo.algo_type                    = WC_ALGO_TYPE_KDF;
2679        cryptoInfo.kdf.type                     = WC_KDF_TYPE_TWOSTEP_CMAC;
2680        cryptoInfo.kdf.twostep_cmac.salt        = salt;
2681        cryptoInfo.kdf.twostep_cmac.saltSz      = saltSz;
2682        cryptoInfo.kdf.twostep_cmac.z           = z;
2683        cryptoInfo.kdf.twostep_cmac.zSz         = zSz;
2684        cryptoInfo.kdf.twostep_cmac.fixedInfo   = fixedInfo;
2685        cryptoInfo.kdf.twostep_cmac.fixedInfoSz = fixedInfoSz;
2686        cryptoInfo.kdf.twostep_cmac.out         = output;
2687        cryptoInfo.kdf.twostep_cmac.outSz       = outputSz;
2688
2689        ret = dev->cb(dev->devId, &cryptoInfo, dev->ctx);
2690    }
2691
2692    return wc_CryptoCb_TranslateErrorCode(ret);
2693}
2694#endif /* HAVE_CMAC_KDF */
2695
2696#endif /* WOLF_CRYPTO_CB */