luna - wolfssl/wolfcrypt/src/port/cypress/psoc6

   1/* psoc6_crypto.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#ifdef HAVE_CONFIG_H
  23#include <config.h>
  24#endif
  25
  26#include <wolfssl/wolfcrypt/settings.h>
  27#ifdef NO_INLINE
  28#include <wolfssl/wolfcrypt/misc.h>
  29#else
  30#define WOLFSSL_MISC_INCLUDED
  31#include <wolfcrypt/src/misc.c>
  32#endif
  33
  34#if defined(WOLFSSL_PSOC6_CRYPTO)
  35
  36#include <stdint.h>
  37#include <string.h>
  38
  39#include <wolfssl/wolfcrypt/error-crypt.h>
  40#include <wolfssl/wolfcrypt/logging.h>
  41#include <wolfssl/wolfcrypt/port/cypress/psoc6_crypto.h>
  42#include <wolfssl/wolfcrypt/random.h>
  43
  44#include "cy_crypto_core_hw_v2.h"
  45#include "cy_crypto_core_mem.h"
  46
  47#ifdef HAVE_ECC
  48#include <wolfssl/wolfcrypt/ecc.h>
  49#endif /* HAVE_ECC */
  50
  51#ifndef NO_AES
  52#include <wolfssl/wolfcrypt/aes.h>
  53
  54#include "cy_crypto_common.h"
  55#include "cy_crypto_core_aes.h"
  56#include "cy_crypto_core_aes_v2.h"
  57#endif /* NO_AES */
  58
  59#ifndef NO_SHA256
  60#include "wolfssl/wolfcrypt/sha256.h"
  61#endif
  62
  63#ifdef WOLFSSL_SHA3
  64#include "wolfssl/wolfcrypt/sha3.h"
  65#endif
  66
  67#if defined(WOLFSSL_SHA512) || defined(WOLFSSL_SHA384)
  68#include "wolfssl/wolfcrypt/sha512.h"
  69#endif
  70
  71#if defined(PSOC6_HASH_SHA3)
  72
  73/* Number of bits in a byte */
  74#define BITS_IN_BYTE 8U
  75
  76/* Number of bytes of SHA3 to store in 1st partition of register buffer
  77 * (reg_buff[1023:0]) */
  78#define PSOC6_CRYPTO_SHA3_RB_LOWER 128U
  79
  80/* Number of bytes of SHA3 to store in 2nd partition of register buffer
  81 * (reg_buff[2047:1024]) */
  82#define PSOC6_CRYPTO_SHA3_RB_UPPER 72U
  83
  84#endif /* PSOC6_HASH_SHA3 */
  85
  86static CRYPTO_Type* crypto_base = PSOC6_CRYPTO_BASE;
  87
  88/* Hook for device specific initialization */
  89int psoc6_crypto_port_init(void)
  90{
  91    Cy_Crypto_Core_Enable(crypto_base);
  92    return 0;
  93}
  94
  95/* Initialize the PSoC6 hardware crypto engine for SHA-1, SHA-2, or SHA-512
  96 * operation.
  97 *
  98 * sha       Pointer to hash context structure (wc_Sha, wc_Sha224, wc_Sha256,
  99 * wc_Sha384, wc_Sha512). hash_mode Hash mode selector (WC_PSOC6_SHA1,
 100 * WC_PSOC6_SHA224, WC_PSOC6_SHA256, etc.). init_hash If 1, initializes the hash
 101 * state; if 0, does not initialize. returns   0 on success, BAD_FUNC_ARG or
 102 * hardware error code on failure.
 103 */
 104int wc_Psoc6_Sha1_Sha2_Init(void* sha, wc_psoc6_hash_sha1_sha2_t hash_mode,
 105                            int init_hash)
 106{
 107    cy_en_crypto_status_t res;
 108    if (sha == NULL) {
 109        return BAD_FUNC_ARG;
 110    }
 111
 112    /* Enable CRYPTO block if not enabled */
 113    if (!Cy_Crypto_Core_IsEnabled(crypto_base)) {
 114        Cy_Crypto_Core_Enable(crypto_base);
 115    }
 116
 117    switch (hash_mode) {
 118#if !defined(NO_SHA) && defined(PSOC6_HASH_SHA1)
 119        case WC_PSOC6_SHA1:
 120            /* Initialize the PSoC6 hash state and configure the SHA mode */
 121            res = Cy_Crypto_Core_Sha_Init(
 122                crypto_base, &((wc_Sha*)sha)->hash_state, CY_CRYPTO_MODE_SHA1,
 123                &((wc_Sha*)sha)->sha_buffers);
 124            /* Initialize the hash state to the SHA1 initial values if requested
 125             * (init_hash set to 1) */
 126            if ((res == CY_CRYPTO_SUCCESS) && (init_hash == 1))
 127                res = Cy_Crypto_Core_Sha_Start(crypto_base,
 128                                               &((wc_Sha*)sha)->hash_state);
 129            break;
 130#endif
 131#if defined(PSOC6_HASH_SHA2)
 132
 133#if !defined(NO_SHA256)
 134#if defined(WOLFSSL_SHA224)
 135        case WC_PSOC6_SHA224:
 136            res = Cy_Crypto_Core_Sha_Init(
 137                crypto_base, &((wc_Sha224*)sha)->hash_state,
 138                CY_CRYPTO_MODE_SHA224, &((wc_Sha224*)sha)->sha_buffers);
 139            if ((res == CY_CRYPTO_SUCCESS) && (init_hash == 1))
 140                res = Cy_Crypto_Core_Sha_Start(crypto_base,
 141                                               &((wc_Sha224*)sha)->hash_state);
 142            break;
 143#endif /* WOLFSSL_SHA224 */
 144        case WC_PSOC6_SHA256:
 145            res = Cy_Crypto_Core_Sha_Init(
 146                crypto_base, &((wc_Sha256*)sha)->hash_state,
 147                CY_CRYPTO_MODE_SHA256, &((wc_Sha256*)sha)->sha_buffers);
 148            if ((res == CY_CRYPTO_SUCCESS) && (init_hash == 1))
 149                res = Cy_Crypto_Core_Sha_Start(crypto_base,
 150                                               &((wc_Sha256*)sha)->hash_state);
 151            break;
 152#endif /* !NO_SHA256 */
 153
 154#if defined(WOLFSSL_SHA384)
 155        case WC_PSOC6_SHA384:
 156            res = Cy_Crypto_Core_Sha_Init(
 157                crypto_base, &((wc_Sha384*)sha)->hash_state,
 158                CY_CRYPTO_MODE_SHA384, &((wc_Sha384*)sha)->sha_buffers);
 159            if ((res == CY_CRYPTO_SUCCESS) && (init_hash == 1))
 160                res = Cy_Crypto_Core_Sha_Start(crypto_base,
 161                                               &((wc_Sha384*)sha)->hash_state);
 162            break;
 163#endif /* WOLFSSL_SHA384 */
 164
 165#if defined(WOLFSSL_SHA512)
 166        case WC_PSOC6_SHA512:
 167            res = Cy_Crypto_Core_Sha_Init(
 168                crypto_base, &((wc_Sha512*)sha)->hash_state,
 169                CY_CRYPTO_MODE_SHA512, &((wc_Sha512*)sha)->sha_buffers);
 170            if ((res == CY_CRYPTO_SUCCESS) && (init_hash == 1))
 171                res = Cy_Crypto_Core_Sha_Start(crypto_base,
 172                                               &((wc_Sha512*)sha)->hash_state);
 173            break;
 174#if !defined(WOLFSSL_NOSHA512_224)
 175
 176        case WC_PSOC6_SHA512_224:
 177            res = Cy_Crypto_Core_Sha_Init(
 178                crypto_base, &((wc_Sha512*)sha)->hash_state,
 179                CY_CRYPTO_MODE_SHA512_224, &((wc_Sha512*)sha)->sha_buffers);
 180            if ((res == CY_CRYPTO_SUCCESS) && (init_hash == 1))
 181                res = Cy_Crypto_Core_Sha_Start(crypto_base,
 182                                               &((wc_Sha512*)sha)->hash_state);
 183            break;
 184#endif /* WOLFSSL_SHA512_224 */
 185
 186#if !defined(WOLFSSL_NOSHA512_256)
 187        case WC_PSOC6_SHA512_256:
 188            res = Cy_Crypto_Core_Sha_Init(
 189                crypto_base, &((wc_Sha512*)sha)->hash_state,
 190                CY_CRYPTO_MODE_SHA512_256, &((wc_Sha512*)sha)->sha_buffers);
 191            if ((res == CY_CRYPTO_SUCCESS) && (init_hash == 1))
 192                res = Cy_Crypto_Core_Sha_Start(crypto_base,
 193                                               &((wc_Sha512*)sha)->hash_state);
 194            break;
 195#endif /* WOLFSSL_SHA512_256 */
 196
 197#endif /* WOLFSSL_SHA512 */
 198
 199#endif /* PSOC6_HASH_SHA2 */
 200        default:
 201            return BAD_FUNC_ARG;
 202    }
 203
 204    return res;
 205}
 206
 207/* Free resources and clear the register buffer for the PSoC6 hardware crypto
 208 * engine.
 209 *
 210 * No parameters.
 211 * returns   0 on success, error code if mutex lock fails.
 212 */
 213int wc_Psoc6_Sha_Free(void)
 214{
 215    int ret;
 216
 217    /* Lock the mutex to perform crypto operations */
 218    ret = wolfSSL_CryptHwMutexLock();
 219    if (ret == 0) {
 220        /* Clear the register buffer */
 221        Cy_Crypto_Core_V2_RBClear(crypto_base);
 222
 223        /* Wait until the instruction is complete */
 224        Cy_Crypto_Core_V2_Sync(crypto_base);
 225
 226        /* Release the lock */
 227        wolfSSL_CryptHwMutexUnLock();
 228    }
 229
 230    return ret;
 231}
 232
 233/* SHA */
 234#if !defined(NO_SHA) && defined(PSOC6_HASH_SHA1)
 235
 236int wc_InitSha_ex(wc_Sha* sha, void* heap, int devid)
 237{
 238    int ret;
 239    if (sha == NULL)
 240        return BAD_FUNC_ARG;
 241
 242    (void)heap;
 243    XMEMSET(sha, 0, sizeof(wc_Sha));
 244    /* Lock the mutex to perform crypto operations */
 245    ret = wolfSSL_CryptHwMutexLock();
 246    if (ret == 0) {
 247        /* Initialize the PSoC6 hash buffers for SHA1 */
 248        ret = wc_Psoc6_Sha1_Sha2_Init(sha, WC_PSOC6_SHA1, 1);
 249        /* Release the lock */
 250        wolfSSL_CryptHwMutexUnLock();
 251    }
 252    return ret;
 253}
 254
 255int wc_ShaUpdate(wc_Sha* sha, const byte* in, word32 sz)
 256{
 257    int ret;
 258    if (sha == NULL || (in == NULL && sz > 0)) {
 259        return BAD_FUNC_ARG;
 260    }
 261
 262    if (in == NULL && sz == 0) {
 263        /* valid, but do nothing */
 264        return 0;
 265    }
 266
 267    /* Lock the mutex to perform crypto operations */
 268    ret = wolfSSL_CryptHwMutexLock();
 269    if (ret == 0) {
 270        /* Perform the SHA calculation input data */
 271        ret = Cy_Crypto_Core_Sha_Update(crypto_base, &sha->hash_state, in, sz);
 272        /* Release the lock */
 273        wolfSSL_CryptHwMutexUnLock();
 274    }
 275    return ret;
 276}
 277
 278int wc_ShaFinal(wc_Sha* sha, byte* hash)
 279{
 280    int ret;
 281
 282    if (sha == NULL || hash == NULL)
 283        return BAD_FUNC_ARG;
 284
 285    /* Lock the mutex to perform crypto operations */
 286    ret = wolfSSL_CryptHwMutexLock();
 287    if (ret == 0) {
 288        /* Complete the SHA calculation */
 289        ret =
 290            (int)Cy_Crypto_Core_Sha_Finish(crypto_base, &sha->hash_state, hash);
 291        /* Release the lock */
 292        wolfSSL_CryptHwMutexUnLock();
 293    }
 294
 295    if (ret != 0)
 296        return ret;
 297
 298    /* Reset state */
 299    return wc_InitSha(sha);
 300}
 301
 302#endif /* !NO_SHA && PSOC6_HASH_SHA1 */
 303
 304/* SHA2 */
 305#if defined(PSOC6_HASH_SHA2)
 306
 307/* Sha-256 */
 308#if !defined(NO_SHA256)
 309
 310int wc_InitSha256_ex(wc_Sha256* sha, void* heap, int devid)
 311{
 312    int ret;
 313    if (sha == NULL)
 314        return BAD_FUNC_ARG;
 315
 316    (void)heap;
 317    (void)devid;
 318    XMEMSET(sha, 0, sizeof(wc_Sha256));
 319    /* Lock the mutex to perform crypto operations */
 320    ret = wolfSSL_CryptHwMutexLock();
 321    if (ret == 0) {
 322        /* Initialize the PSoC6 hash buffers for SHA256 */
 323        ret = wc_Psoc6_Sha1_Sha2_Init(sha, WC_PSOC6_SHA256, 1);
 324        /* Release the lock */
 325        wolfSSL_CryptHwMutexUnLock();
 326    }
 327    return ret;
 328}
 329
 330int wc_Sha256Update(wc_Sha256* sha, const byte* in, word32 sz)
 331{
 332    int ret;
 333    if (sha == NULL || (in == NULL && sz > 0)) {
 334        return BAD_FUNC_ARG;
 335    }
 336
 337    if (in == NULL && sz == 0) {
 338        /* valid, but do nothing */
 339        return 0;
 340    }
 341
 342    /* Lock the mutex to perform crypto operations */
 343    ret = wolfSSL_CryptHwMutexLock();
 344    if (ret == 0) {
 345        /* Perform the SHA calculation input data */
 346        ret = Cy_Crypto_Core_Sha_Update(crypto_base, &sha->hash_state, in, sz);
 347        /* Release the lock */
 348        wolfSSL_CryptHwMutexUnLock();
 349    }
 350
 351    return ret;
 352}
 353
 354int wc_Sha256Final(wc_Sha256* sha, byte* hash)
 355{
 356    int ret;
 357    if (sha == NULL || hash == NULL)
 358        return BAD_FUNC_ARG;
 359
 360    /* Lock the mutex to perform crypto operations */
 361    ret = wolfSSL_CryptHwMutexLock();
 362    if (ret == 0) {
 363        /* Complete the SHA calculation */
 364        ret =
 365            (int)Cy_Crypto_Core_Sha_Finish(crypto_base, &sha->hash_state, hash);
 366        /* Release the lock */
 367        wolfSSL_CryptHwMutexUnLock();
 368    }
 369
 370    if (ret != 0)
 371        return ret;
 372
 373    /* Reset state */
 374    return wc_InitSha256(sha);
 375}
 376
 377/* Sha-224 */
 378#if defined(WOLFSSL_SHA224)
 379
 380int wc_InitSha224_ex(wc_Sha224* sha, void* heap, int devid)
 381{
 382    int ret;
 383    if (sha == NULL)
 384        return BAD_FUNC_ARG;
 385
 386    (void)heap;
 387    (void)devid;
 388    XMEMSET(sha, 0, sizeof(wc_Sha224));
 389    /* Lock the mutex to perform crypto operations */
 390    ret = wolfSSL_CryptHwMutexLock();
 391    if (ret == 0) {
 392        /* Initialize the PSoC6 hash buffers for SHA224 */
 393        ret = wc_Psoc6_Sha1_Sha2_Init(sha, WC_PSOC6_SHA224, 1);
 394        /* Release the lock */
 395        wolfSSL_CryptHwMutexUnLock();
 396    }
 397    return ret;
 398}
 399
 400int wc_Sha224Update(wc_Sha224* sha, const byte* in, word32 sz)
 401{
 402    int ret;
 403    if (sha == NULL || (in == NULL && sz > 0)) {
 404        return BAD_FUNC_ARG;
 405    }
 406
 407    if (in == NULL && sz == 0) {
 408        /* valid, but do nothing */
 409        return 0;
 410    }
 411
 412    /* Lock the mutex to perform crypto operations */
 413    ret = wolfSSL_CryptHwMutexLock();
 414    if (ret == 0) {
 415        /* Perform the SHA calculation input data */
 416        ret = Cy_Crypto_Core_Sha_Update(crypto_base, &sha->hash_state, in, sz);
 417        /* Release the lock */
 418        wolfSSL_CryptHwMutexUnLock();
 419    }
 420
 421    return ret;
 422}
 423
 424int wc_Sha224Final(wc_Sha224* sha, byte* hash)
 425{
 426    int ret;
 427    if (sha == NULL || hash == NULL)
 428        return BAD_FUNC_ARG;
 429
 430    /* Lock the mutex to perform crypto operations */
 431    ret = wolfSSL_CryptHwMutexLock();
 432    if (ret == 0) {
 433        /* Complete the SHA calculation */
 434        ret =
 435            (int)Cy_Crypto_Core_Sha_Finish(crypto_base, &sha->hash_state, hash);
 436        /* Release the lock */
 437        wolfSSL_CryptHwMutexUnLock();
 438    }
 439
 440    if (ret != 0)
 441        return ret;
 442
 443    /* Reset state */
 444    return wc_InitSha224(sha);
 445}
 446
 447#endif /* WOLFSSL_SHA224 */
 448#endif /* !NO_SHA256 */
 449
 450/* SHA-384 */
 451#if defined(WOLFSSL_SHA384)
 452
 453int wc_InitSha384_ex(wc_Sha384* sha, void* heap, int devid)
 454{
 455    int ret;
 456    if (sha == NULL)
 457        return BAD_FUNC_ARG;
 458
 459    (void)heap;
 460    (void)devid;
 461    XMEMSET(sha, 0, sizeof(wc_Sha384));
 462    /* Lock the mutex to perform crypto operations */
 463    ret = wolfSSL_CryptHwMutexLock();
 464    if (ret == 0) {
 465        /* Initialize the PSoC6 hash buffers for SHA384 */
 466        ret = wc_Psoc6_Sha1_Sha2_Init(sha, WC_PSOC6_SHA384, 1);
 467        /* Release the lock */
 468        wolfSSL_CryptHwMutexUnLock();
 469    }
 470    return ret;
 471}
 472
 473int wc_Sha384Update(wc_Sha384* sha, const byte* in, word32 sz)
 474{
 475    int ret;
 476    if (sha == NULL || (in == NULL && sz > 0)) {
 477        return BAD_FUNC_ARG;
 478    }
 479
 480    if (in == NULL && sz == 0) {
 481        /* valid, but do nothing */
 482        return 0;
 483    }
 484
 485    /* Lock the mutex to perform crypto operations */
 486    ret = wolfSSL_CryptHwMutexLock();
 487    if (ret == 0) {
 488        /* Perform the SHA calculation input data */
 489        ret = Cy_Crypto_Core_Sha_Update(crypto_base, &sha->hash_state, in, sz);
 490        /* Release the lock */
 491        wolfSSL_CryptHwMutexUnLock();
 492    }
 493    return ret;
 494}
 495
 496int wc_Sha384Final(wc_Sha384* sha, byte* hash)
 497{
 498    int ret;
 499
 500    if (sha == NULL || hash == NULL)
 501        return BAD_FUNC_ARG;
 502
 503    /* Lock the mutex to perform crypto operations */
 504    ret = wolfSSL_CryptHwMutexLock();
 505    if (ret == 0) {
 506        /* Complete the SHA calculation */
 507        ret =
 508            (int)Cy_Crypto_Core_Sha_Finish(crypto_base, &sha->hash_state, hash);
 509        /* Release the lock */
 510        wolfSSL_CryptHwMutexUnLock();
 511    }
 512
 513    if (ret != 0)
 514        return ret;
 515
 516    /* Reset state */
 517    return wc_InitSha384(sha);
 518}
 519
 520#endif /* WOLFSSL_SHA384 */
 521
 522/* Sha-512 */
 523#if defined(WOLFSSL_SHA512)
 524
 525int wc_InitSha512_ex(wc_Sha512* sha, void* heap, int devid)
 526{
 527    int ret;
 528    (void)heap;
 529    (void)devid;
 530    XMEMSET(sha, 0, sizeof(wc_Sha512));
 531    /* Lock the mutex to perform crypto operations */
 532    ret = wolfSSL_CryptHwMutexLock();
 533    if (ret == 0) {
 534        /* Initialize the PSoC6 hash buffers for SHA512 */
 535        ret = wc_Psoc6_Sha1_Sha2_Init(sha, WC_PSOC6_SHA512, 1);
 536        /* Release the lock */
 537        wolfSSL_CryptHwMutexUnLock();
 538    }
 539#if defined(WOLFSSL_SHA512_HASHTYPE)
 540    if (ret == 0) {
 541        sha->hashType = WC_HASH_TYPE_SHA512;
 542    }
 543#endif
 544    return ret;
 545}
 546
 547int wc_Sha512Update(wc_Sha512* sha, const byte* in, word32 sz)
 548{
 549    int ret;
 550    if (sha == NULL || (in == NULL && sz > 0)) {
 551        return BAD_FUNC_ARG;
 552    }
 553
 554    if (in == NULL && sz == 0) {
 555        /* valid, but do nothing */
 556        return 0;
 557    }
 558
 559    /* Lock the mutex to perform crypto operations */
 560    ret = wolfSSL_CryptHwMutexLock();
 561    if (ret == 0) {
 562        /* Perform the SHA calculation input data */
 563        ret = Cy_Crypto_Core_Sha_Update(crypto_base, &sha->hash_state, in, sz);
 564        /* Release the lock */
 565        wolfSSL_CryptHwMutexUnLock();
 566    }
 567    return ret;
 568}
 569
 570int wc_Sha512Final(wc_Sha512* sha, byte* hash)
 571{
 572    int ret;
 573    if (sha == NULL || hash == NULL)
 574        return BAD_FUNC_ARG;
 575
 576    /* Lock the mutex to perform crypto operations */
 577    ret = wolfSSL_CryptHwMutexLock();
 578    if (ret == 0) {
 579        /* Complete the SHA calculation */
 580        ret =
 581            (int)Cy_Crypto_Core_Sha_Finish(crypto_base, &sha->hash_state, hash);
 582        /* Release the lock */
 583        wolfSSL_CryptHwMutexUnLock();
 584    }
 585
 586    if (ret != 0)
 587        return ret;
 588
 589    /* Reset state */
 590    return wc_InitSha512(sha);
 591}
 592
 593/* SHA-512_224 */
 594
 595#ifndef WOLFSSL_NOSHA512_224
 596
 597int wc_InitSha512_224_ex(wc_Sha512* sha, void* heap, int devid)
 598{
 599    int ret;
 600    if (sha == NULL)
 601        return BAD_FUNC_ARG;
 602
 603    (void)heap;
 604    (void)devid;
 605    XMEMSET(sha, 0, sizeof(wc_Sha512));
 606    /* Lock the mutex to perform crypto operations */
 607    ret = wolfSSL_CryptHwMutexLock();
 608    if (ret == 0) {
 609        /* Initialize the PSoC6 hash buffers for SHA512_224 */
 610        ret = wc_Psoc6_Sha1_Sha2_Init(sha, WC_PSOC6_SHA512_224, 1);
 611        /* Release the lock */
 612        wolfSSL_CryptHwMutexUnLock();
 613    }
 614#if defined(WOLFSSL_SHA512_HASHTYPE)
 615    if (ret == 0) {
 616        sha->hashType = WC_HASH_TYPE_SHA512_224;
 617    }
 618#endif
 619    return ret;
 620}
 621
 622int wc_Sha512_224Update(wc_Sha512* sha, const byte* in, word32 sz)
 623{
 624    return wc_Sha512Update(sha, in, sz);
 625}
 626
 627int wc_Sha512_224Final(wc_Sha512* sha, byte* hash)
 628{
 629    int ret;
 630
 631    if (sha == NULL || hash == NULL)
 632        return BAD_FUNC_ARG;
 633
 634    /* Lock the mutex to perform crypto operations */
 635    ret = wolfSSL_CryptHwMutexLock();
 636    if (ret == 0) {
 637        /* Complete the SHA calculation */
 638        ret =
 639            (int)Cy_Crypto_Core_Sha_Finish(crypto_base, &sha->hash_state, hash);
 640        /* Release the lock */
 641        wolfSSL_CryptHwMutexUnLock();
 642    }
 643
 644    /* Reset state */
 645    return wc_InitSha512_224(sha);
 646}
 647
 648#endif /* !WOLFSSL_NOSHA512_224 */
 649
 650/* SHA-512_256 */
 651
 652#ifndef WOLFSSL_NOSHA512_256
 653
 654int wc_InitSha512_256_ex(wc_Sha512* sha, void* heap, int devid)
 655{
 656    int ret;
 657    if (sha == NULL)
 658        return BAD_FUNC_ARG;
 659
 660    (void)heap;
 661    (void)devid;
 662    XMEMSET(sha, 0, sizeof(wc_Sha512));
 663    /* Lock the mutex to perform crypto operations */
 664    ret = wolfSSL_CryptHwMutexLock();
 665    if (ret == 0) {
 666        /* Initialize the PSoC6 hash buffers for SHA512_256 */
 667        ret = wc_Psoc6_Sha1_Sha2_Init(sha, WC_PSOC6_SHA512_256, 1);
 668        /* Release the lock */
 669        wolfSSL_CryptHwMutexUnLock();
 670    }
 671#if defined(WOLFSSL_SHA512_HASHTYPE)
 672    if (ret == 0) {
 673        sha->hashType = WC_HASH_TYPE_SHA512_256;
 674    }
 675#endif
 676    return ret;
 677}
 678
 679int wc_Sha512_256Update(wc_Sha512* sha, const byte* in, word32 sz)
 680{
 681    return wc_Sha512Update(sha, in, sz);
 682}
 683
 684int wc_Sha512_256Final(wc_Sha512* sha, byte* hash)
 685{
 686    int ret;
 687
 688    if (sha == NULL || hash == NULL)
 689        return BAD_FUNC_ARG;
 690
 691    /* Lock the mutex to perform crypto operations */
 692    ret = wolfSSL_CryptHwMutexLock();
 693    if (ret == 0) {
 694        /* Complete the SHA calculation */
 695        ret =
 696            (int)Cy_Crypto_Core_Sha_Finish(crypto_base, &sha->hash_state, hash);
 697        /* Release the lock */
 698        wolfSSL_CryptHwMutexUnLock();
 699    }
 700    if (ret != 0)
 701        return ret;
 702
 703    /* Reset state */
 704    return wc_InitSha512_256(sha);
 705}
 706
 707#endif /* !WOLFSSL_NOSHA512_256 */
 708#endif /* WOLFSSL_SHA512 */
 709#endif /* PSOC6_HASH_SHA2 */
 710
 711/* SHA3 */
 712#if defined(WOLFSSL_SHA3) && defined(PSOC6_HASH_SHA3)
 713
 714/* Initialize the state for a SHA-3 hash operation using the PSoC6 hardware
 715 * crypto engine.
 716 *
 717 * sha3   wc_Sha3 object holding state.
 718 * returns 0 on success.
 719 */
 720int wc_Psoc6_Sha3_Init(void* sha3)
 721{
 722    wc_Sha3* sha3_ctx = (wc_Sha3*)sha3;
 723
 724    /* Enable CRYPTO block if not enabled */
 725    if (!Cy_Crypto_Core_IsEnabled(crypto_base)) {
 726        Cy_Crypto_Core_Enable(crypto_base);
 727    }
 728
 729    /* Clear the data in sha3 structure */
 730    Cy_Crypto_Core_MemSet(crypto_base, sha3, 0, sizeof(wc_Sha3));
 731
 732    /* Initialise the hash pointer in hash_state structure */
 733    sha3_ctx->hash_state.hash =
 734        (uint8_t*)((cy_stc_crypto_v2_sha3_buffers_t*)&sha3_ctx->sha_buffers)
 735            ->hash;
 736
 737    /* Set the SHA mode to SHA3 */
 738    sha3_ctx->hash_state.modeHw = (uint32_t)CY_CRYPTO_V2_SHA3_OPC;
 739
 740    /* Initialize the hashsize to 0 */
 741    sha3_ctx->hash_state.hashSize = 0;
 742
 743    /* Set the init_done flag to false. It will be updated in */
 744    /* Sha3Update once the mode and blockSize are updated */
 745    sha3_ctx->init_done = false;
 746
 747    return 0;
 748}
 749
 750/* Update the SHA-3 hash state with input data using the PSoC6 hardware crypto
 751 * engine.
 752 *
 753 * sha3   wc_Sha3 object holding state.
 754 * data   Input data buffer.
 755 * len    Length of input data.
 756 * p      SHA-3 parameter (block size/count).
 757 * returns 0 on success, BAD_FUNC_ARG or hardware error code on failure.
 758 */
 759int wc_Psoc6_Sha3_Update(void* sha3, const byte* data, word32 len, byte p)
 760{
 761    wc_Sha3* sha3_ctx = (wc_Sha3*)sha3;
 762
 763    /* If the initialization is not done, set it up */
 764    if (!sha3_ctx->init_done) {
 765        /* Set the SHA mode, blockSize and digestSize (for applicable ones) */
 766        switch (p) {
 767            case WC_SHA3_128_COUNT:
 768                /* For SHAKE-128 Cy_Crypto_Core_Sha_Update requires mode to be
 769                 * valid (SHA3_224 fits) */
 770                sha3_ctx->hash_state.mode = CY_CRYPTO_MODE_SHA3_224;
 771                sha3_ctx->hash_state.blockSize =
 772                    WC_SHA3_128_COUNT * BITS_IN_BYTE;
 773                break;
 774            case WC_SHA3_224_COUNT:
 775                sha3_ctx->hash_state.mode       = CY_CRYPTO_MODE_SHA3_224;
 776                sha3_ctx->hash_state.blockSize  = CY_CRYPTO_SHA3_224_BLOCK_SIZE;
 777                sha3_ctx->hash_state.digestSize = CY_CRYPTO_SHA224_DIGEST_SIZE;
 778                break;
 779            case WC_SHA3_256_COUNT:
 780                sha3_ctx->hash_state.mode       = CY_CRYPTO_MODE_SHA3_256;
 781                sha3_ctx->hash_state.blockSize  = CY_CRYPTO_SHA3_256_BLOCK_SIZE;
 782                sha3_ctx->hash_state.digestSize = CY_CRYPTO_SHA256_DIGEST_SIZE;
 783                break;
 784            case WC_SHA3_384_COUNT:
 785                sha3_ctx->hash_state.mode       = CY_CRYPTO_MODE_SHA3_384;
 786                sha3_ctx->hash_state.blockSize  = CY_CRYPTO_SHA3_384_BLOCK_SIZE;
 787                sha3_ctx->hash_state.digestSize = CY_CRYPTO_SHA384_DIGEST_SIZE;
 788                break;
 789            case WC_SHA3_512_COUNT:
 790                sha3_ctx->hash_state.mode       = CY_CRYPTO_MODE_SHA3_512;
 791                sha3_ctx->hash_state.blockSize  = CY_CRYPTO_SHA3_512_BLOCK_SIZE;
 792                sha3_ctx->hash_state.digestSize = CY_CRYPTO_SHA512_DIGEST_SIZE;
 793                break;
 794            default:
 795                return BAD_FUNC_ARG;
 796        }
 797
 798        /* Update the init_done flag */
 799        sha3_ctx->init_done = true;
 800    }
 801
 802    /* Perform the SHA calculation input data */
 803    return Cy_Crypto_Core_Sha_Update(crypto_base, &sha3_ctx->hash_state, data,
 804                                     len);
 805}
 806
 807/* Finalize the SHA-3 hash operation and produce the digest using the PSoC6
 808 * hardware crypto engine.
 809 *
 810 * sha3    wc_Sha3 object holding state.
 811 * padChar Padding character for SHA-3.
 812 * hash    Output buffer for hash result.
 813 * p       SHA-3 parameter (block size/count).
 814 * l       Output length.
 815 * returns 0 on success, BAD_FUNC_ARG or hardware error code on failure.
 816 */
 817int wc_Psoc6_Sha3_Final(void* sha3, byte padChar, byte* hash, byte p, word32 l)
 818{
 819    word32 rate = p * BITS_IN_BYTE;
 820    word32 offset;
 821    wc_Sha3* sha3_ctx = (wc_Sha3*)sha3;
 822
 823    /* For KECCCAK256 specific padding */
 824#ifdef WOLFSSL_HASH_FLAGS
 825    if ((p == WC_SHA3_256_COUNT) && (sha3_ctx->flags & WC_HASH_SHA3_KECCAK256))
 826        padChar = 0x01;
 827#endif
 828
 829    /* Apply padding */
 830    sha3_ctx->hash_state.hash[sha3_ctx->hash_state.blockIdx] ^= padChar;
 831    sha3_ctx->hash_state.hash[rate - 1] ^= 0x80;
 832
 833    /* Clear the register buffer */
 834    Cy_Crypto_Core_V2_RBClear(crypto_base);
 835
 836    /* Wait until the instruction is complete */
 837    Cy_Crypto_Core_V2_Sync(crypto_base);
 838
 839    /* Start streaming data in sha3_ctx->sha_buffers.hash into LOAD_FIFO0 */
 840    Cy_Crypto_Core_V2_FFStart(crypto_base, CY_CRYPTO_V2_RB_FF_LOAD0,
 841                              sha3_ctx->sha_buffers.hash,
 842                              CY_CRYPTO_SHA3_STATE_SIZE);
 843
 844    /* XOR data present in lower register buffer partition with data streamed
 845     * from LOAD0_FIF0 */
 846    Cy_Crypto_Core_V2_RBXor(crypto_base, 0U, PSOC6_CRYPTO_SHA3_RB_LOWER);
 847
 848    /* Swap the data present in the two register buffer partitions
 849     * (swap(reg_buff[1023:0], reg_buff[2047:1024])) */
 850    Cy_Crypto_Core_V2_RBSwap(crypto_base);
 851
 852    /* XOR data present in upper register buffer partition with data streamed
 853     * from LOAD0_FIF0 */
 854    Cy_Crypto_Core_V2_RBXor(crypto_base, 0U, PSOC6_CRYPTO_SHA3_RB_UPPER);
 855
 856    /* Swap the data present in the two register buffer partitions. The recently
 857     * XOR'ed data will be now present in 2nd partition */
 858    Cy_Crypto_Core_V2_RBSwap(crypto_base);
 859
 860    /* Wait until the instruction is complete */
 861    Cy_Crypto_Core_V2_Sync(crypto_base);
 862
 863    /* Process full blocks and write output to hash buffer */
 864    for (offset = 0; l - offset >= rate; offset += rate) {
 865        /* Perform SHA3 on current state. */
 866        Cy_Crypto_Core_V2_Run(crypto_base, sha3_ctx->hash_state.modeHw);
 867
 868        /* Wait until the instruction is complete */
 869        Cy_Crypto_Core_V2_Sync(crypto_base);
 870
 871        /* If the rate is more than 128, then we have to copy the data in 2nd
 872         * partition of register buffer as well */
 873        if (rate > PSOC6_CRYPTO_SHA3_RB_LOWER) {
 874            /* Start streaming data in 1st partition of register buffer into
 875             * hash buffer */
 876            Cy_Crypto_Core_V2_FFStart(crypto_base, CY_CRYPTO_V2_RB_FF_STORE,
 877                                      hash + offset,
 878                                      PSOC6_CRYPTO_SHA3_RB_LOWER);
 879
 880            /* Copy the data in register buffer lower partition into hash buffer
 881             */
 882            Cy_Crypto_Core_V2_RBStore(crypto_base, 0U,
 883                                      PSOC6_CRYPTO_SHA3_RB_LOWER);
 884
 885            /* Wait until FF_STORE operation is completed */
 886            Cy_Crypto_Core_V2_FFStoreSync(crypto_base);
 887
 888            /* Swap the data present in the two register buffer partitions
 889             * (swap(reg_buff[1023:0], reg_buff[2047:1024])) */
 890            Cy_Crypto_Core_V2_RBSwap(crypto_base);
 891
 892            /* Wait until the instruction is complete */
 893            Cy_Crypto_Core_V2_Sync(crypto_base);
 894
 895            /* Now the 1st partition have 2nd partition data, start streaming
 896             * remaining extra data in register buffer into hash buffer */
 897            Cy_Crypto_Core_V2_FFStart(crypto_base, CY_CRYPTO_V2_RB_FF_STORE,
 898                                      hash + offset +
 899                                          PSOC6_CRYPTO_SHA3_RB_LOWER,
 900                                      (rate - PSOC6_CRYPTO_SHA3_RB_LOWER));
 901
 902            /* Copy the remaining data in register buffer lower partition into
 903             * hash buffer */
 904            Cy_Crypto_Core_V2_RBStore(crypto_base, 0U,
 905                                      (rate - PSOC6_CRYPTO_SHA3_RB_LOWER));
 906
 907            /* Wait until FF_STORE operation is completed */
 908            Cy_Crypto_Core_V2_FFStoreSync(crypto_base);
 909
 910            /* Swap back the register buffer partitions */
 911            Cy_Crypto_Core_V2_RBSwap(crypto_base);
 912        }
 913        else {
 914            /* Start streaming data in 1st partition of register buffer into
 915             * hash buffer */
 916            Cy_Crypto_Core_V2_FFStart(crypto_base, CY_CRYPTO_V2_RB_FF_STORE,
 917                                      hash + offset, rate);
 918
 919            /* Copy the remaining data in register buffer lower partition into
 920             * hash buffer */
 921            Cy_Crypto_Core_V2_RBStore(crypto_base, 0U, rate);
 922
 923            /* Wait until FF_STORE operation is completed */
 924            Cy_Crypto_Core_V2_FFStoreSync(crypto_base);
 925        }
 926    }
 927
 928    /* If more data need to be processed */
 929    if (offset != l) {
 930        /* Perform SHA3 on current state. */
 931        Cy_Crypto_Core_V2_Run(crypto_base, sha3_ctx->hash_state.modeHw);
 932
 933        /* Wait until the instruction is complete */
 934        Cy_Crypto_Core_V2_Sync(crypto_base);
 935
 936        /* If amount of data to be copied is more than length of register buffer
 937         * partition (128), */
 938        /* then we have to copy the data in 2nd partition of register buffer as
 939         * well */
 940        if ((l - offset) > PSOC6_CRYPTO_SHA3_RB_LOWER) {
 941            /* Start streaming data in 1st partition of register buffer into
 942             * hash buffer */
 943            Cy_Crypto_Core_V2_FFStart(crypto_base, CY_CRYPTO_V2_RB_FF_STORE,
 944                                      hash + offset,
 945                                      PSOC6_CRYPTO_SHA3_RB_LOWER);
 946
 947            /* Copy the data in register buffer lower partition into hash buffer
 948             */
 949            Cy_Crypto_Core_V2_RBStore(crypto_base, 0U,
 950                                      PSOC6_CRYPTO_SHA3_RB_LOWER);
 951
 952            /* Wait until FF_STORE operation is completed */
 953            Cy_Crypto_Core_V2_FFStoreSync(crypto_base);
 954
 955            /* Swap the data present in the two register buffer partitions
 956             * (swap(reg_buff[1023:0], reg_buff[2047:1024])) */
 957            Cy_Crypto_Core_V2_RBSwap(crypto_base);
 958
 959            /* Wait until the instruction is complete */
 960            Cy_Crypto_Core_V2_Sync(crypto_base);
 961
 962            /* Now the 1st partition have 2nd partition data, start streaming
 963             * remaining extra data in register buffer into hash buffer */
 964            Cy_Crypto_Core_V2_FFStart(
 965                crypto_base, CY_CRYPTO_V2_RB_FF_STORE,
 966                hash + offset + PSOC6_CRYPTO_SHA3_RB_LOWER,
 967                ((l - offset) - PSOC6_CRYPTO_SHA3_RB_LOWER));
 968
 969            /* Copy the remaining data in register buffer lower partition into
 970             * hash buffer */
 971            Cy_Crypto_Core_V2_RBStore(
 972                crypto_base, 0U, ((l - offset) - PSOC6_CRYPTO_SHA3_RB_LOWER));
 973
 974            /* Wait until FF_STORE operation is completed */
 975            Cy_Crypto_Core_V2_FFStoreSync(crypto_base);
 976        }
 977        else {
 978            /* Start streaming data in 1st partition of register buffer into
 979             * hash buffer */
 980            Cy_Crypto_Core_V2_FFStart(crypto_base, CY_CRYPTO_V2_RB_FF_STORE,
 981                                      hash + offset, l - offset);
 982
 983            /* Copy the data in register buffer lower partition into hash buffer
 984             */
 985            Cy_Crypto_Core_V2_RBStore(crypto_base, 0U, l - offset);
 986
 987            /* Wait until FF_STORE operation is completed */
 988            Cy_Crypto_Core_V2_FFStoreSync(crypto_base);
 989        }
 990    }
 991
 992    return 0;
 993}
 994
 995#if defined(WOLFSSL_SHAKE128) || defined(WOLFSSL_SHAKE256)
 996
 997/* Squeeze output blocks from a SHAKE state using the PSoC6 hardware crypto
 998 * engine.
 999 *
1000 * shake    wc_Shake object holding state.
1001 * out      Output buffer for squeezed blocks.
1002 * blockCnt Number of blocks to squeeze.
1003 * returns 0 on success, BAD_FUNC_ARG or hardware error code on failure.
1004 */
1005int wc_Psoc6_Shake_SqueezeBlocks(void* shake, byte* out, word32 blockCnt)
1006{
1007    wc_Shake* shake_ctx = (wc_Shake*)shake;
1008
1009    for (; (blockCnt > 0); blockCnt--) {
1010        /* Perform SHA3 on the current state */
1011        Cy_Crypto_Core_V2_Run(crypto_base, shake_ctx->hash_state.modeHw);
1012
1013        /* Wait until the instruction is complete */
1014        Cy_Crypto_Core_V2_Sync(crypto_base);
1015
1016        /* Start streaming data in 1st partition of register buffer into hash
1017         * buffer */
1018        Cy_Crypto_Core_V2_FFStart(crypto_base, CY_CRYPTO_V2_RB_FF_STORE, out,
1019                                  PSOC6_CRYPTO_SHA3_RB_LOWER);
1020
1021        /* Copy the data in register buffer lower partition into hash buffer */
1022        Cy_Crypto_Core_V2_RBStore(crypto_base, 0U, PSOC6_CRYPTO_SHA3_RB_LOWER);
1023
1024        /* Wait until FF_STORE operation is completed */
1025        Cy_Crypto_Core_V2_FFStoreSync(crypto_base);
1026
1027        /* Swap the data present in the two register buffer partitions
1028         * (swap(reg_buff[1023:0], reg_buff[2047:1024])) */
1029        Cy_Crypto_Core_V2_RBSwap(crypto_base);
1030
1031        /* Wait until the instruction is complete */
1032        Cy_Crypto_Core_V2_Sync(crypto_base);
1033
1034        /* Now the 1st partition have 2nd partition data, start streaming
1035         * remaining extra data in register buffer into hash buffer */
1036        Cy_Crypto_Core_V2_FFStart(crypto_base, CY_CRYPTO_V2_RB_FF_STORE,
1037                                  out + PSOC6_CRYPTO_SHA3_RB_LOWER,
1038                                  shake_ctx->hash_state.blockSize -
1039                                      PSOC6_CRYPTO_SHA3_RB_LOWER);
1040
1041        /* Copy the remaining data in register buffer lower partition into hash
1042         * buffer */
1043        Cy_Crypto_Core_V2_RBStore(crypto_base, 0U,
1044                                  shake_ctx->hash_state.blockSize -
1045                                      PSOC6_CRYPTO_SHA3_RB_LOWER);
1046
1047        /* Wait until FF_STORE operation is completed */
1048        Cy_Crypto_Core_V2_FFStoreSync(crypto_base);
1049
1050        /* Swap back the register buffer partitions */
1051        Cy_Crypto_Core_V2_RBSwap(crypto_base);
1052
1053        /* Move to the next block */
1054        out += shake_ctx->hash_state.blockSize;
1055    }
1056
1057    return 0;
1058}
1059
1060#endif /* WOLFSSL_SHAKE128 || WOLFSSL_SHAKE256 */
1061
1062#endif /* WOLFSSL_SHA3 && PSOC6_HASH_SHA3 */
1063
1064#if defined(PSOC6_CRYPTO_AES)
1065
1066/* Convert wolfSSL AES key length to PSoC6 crypto key length enumeration.
1067 *
1068 * This helper function maps standard AES key sizes to the corresponding
1069 * PSoC6 hardware crypto enumeration values.
1070 *
1071 * keyLen   AES key length in bytes (16, 24, or 32)
1072 * returns  Corresponding PSoC6 key length enumeration value
1073 *          - CY_CRYPTO_KEY_AES_128 for 16-byte keys (AES-128)
1074 *          - CY_CRYPTO_KEY_AES_192 for 24-byte keys (AES-192)
1075 *          - CY_CRYPTO_KEY_AES_256 for 32-byte keys (AES-256)
1076 *          - CY_CRYPTO_KEY_AES_128 as safe default (key validation done
1077 * earlier)
1078 */
1079static cy_en_crypto_aes_key_length_t psoc6_get_aes_key_length(word32 keyLen)
1080{
1081    switch (keyLen) {
1082        case 16:
1083            return CY_CRYPTO_KEY_AES_128;
1084        case 24:
1085            return CY_CRYPTO_KEY_AES_192;
1086        case 32:
1087            return CY_CRYPTO_KEY_AES_256;
1088        default:
1089            /* Safe default - validation done in wc_Psoc6_Aes_SetKey */
1090            return CY_CRYPTO_KEY_AES_128;
1091    }
1092}
1093
1094/* Initialize AES context with key and optional IV for PSoC6 hardware
1095 * acceleration.
1096 *
1097 * Sets up the AES context structure with the provided key and optional
1098 * initialization vector. This function validates key length, stores key
1099 * information, and prepares the context for subsequent crypto operations.
1100 * The actual hardware key scheduling is performed during encrypt/decrypt calls.
1101 *
1102 * aes     Pointer to AES context structure to initialize
1103 * userKey Pointer to AES key buffer (16, 24, or 32 bytes)
1104 * len     Key length in bytes (must be 16, 24, or 32)
1105 * iv      Pointer to initialization vector (AES_BLOCK_SIZE bytes, optional)
1106 * dir     Encryption direction (currently unused, direction handled
1107 * per-operation)
1108 *
1109 * returns 0 on success, BAD_FUNC_ARG for invalid parameters
1110 *
1111 * Note: This function only stores the key and IV in the wolfSSL context.
1112 *       Hardware initialization occurs during actual crypto operations.
1113 */
1114int wc_Psoc6_Aes_SetKey(Aes* aes, const byte* userKey, word32 len,
1115                        const byte* iv, int dir)
1116{
1117    int ret = 0;
1118
1119    if (aes == NULL || userKey == NULL) {
1120        return BAD_FUNC_ARG;
1121    }
1122
1123    /* Validate key length */
1124    if (len != 16 && len != 24 && len != 32) {
1125        return BAD_FUNC_ARG;
1126    }
1127
1128    /* Store key information in wolfSSL structure */
1129    aes->keylen = len;
1130    aes->rounds = len / 4 + 6;
1131
1132#if defined(WOLFSSL_AES_CFB)
1133    aes->left = 0;
1134#endif
1135
1136    XMEMCPY(aes->key, userKey, len);
1137
1138    /* Store IV if provided */
1139    if (iv != NULL) {
1140        XMEMCPY(aes->reg, iv, AES_BLOCK_SIZE);
1141    }
1142
1143    (void)dir; /* Direction is handled per-operation */
1144
1145    return ret;
1146}
1147
1148/* Free the internal AES buffers used by PSOC6 CRYPTO block.
1149 *
1150 * This function clears the internal AES buffers allocated
1151 * in the AES context. It is called after encryption/decryption operations
1152 * to ensure sensitive data is not left in memory.
1153 *
1154 * aes   Pointer to initialized AES context
1155 *
1156 * Note: Thread safety is implemented in the functions it is called, so no
1157 * need to lock the mutex again here.
1158 */
1159void wc_Psoc6_Aes_Free(Aes* aes)
1160{
1161    /* Only aes_buffers are cleared here. aes_state is cleared in wc_AesFree()
1162     */
1163    if (aes->aes_state.buffers != NULL) {
1164        Cy_Crypto_Core_V2_MemSet(
1165            crypto_base, (void*)aes->aes_state.buffers, 0u,
1166            ((uint16_t)sizeof(cy_stc_crypto_aes_buffers_t)));
1167    }
1168
1169#ifdef HAVE_AESGCM
1170    /* No need to clear the buffers again if internal buffers are not
1171     * initialized */
1172    if (aes->aes_gcm_state.aes_buffer != NULL) {
1173        Cy_Crypto_Core_Aes_GCM_Free(crypto_base, &aes->aes_gcm_state);
1174    }
1175#endif /* HAVE_AESGCM */
1176}
1177
1178/* Encrypt a single AES block using PSoC6 hardware acceleration.
1179 *
1180 * Performs AES encryption on exactly one block (16 bytes) of data using
1181 * the PSoC6 crypto hardware in ECB mode. The function initializes the
1182 * hardware with the key from the AES context, performs the encryption,
1183 * and cleans up resources.
1184 *
1185 * aes   Pointer to initialized AES context containing key
1186 * in    Pointer to input plaintext block (exactly AES_BLOCK_SIZE bytes)
1187 * out   Pointer to output ciphertext buffer (exactly AES_BLOCK_SIZE bytes)
1188 *
1189 * returns 0 on success, BAD_FUNC_ARG for invalid parameters, WC_HW_E for
1190 *         hardware errors, or mutex error codes
1191 */
1192int wc_Psoc6_Aes_Encrypt(Aes* aes, const byte* in, byte* out)
1193{
1194    int ret = 0;
1195    cy_en_crypto_status_t status;
1196    cy_en_crypto_aes_key_length_t keyLength;
1197    int aesInited = 0;
1198
1199    if (aes == NULL || in == NULL || out == NULL) {
1200        return BAD_FUNC_ARG;
1201    }
1202
1203    keyLength = psoc6_get_aes_key_length(aes->keylen);
1204
1205    /* Lock the mutex to perform crypto operations */
1206    ret = wolfSSL_CryptHwMutexLock();
1207    if (ret != 0) {
1208        return ret;
1209    }
1210
1211    /* Initialize AES state with key */
1212    status = Cy_Crypto_Core_Aes_Init(crypto_base, (const uint8_t*)aes->key,
1213                                     keyLength, &aes->aes_state);
1214    if (status != CY_CRYPTO_SUCCESS) {
1215        ret = WC_HW_E;
1216        goto cleanup;
1217    }
1218
1219    aesInited = 1;
1220
1221    /* Encrypt single block using ECB mode */
1222    status = Cy_Crypto_Core_Aes_Ecb(crypto_base, CY_CRYPTO_ENCRYPT, out, in,
1223                                    &aes->aes_state);
1224    if (status != CY_CRYPTO_SUCCESS) {
1225        ret = WC_HW_E;
1226        goto cleanup;
1227    }
1228
1229cleanup:
1230    if (aesInited) {
1231        wc_Psoc6_Aes_Free(aes);
1232    }
1233
1234    /* Release the lock */
1235    wolfSSL_CryptHwMutexUnLock();
1236    return ret;
1237}
1238
1239#ifdef WOLFSSL_AES_DIRECT
1240/* Direct AES encryption wrapper with parameter order compatibility.
1241 *
1242 * Provides parameter order compatibility with wolfSSL's direct AES interface.
1243 * This is a simple wrapper around wc_Psoc6_Aes_Encrypt that reorders parameters
1244 * to match the expected direct encryption API.
1245 *
1246 * aes   Pointer to initialized AES context containing key
1247 * out   Pointer to output ciphertext buffer (exactly AES_BLOCK_SIZE bytes)
1248 * in    Pointer to input plaintext block (exactly AES_BLOCK_SIZE bytes)
1249 *
1250 * returns 0 on success, or error codes from wc_Psoc6_Aes_Encrypt
1251 */
1252int wc_Psoc6_Aes_EncryptDirect(Aes* aes, byte* out, const byte* in)
1253{
1254    return wc_Psoc6_Aes_Encrypt(aes, in, out);
1255}
1256#endif /* WOLFSSL_AES_DIRECT */
1257
1258#ifdef HAVE_AES_DECRYPT
1259/* Decrypt a single AES block using PSoC6 hardware acceleration.
1260 *
1261 * Performs AES decryption on exactly one block (16 bytes) of data using
1262 * the PSoC6 crypto hardware in ECB mode. The function initializes the
1263 * hardware with the key from the AES context, performs the decryption,
1264 * and cleans up resources.
1265 *
1266 * aes   Pointer to initialized AES context containing key
1267 * in    Pointer to input ciphertext block (exactly AES_BLOCK_SIZE bytes)
1268 * out   Pointer to output plaintext buffer (exactly AES_BLOCK_SIZE bytes)
1269 *
1270 * returns 0 on success, BAD_FUNC_ARG for invalid parameters, WC_HW_E for
1271 *         hardware errors, or mutex error codes
1272 */
1273int wc_Psoc6_Aes_Decrypt(Aes* aes, const byte* in, byte* out)
1274{
1275    int ret = 0;
1276    cy_en_crypto_status_t status;
1277    cy_en_crypto_aes_key_length_t keyLength;
1278    int aesInited = 0;
1279
1280    if (aes == NULL || in == NULL || out == NULL) {
1281        return BAD_FUNC_ARG;
1282    }
1283
1284    keyLength = psoc6_get_aes_key_length(aes->keylen);
1285
1286    /* Lock the mutex to perform crypto operations */
1287    ret = wolfSSL_CryptHwMutexLock();
1288    if (ret != 0) {
1289        return ret;
1290    }
1291
1292    /* Initialize AES state with key */
1293    status = Cy_Crypto_Core_Aes_Init(crypto_base, (const uint8_t*)aes->key,
1294                                     keyLength, &aes->aes_state);
1295    if (status != CY_CRYPTO_SUCCESS) {
1296        ret = WC_HW_E;
1297        goto cleanup;
1298    }
1299
1300    aesInited = 1;
1301
1302    /* Decrypt single block using ECB mode */
1303    status = Cy_Crypto_Core_Aes_Ecb(crypto_base, CY_CRYPTO_DECRYPT, out, in,
1304                                    &aes->aes_state);
1305    if (status != CY_CRYPTO_SUCCESS) {
1306        ret = WC_HW_E;
1307        goto cleanup;
1308    }
1309
1310cleanup:
1311    if (aesInited) {
1312        wc_Psoc6_Aes_Free(aes);
1313    }
1314
1315    /* Release the lock */
1316    wolfSSL_CryptHwMutexUnLock();
1317    return ret;
1318}
1319
1320#ifdef WOLFSSL_AES_DIRECT
1321/* Direct AES decryption wrapper with parameter order compatibility.
1322 *
1323 * Provides parameter order compatibility with wolfSSL's direct AES interface.
1324 * This is a simple wrapper around wc_Psoc6_Aes_Decrypt that reorders parameters
1325 * to match the expected direct decryption API.
1326 *
1327 * aes   Pointer to initialized AES context containing key
1328 * out   Pointer to output plaintext buffer (exactly AES_BLOCK_SIZE bytes)
1329 * in    Pointer to input ciphertext block (exactly AES_BLOCK_SIZE bytes)
1330 *
1331 * returns 0 on success, or error codes from wc_Psoc6_Aes_Decrypt
1332 */
1333int wc_Psoc6_Aes_DecryptDirect(Aes* aes, byte* out, const byte* in)
1334{
1335    return wc_Psoc6_Aes_Decrypt(aes, in, out);
1336}
1337#endif /* WOLFSSL_AES_DIRECT */
1338#endif /* HAVE_AES_DECRYPT */
1339
1340#if defined(HAVE_AES_ECB)
1341/* Encrypt multiple blocks using AES-ECB mode with PSoC6 hardware.
1342 *
1343 * Performs AES encryption on multiple blocks of data using Electronic
1344 * Codebook (ECB) mode. Each block is encrypted independently using the
1345 * same key. The input size must be a multiple of AES_BLOCK_SIZE.
1346 *
1347 * aes   Pointer to initialized AES context containing key
1348 * out   Pointer to output ciphertext buffer (sz bytes)
1349 * in    Pointer to input plaintext buffer (sz bytes)
1350 * sz    Size of data in bytes (must be multiple of AES_BLOCK_SIZE)
1351 *
1352 * returns 0 on success, BAD_FUNC_ARG for invalid parameters (including
1353 *         non-block-aligned sizes), WC_HW_E for hardware errors, or
1354 *         mutex error codes
1355 */
1356int wc_Psoc6_Aes_EcbEncrypt(Aes* aes, byte* out, const byte* in, word32 sz)
1357{
1358    int ret = 0;
1359    cy_en_crypto_status_t status;
1360    cy_en_crypto_aes_key_length_t keyLength;
1361    int aesInited = 0;
1362
1363    if (aes == NULL || in == NULL || out == NULL) {
1364        return BAD_FUNC_ARG;
1365    }
1366
1367    if (sz % AES_BLOCK_SIZE != 0) {
1368        return BAD_FUNC_ARG;
1369    }
1370
1371    keyLength = psoc6_get_aes_key_length(aes->keylen);
1372
1373    /* Lock the mutex to perform crypto operations */
1374    ret = wolfSSL_CryptHwMutexLock();
1375    if (ret != 0) {
1376        return ret;
1377    }
1378
1379    /* Initialize AES state once for all blocks */
1380    status = Cy_Crypto_Core_Aes_Init(crypto_base, (const uint8_t*)aes->key,
1381                                     keyLength, &aes->aes_state);
1382    if (status != CY_CRYPTO_SUCCESS) {
1383        ret = WC_HW_E;
1384        goto cleanup;
1385    }
1386
1387    aesInited = 1;
1388    Cy_Crypto_Core_V2_Aes_LoadEncKey(crypto_base, &aes->aes_state);
1389    Cy_Crypto_Core_V2_FFContinue(crypto_base, CY_CRYPTO_V2_RB_FF_LOAD0, in, sz);
1390    Cy_Crypto_Core_V2_FFStart(crypto_base, CY_CRYPTO_V2_RB_FF_STORE, out, sz);
1391
1392    for (; sz > 0; sz -= CY_CRYPTO_AES_BLOCK_SIZE) {
1393        Cy_Crypto_Core_V2_BlockMov(crypto_base, CY_CRYPTO_V2_RB_BLOCK0,
1394                                   CY_CRYPTO_V2_RB_FF_LOAD0,
1395                                   CY_CRYPTO_AES_BLOCK_SIZE);
1396        Cy_Crypto_Core_V2_RunAes(crypto_base);
1397
1398        Cy_Crypto_Core_V2_BlockMov(crypto_base, CY_CRYPTO_V2_RB_FF_STORE,
1399                                   CY_CRYPTO_V2_RB_BLOCK1,
1400                                   CY_CRYPTO_AES_BLOCK_SIZE);
1401    }
1402
1403    Cy_Crypto_Core_WaitForReady(crypto_base);
1404
1405cleanup:
1406    if (aesInited) {
1407        wc_Psoc6_Aes_Free(aes);
1408    }
1409
1410    /* Release the lock */
1411    wolfSSL_CryptHwMutexUnLock();
1412    return ret;
1413}
1414
1415#ifdef HAVE_AES_DECRYPT
1416/* Decrypt multiple blocks using AES-ECB mode with PSoC6 hardware.
1417 *
1418 * Performs AES decryption on multiple blocks of data using Electronic
1419 * Codebook (ECB) mode. Each block is decrypted independently using the
1420 * same key. The input size must be a multiple of AES_BLOCK_SIZE.
1421 *
1422 * aes   Pointer to initialized AES context containing key
1423 * out   Pointer to output plaintext buffer (sz bytes)
1424 * in    Pointer to input ciphertext buffer (sz bytes)
1425 * sz    Size of data in bytes (must be multiple of AES_BLOCK_SIZE)
1426 *
1427 * returns 0 on success, BAD_FUNC_ARG for invalid parameters (including
1428 *         non-block-aligned sizes), WC_HW_E for hardware errors, or
1429 *         mutex error codes
1430 */
1431int wc_Psoc6_Aes_EcbDecrypt(Aes* aes, byte* out, const byte* in, word32 sz)
1432{
1433    int ret = 0;
1434    cy_en_crypto_status_t status;
1435    cy_en_crypto_aes_key_length_t keyLength;
1436    int aesInited = 0;
1437
1438    if (aes == NULL || in == NULL || out == NULL) {
1439        return BAD_FUNC_ARG;
1440    }
1441
1442    if (sz % AES_BLOCK_SIZE != 0) {
1443        return BAD_FUNC_ARG;
1444    }
1445
1446    keyLength = psoc6_get_aes_key_length(aes->keylen);
1447
1448    /* Lock the mutex to perform crypto operations */
1449    ret = wolfSSL_CryptHwMutexLock();
1450    if (ret != 0) {
1451        return ret;
1452    }
1453
1454    /* Initialize AES state once for all blocks */
1455    status = Cy_Crypto_Core_Aes_Init(crypto_base, (const uint8_t*)aes->key,
1456                                     keyLength, &aes->aes_state);
1457    if (status != CY_CRYPTO_SUCCESS) {
1458        ret = WC_HW_E;
1459        goto cleanup;
1460    }
1461
1462    aesInited = 1;
1463
1464    Cy_Crypto_Core_V2_Aes_LoadDecKey(crypto_base, &aes->aes_state);
1465    Cy_Crypto_Core_V2_FFContinue(crypto_base, CY_CRYPTO_V2_RB_FF_LOAD0, in, sz);
1466    Cy_Crypto_Core_V2_FFStart(crypto_base, CY_CRYPTO_V2_RB_FF_STORE, out, sz);
1467
1468    for (; sz > 0; sz -= CY_CRYPTO_AES_BLOCK_SIZE) {
1469        Cy_Crypto_Core_V2_BlockMov(crypto_base, CY_CRYPTO_V2_RB_BLOCK0,
1470                                   CY_CRYPTO_V2_RB_FF_LOAD0,
1471                                   CY_CRYPTO_AES_BLOCK_SIZE);
1472        Cy_Crypto_Core_V2_RunAesInv(crypto_base);
1473
1474        Cy_Crypto_Core_V2_BlockMov(crypto_base, CY_CRYPTO_V2_RB_FF_STORE,
1475                                   CY_CRYPTO_V2_RB_BLOCK1,
1476                                   CY_CRYPTO_AES_BLOCK_SIZE);
1477    }
1478
1479    Cy_Crypto_Core_WaitForReady(crypto_base);
1480
1481cleanup:
1482    if (aesInited) {
1483        wc_Psoc6_Aes_Free(aes);
1484    }
1485
1486    /* Release the lock */
1487    wolfSSL_CryptHwMutexUnLock();
1488    return ret;
1489}
1490#endif /* HAVE_AES_DECRYPT */
1491#endif /* HAVE_AES_ECB */
1492
1493/* AES CBC */
1494#ifdef HAVE_AES_CBC
1495/* Encrypt multiple blocks using AES-CBC mode with PSoC6 hardware.
1496 *
1497 * Performs AES encryption using Cipher Block Chaining (CBC) mode where
1498 * each plaintext block is XORed with the previous ciphertext block before
1499 * encryption. The initialization vector (IV) from the AES context is used
1500 * for the first block and updated during the operation.
1501 *
1502 * aes   Pointer to initialized AES context containing key and IV
1503 * out   Pointer to output ciphertext buffer (sz bytes)
1504 * in    Pointer to input plaintext buffer (sz bytes)
1505 * sz    Size of data in bytes (must be multiple of AES_BLOCK_SIZE)
1506 *
1507 * returns 0 on success, BAD_FUNC_ARG for invalid parameters (including
1508 *         non-block-aligned sizes), WC_HW_E for hardware errors, or
1509 *         mutex error codes
1510 */
1511int wc_Psoc6_Aes_CbcEncrypt(Aes* aes, byte* out, const byte* in, word32 sz)
1512{
1513    int ret = 0;
1514    cy_en_crypto_status_t status;
1515    cy_en_crypto_aes_key_length_t keyLength;
1516    int aesInited = 0;
1517
1518    if (aes == NULL || in == NULL || out == NULL) {
1519        return BAD_FUNC_ARG;
1520    }
1521
1522    if (sz % AES_BLOCK_SIZE != 0) {
1523        return BAD_FUNC_ARG;
1524    }
1525
1526    keyLength = psoc6_get_aes_key_length(aes->keylen);
1527
1528    /* Lock the mutex to perform crypto operations */
1529    ret = wolfSSL_CryptHwMutexLock();
1530    if (ret != 0) {
1531        return ret;
1532    }
1533
1534    /* Initialize AES state with key */
1535    status = Cy_Crypto_Core_Aes_Init(crypto_base, (const uint8_t*)aes->key,
1536                                     keyLength, &aes->aes_state);
1537    if (status != CY_CRYPTO_SUCCESS) {
1538        ret = WC_HW_E;
1539        goto cleanup;
1540    }
1541
1542    aesInited = 1;
1543    status =
1544        Cy_Crypto_Core_Aes_Cbc(crypto_base, CY_CRYPTO_ENCRYPT, sz,
1545                               (uint8_t*)aes->reg, out, in, &aes->aes_state);
1546    if (status != CY_CRYPTO_SUCCESS) {
1547        ret = WC_HW_E;
1548        goto cleanup;
1549    }
1550
1551cleanup:
1552    if (aesInited) {
1553        wc_Psoc6_Aes_Free(aes);
1554    }
1555
1556    /* Release the lock */
1557    wolfSSL_CryptHwMutexUnLock();
1558    return ret;
1559}
1560
1561#ifdef HAVE_AES_DECRYPT
1562/* Decrypt multiple blocks using AES-CBC mode with PSoC6 hardware.
1563 *
1564 * Performs AES decryption using Cipher Block Chaining (CBC) mode where
1565 * each ciphertext block is decrypted and XORed with the previous ciphertext
1566 * block. The initialization vector (IV) from the AES context is used for
1567 * the first block and updated during the operation.
1568 *
1569 * aes   Pointer to initialized AES context containing key and IV
1570 * out   Pointer to output plaintext buffer (sz bytes)
1571 * in    Pointer to input ciphertext buffer (sz bytes)
1572 * sz    Size of data in bytes (must be multiple of AES_BLOCK_SIZE)
1573 *
1574 * returns 0 on success, BAD_FUNC_ARG for invalid parameters (including
1575 *         non-block-aligned sizes), WC_HW_E for hardware errors, or
1576 *         mutex error codes
1577 */
1578int wc_Psoc6_Aes_CbcDecrypt(Aes* aes, byte* out, const byte* in, word32 sz)
1579{
1580    int ret = 0;
1581    cy_en_crypto_status_t status;
1582    cy_en_crypto_aes_key_length_t keyLength;
1583    int aesInited = 0;
1584
1585    if (aes == NULL || in == NULL || out == NULL) {
1586        return BAD_FUNC_ARG;
1587    }
1588
1589    if (sz % AES_BLOCK_SIZE != 0) {
1590        return BAD_FUNC_ARG;
1591    }
1592
1593    keyLength = psoc6_get_aes_key_length(aes->keylen);
1594
1595    /* Lock the mutex to perform crypto operations */
1596    ret = wolfSSL_CryptHwMutexLock();
1597    if (ret != 0) {
1598        return ret;
1599    }
1600
1601    /* Initialize AES state with key */
1602    status = Cy_Crypto_Core_Aes_Init(crypto_base, (const uint8_t*)aes->key,
1603                                     keyLength, &aes->aes_state);
1604    if (status != CY_CRYPTO_SUCCESS) {
1605        ret = WC_HW_E;
1606        goto cleanup;
1607    }
1608
1609    aesInited = 1;
1610
1611    status =
1612        Cy_Crypto_Core_Aes_Cbc(crypto_base, CY_CRYPTO_DECRYPT, sz,
1613                               (uint8_t*)aes->reg, out, in, &aes->aes_state);
1614    if (status != CY_CRYPTO_SUCCESS) {
1615        ret = WC_HW_E;
1616        goto cleanup;
1617    }
1618
1619cleanup:
1620    if (aesInited) {
1621        wc_Psoc6_Aes_Free(aes);
1622    }
1623
1624    /* Release the lock */
1625    wolfSSL_CryptHwMutexUnLock();
1626    return ret;
1627}
1628#endif /* HAVE_AES_DECRYPT */
1629#endif /* HAVE_AES_CBC */
1630
1631/* AES CFB */
1632#ifdef WOLFSSL_AES_CFB
1633/* Encrypt data using AES-CFB mode with PSoC6 hardware acceleration.
1634 *
1635 * Performs AES encryption using Cipher Feedback (CFB) mode, which operates
1636 * as a stream cipher. CFB can handle data that is not block-aligned and
1637 * maintains state between calls for streaming operations. The IV and
1638 * partial block state are managed automatically.
1639 *
1640 * aes   Pointer to initialized AES context containing key, IV, and state
1641 * out   Pointer to output ciphertext buffer (sz bytes)
1642 * in    Pointer to input plaintext buffer (sz bytes)
1643 * sz    Size of data in bytes (can be any length, not limited to block size)
1644 *
1645 * returns 0 on success, BAD_FUNC_ARG for invalid parameters, WC_HW_E for
1646 *         hardware errors, or mutex error codes
1647 */
1648int wc_Psoc6_Aes_CfbEncrypt(Aes* aes, byte* out, const byte* in, word32 sz)
1649{
1650    int ret = 0;
1651    cy_en_crypto_status_t status;
1652    cy_en_crypto_aes_key_length_t keyLength;
1653    int aesInited = 0;
1654
1655    if (aes == NULL || in == NULL || out == NULL) {
1656        return BAD_FUNC_ARG;
1657    }
1658
1659    keyLength = psoc6_get_aes_key_length(aes->keylen);
1660
1661    /* Lock the mutex to perform crypto operations */
1662    ret = wolfSSL_CryptHwMutexLock();
1663    if (ret != 0) {
1664        return ret;
1665    }
1666
1667    /* Initialize AES state with key */
1668    status = Cy_Crypto_Core_Aes_Init(crypto_base, (const uint8_t*)aes->key,
1669                                     keyLength, &aes->aes_state);
1670    if (status != CY_CRYPTO_SUCCESS) {
1671        ret = WC_HW_E;
1672        goto cleanup;
1673    }
1674
1675    aesInited = 1;
1676
1677    /* Setup CFB mode */
1678    status = Cy_Crypto_Core_Aes_Cfb_Setup(crypto_base, CY_CRYPTO_ENCRYPT,
1679                                          &aes->aes_state);
1680    if (status != CY_CRYPTO_SUCCESS) {
1681        ret = WC_HW_E;
1682        goto cleanup;
1683    }
1684
1685    /* Set IV */
1686    status = Cy_Crypto_Core_Aes_Cfb_Set_IV(crypto_base, (uint8_t*)aes->reg,
1687                                           &aes->aes_state);
1688    if (status != CY_CRYPTO_SUCCESS) {
1689        ret = WC_HW_E;
1690        goto cleanup;
1691    }
1692
1693    /* Copy the unprocessed bytes */
1694    aes->aes_state.unProcessedBytes = aes->left;
1695    XMEMCPY(aes->aes_state.buffers->unProcessedData, aes->tmp, AES_BLOCK_SIZE);
1696
1697    /* Update operation */
1698    status = Cy_Crypto_Core_Aes_Cfb_Update(crypto_base, sz, out, in,
1699                                           &aes->aes_state);
1700    if (status != CY_CRYPTO_SUCCESS) {
1701        ret = WC_HW_E;
1702        goto cleanup;
1703    }
1704
1705    /* Finish operation */
1706    status = Cy_Crypto_Core_Aes_Cfb_Finish(crypto_base, &aes->aes_state);
1707    if (status != CY_CRYPTO_SUCCESS) {
1708        ret = WC_HW_E;
1709        goto cleanup;
1710    }
1711
1712    /* Copy the updated IV into the AES context */
1713    XMEMCPY(aes->reg, aes->aes_state.buffers->iv, AES_BLOCK_SIZE);
1714
1715    /* Copy the number of bytes processed in the current block */
1716    aes->left = aes->aes_state.unProcessedBytes;
1717    XMEMCPY(aes->tmp, aes->aes_state.buffers->unProcessedData, AES_BLOCK_SIZE);
1718
1719cleanup:
1720    if (aesInited) {
1721        wc_Psoc6_Aes_Free(aes);
1722    }
1723
1724    /* Release the lock */
1725    wolfSSL_CryptHwMutexUnLock();
1726    return ret;
1727}
1728
1729#ifdef HAVE_AES_DECRYPT
1730/* Decrypt data using AES-CFB mode with PSoC6 hardware acceleration.
1731 *
1732 * Performs AES decryption using Cipher Feedback (CFB) mode, which operates
1733 * as a stream cipher. CFB can handle data that is not block-aligned and
1734 * maintains state between calls for streaming operations. The IV and
1735 * partial block state are managed automatically.
1736 *
1737 * aes   Pointer to initialized AES context containing key, IV, and state
1738 * out   Pointer to output plaintext buffer (sz bytes)
1739 * in    Pointer to input ciphertext buffer (sz bytes)
1740 * sz    Size of data in bytes (can be any length, not limited to block size)
1741 *
1742 * returns 0 on success, BAD_FUNC_ARG for invalid parameters, WC_HW_E for
1743 *         hardware errors, or mutex error codes
1744 */
1745int wc_Psoc6_Aes_CfbDecrypt(Aes* aes, byte* out, const byte* in, word32 sz)
1746{
1747    int ret = 0;
1748    cy_en_crypto_status_t status;
1749    cy_en_crypto_aes_key_length_t keyLength;
1750    int aesInited = 0;
1751
1752    if (aes == NULL || in == NULL || out == NULL) {
1753        return BAD_FUNC_ARG;
1754    }
1755
1756    keyLength = psoc6_get_aes_key_length(aes->keylen);
1757
1758    /* Lock the mutex to perform crypto operations */
1759    ret = wolfSSL_CryptHwMutexLock();
1760    if (ret != 0) {
1761        return ret;
1762    }
1763
1764    /* Initialize AES state with key */
1765    status = Cy_Crypto_Core_Aes_Init(crypto_base, (const uint8_t*)aes->key,
1766                                     keyLength, &aes->aes_state);
1767    if (status != CY_CRYPTO_SUCCESS) {
1768        ret = WC_HW_E;
1769        goto cleanup;
1770    }
1771
1772    aesInited = 1;
1773
1774    /* Setup CFB mode */
1775    status = Cy_Crypto_Core_Aes_Cfb_Setup(crypto_base, CY_CRYPTO_DECRYPT,
1776                                          &aes->aes_state);
1777    if (status != CY_CRYPTO_SUCCESS) {
1778        ret = WC_HW_E;
1779        goto cleanup;
1780    }
1781
1782    /* Set IV */
1783    status = Cy_Crypto_Core_Aes_Cfb_Set_IV(crypto_base, (uint8_t*)aes->reg,
1784                                           &aes->aes_state);
1785    if (status != CY_CRYPTO_SUCCESS) {
1786        ret = WC_HW_E;
1787        goto cleanup;
1788    }
1789
1790    /* Copy the unprocessed bytes */
1791    aes->aes_state.unProcessedBytes = aes->left;
1792    XMEMCPY(aes->aes_state.buffers->unProcessedData, aes->tmp, AES_BLOCK_SIZE);
1793
1794    /* Update operation */
1795    status = Cy_Crypto_Core_Aes_Cfb_Update(crypto_base, sz, out, in,
1796                                           &aes->aes_state);
1797    if (status != CY_CRYPTO_SUCCESS) {
1798        ret = WC_HW_E;
1799        goto cleanup;
1800    }
1801
1802    /* Finish operation */
1803    status = Cy_Crypto_Core_Aes_Cfb_Finish(crypto_base, &aes->aes_state);
1804    if (status != CY_CRYPTO_SUCCESS) {
1805        ret = WC_HW_E;
1806        goto cleanup;
1807    }
1808
1809    /* Copy the updated IV into the AES context */
1810    XMEMCPY(aes->reg, aes->aes_state.buffers->iv, AES_BLOCK_SIZE);
1811
1812    /* Copy the number of bytes processed in the current block */
1813    aes->left = aes->aes_state.unProcessedBytes;
1814    XMEMCPY(aes->tmp, aes->aes_state.buffers->unProcessedData, AES_BLOCK_SIZE);
1815
1816cleanup:
1817    if (aesInited) {
1818        wc_Psoc6_Aes_Free(aes);
1819    }
1820
1821    /* Release the lock */
1822    wolfSSL_CryptHwMutexUnLock();
1823    return ret;
1824}
1825#endif /* HAVE_AES_DECRYPT */
1826#endif /* WOLFSSL_AES_CFB */
1827
1828/* AES GCM */
1829#ifdef HAVE_AESGCM
1830
1831/* Perform authenticated AES-GCM encryption using PSoC6 hardware.
1832 *
1833 * Encrypts plaintext data and generates an authentication tag using
1834 * AES-GCM (Galois/Counter Mode). This mode provides both confidentiality
1835 * and authenticity in a single operation, making it ideal for secure
1836 * communications.
1837 *
1838 * aes        Pointer to initialized AES-GCM context (key must be set)
1839 * out        Pointer to output ciphertext buffer (sz bytes, can be NULL if
1840 * sz=0) in         Pointer to input plaintext buffer (sz bytes, can be NULL if
1841 * sz=0) sz         Size of plaintext/ciphertext data in bytes iv Pointer to
1842 * initialization vector/nonce buffer ivSz       Size of IV in bytes
1843 * (recommended: 12 bytes for GCM) authTag    Pointer to output authentication
1844 * tag buffer (authTagSz bytes) authTagSz  Size of authentication tag (typically
1845 * 12 or 16 bytes) authIn     Pointer to additional authenticated data (AAD),
1846 * can be NULL authInSz   Size of AAD in bytes (0 if no AAD)
1847 *
1848 * returns 0 on success WC_HW_E for hardware errors, or mutex error codes
1849 */
1850int wc_Psoc6_Aes_GcmEncrypt(Aes* aes, byte* out, const byte* in, word32 sz,
1851                            const byte* iv, word32 ivSz, byte* authTag,
1852                            word32 authTagSz, const byte* authIn,
1853                            word32 authInSz)
1854{
1855    int ret = 0;
1856    cy_en_crypto_status_t status;
1857    cy_en_crypto_aes_key_length_t keyLength;
1858    int aesInited = 0;
1859
1860    /* Lock the mutex to perform crypto operations */
1861    ret = wolfSSL_CryptHwMutexLock();
1862    if (ret != 0) {
1863        return ret;
1864    }
1865
1866    keyLength = psoc6_get_aes_key_length(aes->keylen);
1867
1868    /* Initialize AES GCM state */
1869    cy_stc_crypto_aes_gcm_buffers_t* aesBuffers =
1870        (cy_stc_crypto_aes_gcm_buffers_t*)((
1871            void*)Cy_Crypto_Core_GetVuMemoryAddress(crypto_base));
1872    status = Cy_Crypto_Core_Aes_GCM_Init(crypto_base, aesBuffers,
1873                                         &aes->aes_gcm_state);
1874    if (status != CY_CRYPTO_SUCCESS) {
1875        ret = WC_HW_E;
1876        goto cleanup;
1877    }
1878
1879    aesInited = 1;
1880
1881    /* Set the key */
1882    status = Cy_Crypto_Core_Aes_GCM_SetKey(crypto_base, (uint8_t*)aes->key,
1883                                           keyLength, &aes->aes_gcm_state);
1884    if (status != CY_CRYPTO_SUCCESS) {
1885        ret = WC_HW_E;
1886        goto cleanup;
1887    }
1888
1889    /* Start GCM operation */
1890    status = Cy_Crypto_Core_Aes_GCM_Start(crypto_base, CY_CRYPTO_ENCRYPT, iv,
1891                                          ivSz, &aes->aes_gcm_state);
1892    if (status != CY_CRYPTO_SUCCESS) {
1893        ret = WC_HW_E;
1894        goto cleanup;
1895    }
1896
1897    /* Process AAD if present */
1898    if (authIn != NULL && authInSz > 0) {
1899        status = Cy_Crypto_Core_Aes_GCM_AAD_Update(
1900            crypto_base, (uint8_t*)authIn, authInSz, &aes->aes_gcm_state);
1901        if (status != CY_CRYPTO_SUCCESS) {
1902            ret = WC_HW_E;
1903            goto cleanup;
1904        }
1905    }
1906
1907    /* Encrypt data if present */
1908    if (sz > 0) {
1909        status = Cy_Crypto_Core_Aes_GCM_Update(crypto_base, in, sz, out,
1910                                               &aes->aes_gcm_state);
1911        if (status != CY_CRYPTO_SUCCESS) {
1912            ret = WC_HW_E;
1913            goto cleanup;
1914        }
1915    }
1916
1917    /* Finalize and get tag */
1918    status = Cy_Crypto_Core_Aes_GCM_Finish(crypto_base, authTag, authTagSz,
1919                                           &aes->aes_gcm_state);
1920    if (status != CY_CRYPTO_SUCCESS) {
1921        ret = WC_HW_E;
1922        goto cleanup;
1923    }
1924
1925cleanup:
1926    if (aesInited) {
1927        wc_Psoc6_Aes_Free(aes);
1928    }
1929
1930    /* Release the lock */
1931    wolfSSL_CryptHwMutexUnLock();
1932    return ret;
1933}
1934
1935#if defined(HAVE_AES_DECRYPT) || defined(HAVE_AESGCM_DECRYPT)
1936/* Perform authenticated AES-GCM decryption using PSoC6 hardware.
1937 *
1938 * Decrypts ciphertext data and verifies the authentication tag using
1939 * AES-GCM (Galois/Counter Mode). The authentication tag is verified
1940 * before returning the plaintext to ensure data authenticity and integrity.
1941 *
1942 * aes        Pointer to initialized AES-GCM context (key must be set)
1943 * out        Pointer to output plaintext buffer (sz bytes, can be NULL if sz=0)
1944 * in         Pointer to input ciphertext buffer (sz bytes, can be NULL if sz=0)
1945 * sz         Size of ciphertext/plaintext data in bytes
1946 * iv         Pointer to initialization vector/nonce buffer (same as encryption)
1947 * ivSz       Size of IV in bytes (must match encryption)
1948 * authTag    Pointer to authentication tag from encryption (authTagSz bytes)
1949 * authTagSz  Size of authentication tag (must match encryption)
1950 * authIn     Pointer to additional authenticated data (AAD), can be NULL
1951 * authInSz   Size of AAD in bytes (must match encryption, 0 if no AAD)
1952 *
1953 * returns 0 on success and valid authentication, AES_GCM_AUTH_E for
1954 * authentication failure (tag mismatch), WC_HW_E for hardware errors, or mutex
1955 * error codes
1956 */
1957int wc_Psoc6_Aes_GcmDecrypt(Aes* aes, byte* out, const byte* in, word32 sz,
1958                            const byte* iv, word32 ivSz, const byte* authTag,
1959                            word32 authTagSz, const byte* authIn,
1960                            word32 authInSz)
1961{
1962    int ret = 0;
1963    cy_en_crypto_status_t status;
1964    cy_en_crypto_aes_key_length_t keyLength;
1965    byte computedTag[AES_BLOCK_SIZE];
1966    int aesInited = 0;
1967
1968    /* Lock the mutex to perform crypto operations */
1969    ret = wolfSSL_CryptHwMutexLock();
1970    if (ret != 0) {
1971        return ret;
1972    }
1973
1974    keyLength = psoc6_get_aes_key_length(aes->keylen);
1975
1976    /* Initialize AES GCM state */
1977    cy_stc_crypto_aes_gcm_buffers_t* aesBuffers =
1978        (cy_stc_crypto_aes_gcm_buffers_t*)((
1979            void*)Cy_Crypto_Core_GetVuMemoryAddress(crypto_base));
1980    status = Cy_Crypto_Core_Aes_GCM_Init(crypto_base, aesBuffers,
1981                                         &aes->aes_gcm_state);
1982    if (status != CY_CRYPTO_SUCCESS) {
1983        ret = WC_HW_E;
1984        goto cleanup;
1985    }
1986
1987    aesInited = 1;
1988
1989    /* Set the key */
1990    status = Cy_Crypto_Core_Aes_GCM_SetKey(crypto_base, (uint8_t*)aes->key,
1991                                           keyLength, &aes->aes_gcm_state);
1992    if (status != CY_CRYPTO_SUCCESS) {
1993        ret = WC_HW_E;
1994        goto cleanup;
1995    }
1996
1997    /* Start GCM operation */
1998    status = Cy_Crypto_Core_Aes_GCM_Start(crypto_base, CY_CRYPTO_DECRYPT, iv,
1999                                          ivSz, &aes->aes_gcm_state);
2000    if (status != CY_CRYPTO_SUCCESS) {
2001        ret = WC_HW_E;
2002        goto cleanup;
2003    }
2004
2005    /* Process AAD if present */
2006    if (authIn != NULL && authInSz > 0) {
2007        status = Cy_Crypto_Core_Aes_GCM_AAD_Update(
2008            crypto_base, (uint8_t*)authIn, authInSz, &aes->aes_gcm_state);
2009        if (status != CY_CRYPTO_SUCCESS) {
2010            ret = WC_HW_E;
2011            goto cleanup;
2012        }
2013    }
2014
2015    /* Decrypt data if present */
2016    if (sz > 0) {
2017        status = Cy_Crypto_Core_Aes_GCM_Update(crypto_base, in, sz, out,
2018                                               &aes->aes_gcm_state);
2019        if (status != CY_CRYPTO_SUCCESS) {
2020            ret = WC_HW_E;
2021            goto cleanup;
2022        }
2023    }
2024
2025    /* Finalize and get computed tag */
2026    status = Cy_Crypto_Core_Aes_GCM_Finish(crypto_base, computedTag, authTagSz,
2027                                           &aes->aes_gcm_state);
2028    if (status != CY_CRYPTO_SUCCESS) {
2029        ret = WC_HW_E;
2030        goto cleanup;
2031    }
2032
2033    /* Verify tag */
2034    if (ConstantCompare(computedTag, authTag, authTagSz) != 0) {
2035        ret = AES_GCM_AUTH_E;
2036        goto cleanup;
2037    }
2038
2039cleanup:
2040    if (aesInited) {
2041        wc_Psoc6_Aes_Free(aes);
2042    }
2043
2044    /* Release the lock */
2045    wolfSSL_CryptHwMutexUnLock();
2046    return ret;
2047}
2048#endif /* HAVE_AES_DECRYPT || HAVE_AESGCM_DECRYPT */
2049#endif /* HAVE_AESGCM */
2050#endif /* PSOC6_CRYPTO_AES */
2051
2052/* ECDSA */
2053#ifdef HAVE_ECC
2054
2055#define MAX_ECC_KEYSIZE 66 /* Supports up to secp521r1 */
2056static cy_en_crypto_ecc_curve_id_t psoc6_get_curve_id(int size)
2057{
2058    switch (size) {
2059        case 24:
2060            return CY_CRYPTO_ECC_ECP_SECP192R1;
2061        case 28:
2062            return CY_CRYPTO_ECC_ECP_SECP224R1;
2063        case 32:
2064            return CY_CRYPTO_ECC_ECP_SECP256R1;
2065        case 48:
2066            return CY_CRYPTO_ECC_ECP_SECP384R1;
2067        case 66:
2068            return CY_CRYPTO_ECC_ECP_SECP521R1;
2069        default:
2070            return CY_CRYPTO_ECC_ECP_NONE;
2071    }
2072}
2073
2074int psoc6_ecc_verify_hash_ex(MATH_INT_T* r, MATH_INT_T* s, const byte* hash,
2075                             word32 hashlen, int* verif_res,
2076                             struct ecc_key* key)
2077{
2078    uint8_t signature_buf[MAX_ECC_KEYSIZE * 2] = { 0 };
2079    cy_stc_crypto_ecc_key ecc_key;
2080    bool loadPublicKey = false;
2081    uint8_t stat       = 0;
2082    int res            = -1;
2083    int keySz;
2084    int rSz, sSz, qxSz, qySz;
2085    uint8_t x[MAX_ECC_KEYSIZE] = { 0 };
2086    uint8_t y[MAX_ECC_KEYSIZE] = { 0 };
2087    uint8_t k[MAX_ECC_KEYSIZE] = { 0 };
2088
2089    if (!key || !verif_res || !r || !s || !hash)
2090        return -BAD_FUNC_ARG;
2091
2092    /* Enable CRYPTO block if not enabled */
2093    if (!Cy_Crypto_Core_IsEnabled(crypto_base)) {
2094        Cy_Crypto_Core_Enable(crypto_base);
2095    }
2096
2097    keySz = wc_ecc_size(key);
2098    rSz   = mp_unsigned_bin_size(r);
2099    sSz   = mp_unsigned_bin_size(s);
2100
2101    if (keySz > MAX_ECC_KEYSIZE)
2102        return -BAD_FUNC_ARG;
2103
2104    /* Prepare ECC key */
2105    ecc_key.type     = PK_PUBLIC;
2106    ecc_key.curveID  = psoc6_get_curve_id(keySz);
2107    ecc_key.k        = NULL;
2108    ecc_key.pubkey.x = x;
2109    ecc_key.pubkey.y = y;
2110
2111    /* If the key is private only, generate the public key before */
2112    if (key->type == ECC_PRIVATEKEY_ONLY) {
2113        /* Get the private key as bytes */
2114        res = mp_to_unsigned_bin(ecc_get_k(key), k);
2115        if (res == MP_OKAY) {
2116            /* Convert the private key into little endian */
2117            Cy_Crypto_Core_InvertEndianness(k, keySz);
2118
2119            /* Make the public key from the private key */
2120            res = Cy_Crypto_Core_ECC_MakePublicKey(crypto_base, ecc_key.curveID,
2121                                                   k, &ecc_key);
2122
2123            /* Load the public key into the key structure. */
2124            if (res == CY_RSLT_SUCCESS) {
2125                loadPublicKey = true;
2126            }
2127        }
2128
2129        if (res != CY_RSLT_SUCCESS) {
2130            return WC_FAILURE;
2131        }
2132    }
2133    else {
2134        qxSz = mp_unsigned_bin_size(key->pubkey.x);
2135        qySz = mp_unsigned_bin_size(key->pubkey.y);
2136
2137        res = mp_to_unsigned_bin(key->pubkey.x, x);
2138        if (res == MP_OKAY) {
2139            res = mp_to_unsigned_bin(key->pubkey.y, y);
2140            if (res == MP_OKAY) {
2141                Cy_Crypto_Core_InvertEndianness(x, qxSz);
2142                Cy_Crypto_Core_InvertEndianness(y, qySz);
2143            }
2144        }
2145    }
2146
2147    /* Note: keySz is used for the offset of the s component in signature_buf
2148     * because the hardware expects r and s to be packed as [r (keySz bytes)][s
2149     * (keySz bytes)]. However, rSz and sSz are used for endianness conversion
2150     * since they represent the actual sizes of the r and s values as produced
2151     * by mp_to_unsigned_bin.
2152     */
2153    if (res == MP_OKAY) {
2154        /* Copy r component */
2155        res = mp_to_unsigned_bin(r, signature_buf);
2156        if (res == MP_OKAY) {
2157            /* Copy s component. */
2158            res = mp_to_unsigned_bin(s, signature_buf + keySz);
2159            if (res == MP_OKAY) {
2160                /* Convert to little endian */
2161                Cy_Crypto_Core_InvertEndianness(signature_buf, rSz);
2162                Cy_Crypto_Core_InvertEndianness(signature_buf + keySz, sSz);
2163            }
2164        }
2165    }
2166
2167    /* perform HW ECDSA */
2168    if (res == MP_OKAY) {
2169        res = Cy_Crypto_Core_ECC_VerifyHash(crypto_base, signature_buf, hash,
2170                                            hashlen, &stat, &ecc_key);
2171        if (res == CY_RSLT_SUCCESS) {
2172            *verif_res = stat;
2173
2174            if (loadPublicKey == true) {
2175                Cy_Crypto_Core_InvertEndianness(ecc_key.pubkey.x, keySz);
2176                Cy_Crypto_Core_InvertEndianness(ecc_key.pubkey.y, keySz);
2177                res = mp_read_unsigned_bin(key->pubkey.x, ecc_key.pubkey.x,
2178                                           keySz);
2179                if (res == MP_OKAY) {
2180                    res = mp_read_unsigned_bin(key->pubkey.y, ecc_key.pubkey.y,
2181                                               keySz);
2182                }
2183
2184                if (res == MP_OKAY) {
2185                    key->type = ECC_PRIVATEKEY;
2186                }
2187            }
2188        }
2189        else {
2190            res = WC_FAILURE;
2191        }
2192        return res;
2193    }
2194
2195    return WC_FAILURE;
2196}
2197#endif /* HAVE_ECC */
2198
2199#endif /* WOLFSSL_PSOC6_CRYPTO */