luna - wolfssl/wolfcrypt/src/port/Renesas/renesas_tsip

   1/* renesas_tsip_aes.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#include <string.h>
  23#include <stdio.h>
  24
  25#ifdef HAVE_CONFIG_H
  26    #include <config.h>
  27#endif
  28#include <wolfssl/wolfcrypt/settings.h>
  29#include <stdio.h>
  30
  31#ifndef NO_AES
  32
  33#if (defined(WOLFSSL_RENESAS_TSIP_TLS) || \
  34     defined(WOLFSSL_RENESAS_TSIP_CRYPTONLY)) && \
  35    !defined(NO_WOLFSSL_RENESAS_TSIP_CRYPT_AES)
  36
  37#include <wolfssl/wolfcrypt/wc_port.h>
  38#include <wolfssl/wolfcrypt/error-crypt.h>
  39#ifdef WOLFSSL_RENESAS_TSIP_TLS
  40#include <wolfssl/internal.h>
  41#endif
  42#include <wolfssl/wolfcrypt/aes.h>
  43#include "wolfssl/wolfcrypt/port/Renesas/renesas_tsip_internal.h"
  44#ifdef NO_INLINE
  45    #include <wolfssl/wolfcrypt/misc.h>
  46#else
  47    #define WOLFSSL_MISC_INCLUDED
  48    #include <wolfcrypt/src/misc.c>
  49#endif
  50
  51#define TSIP_AES_GCM_AUTH_TAG_SIZE  16
  52
  53typedef e_tsip_err_t (*aesGcmEncInitFn)
  54        (tsip_gcm_handle_t*, tsip_aes_key_index_t*, uint8_t*, uint32_t);
  55typedef e_tsip_err_t (*aesGcmEncUpdateFn)
  56        (tsip_gcm_handle_t*,uint8_t*, uint8_t*, uint32_t, uint8_t*, uint32_t);
  57typedef e_tsip_err_t (*aesGcmEncFinalFn)
  58        (tsip_gcm_handle_t*, uint8_t*, uint32_t*, uint8_t*);
  59typedef e_tsip_err_t (*aesGcmDecInitFn)
  60        (tsip_gcm_handle_t*, tsip_aes_key_index_t*, uint8_t*, uint32_t);
  61typedef e_tsip_err_t (*aesGcmDecUpdateFn)
  62        (tsip_gcm_handle_t*,uint8_t*, uint8_t*, uint32_t, uint8_t*, uint32_t);
  63typedef e_tsip_err_t (*aesGcmDecFinalFn)
  64        (tsip_gcm_handle_t*, uint8_t*, uint32_t*, uint8_t*, uint32_t);
  65
  66#ifdef WOLFSSL_RENESAS_TSIP_TLS
  67
  68/* function pointer type defs for TLSv13 handshake AES-GCM/CCM encryption */
  69typedef e_tsip_err_t (*Tls13AesEncInitFn)
  70        (tsip_tls13_handle_t*, e_tsip_tls13_phase_t, e_tsip_tls13_mode_t,
  71         e_tsip_tls13_cipher_suite_t, tsip_aes_key_index_t*, uint32_t);
  72typedef e_tsip_err_t (*Tls13AesEncUpdateFn)
  73        (tsip_tls13_handle_t*, uint8_t*, uint8_t*, uint32_t);
  74typedef e_tsip_err_t (*Tls13AesEncFinalFn)
  75        (tsip_tls13_handle_t*, uint8_t*, uint32_t*);
  76
  77/* function pointer type defs for TLSv13 handshake AES-GCM/CCM decryption */
  78typedef e_tsip_err_t (*Tls13AesDecInitFn)
  79        (tsip_tls13_handle_t*, e_tsip_tls13_phase_t, e_tsip_tls13_mode_t,
  80         e_tsip_tls13_cipher_suite_t, tsip_aes_key_index_t*, uint32_t);
  81typedef e_tsip_err_t (*Tls13AesDecUpdateFn)
  82        (tsip_tls13_handle_t*, uint8_t*, uint8_t*, uint32_t);
  83typedef e_tsip_err_t (*Tls13AesDecFinalFn)
  84        (tsip_tls13_handle_t*, uint8_t*, uint32_t*);
  85
  86
  87
  88
  89
  90/*  encrypt plain data.
  91 *
  92 *  return cipher data size on success, negative value on failure.
  93 *         CRYPTOCB_UNAVAILABLE may be returned.
  94 */
  95WOLFSSL_LOCAL int tsip_Tls13AesEncrypt(
  96                            struct WOLFSSL* ssl,
  97                            byte* output,
  98                            const byte* input,
  99                            word16 sz)
 100{
 101    int ret = 0;
 102    e_tsip_err_t    err = TSIP_SUCCESS;
 103    TsipUserCtx_Internal* tuc = NULL;
 104    e_tsip_tls13_cipher_suite_t cs;
 105    word32  cipher[(WC_AES_BLOCK_SIZE + TSIP_AES_GCM_AUTH_TAG_SIZE) /
 106                                                             sizeof(word32)];
 107    word32  plain[WC_AES_BLOCK_SIZE / sizeof(word32)];
 108    int             idxIn,idxOut;
 109    uint32_t        remain;
 110    uint32_t        dataSz, finalSz;
 111    e_tsip_tls13_phase_t phase;
 112    tsip_aes_key_index_t* key = NULL;
 113
 114    WOLFSSL_ENTER("tsip_Tls13AesEncrypt");
 115
 116    if ((ssl == NULL) || (input == NULL) || (output == NULL) || (sz == 0) ||
 117        (ssl->RenesasUserCtx == NULL)) {
 118        return BAD_FUNC_ARG;
 119    }
 120
 121    if (ssl->options.side != WOLFSSL_CLIENT_END) {
 122        return CRYPTOCB_UNAVAILABLE;   /* expecting to fallback to S/W */
 123    }
 124
 125    /* get user context for TSIP */
 126    tuc = (TsipUserCtx_Internal*)((TsipUserCtx*)ssl->RenesasUserCtx)->internal;
 127    if (tuc == NULL) {
 128        WOLFSSL_MSG("TsipUserCtx hasn't been set to ssl.");
 129        return CRYPTOCB_UNAVAILABLE;
 130    }
 131
 132    /* select the appropriate encryption key and phase */
 133    if (ssl->options.handShakeDone) {
 134        if (!tuc->ClientWriteTrafficKey_set) {
 135            WOLFSSL_MSG("TSIP wasn't involved in the key-exchange.");
 136            return CRYPTOCB_UNAVAILABLE;
 137        }
 138
 139        key = &(tuc->clientAppWriteKey13Idx);
 140        phase = TSIP_TLS13_PHASE_APPLICATION;
 141    }
 142    else {
 143        if (!tuc->HandshakeClientTrafficKey_set) {
 144            WOLFSSL_MSG("TSIP wasn't involved in the key-exchange.");
 145            return CRYPTOCB_UNAVAILABLE;
 146        }
 147
 148        key = &(tuc->clientWriteKey13Idx);
 149        phase = TSIP_TLS13_PHASE_HANDSHAKE;
 150    }
 151
 152    /* select AES mode */
 153    if (ssl->specs.bulk_cipher_algorithm == wolfssl_aes_gcm)
 154        cs = TSIP_TLS13_CIPHER_SUITE_AES_128_GCM_SHA256;
 155    else if (ssl->specs.bulk_cipher_algorithm == wolfssl_aes_ccm)
 156        cs = TSIP_TLS13_CIPHER_SUITE_AES_128_CCM_SHA256;
 157    else
 158        return CRYPTOCB_UNAVAILABLE;
 159
 160    remain  = sz;
 161    finalSz = 0;
 162
 163    if ((ret = tsip_hw_lock()) == 0) {
 164
 165        err = R_TSIP_Tls13EncryptInit(
 166                                    &(tuc->handle13),
 167                                    phase,
 168                                    TSIP_TLS13_MODE_FULL_HANDSHAKE,
 169                                    cs,
 170                                    key,
 171                                    sz);
 172
 173        if (err != TSIP_SUCCESS) {
 174            WOLFSSL_MSG("R_TSIP_Tls13DecryptUpdate error");
 175            ret = WC_HW_E;
 176        }
 177
 178        idxIn  = 0;
 179        idxOut = 0;
 180
 181        while (err == TSIP_SUCCESS && remain > 0) {
 182
 183            dataSz = min(remain, WC_AES_BLOCK_SIZE);
 184            ForceZero(plain, sizeof(plain));
 185            ForceZero(cipher, sizeof(cipher));
 186            XMEMCPY(plain, input + idxIn, dataSz);
 187
 188
 189            err = R_TSIP_Tls13EncryptUpdate(
 190                                    &(tuc->handle13),
 191                                    (uint8_t*)plain,
 192                                    (uint8_t*)cipher,
 193                                    dataSz);
 194
 195            if (err == TSIP_SUCCESS) {
 196                if (dataSz >= WC_AES_BLOCK_SIZE) {
 197                    XMEMCPY(output + idxOut, cipher, dataSz);
 198                    idxOut += dataSz;
 199                }
 200                idxIn  += dataSz;
 201                remain -= dataSz;
 202            }
 203            else {
 204                WOLFSSL_MSG("R_TSIP_Tls13DecryptUpdate error");
 205                ret = WC_HW_E;
 206            }
 207        }
 208
 209        if (err == TSIP_SUCCESS) {
 210
 211            ForceZero(cipher, sizeof(cipher));
 212            /* R_TSIP_Tls13EncryptFinal outputs encrypted content and auth-data
 213             * to the buffer.
 214             */
 215            err = R_TSIP_Tls13EncryptFinal(
 216                                    &(tuc->handle13),
 217                                    (uint8_t*)cipher,
 218                                    &finalSz);          /* total output size */
 219
 220            if (err == TSIP_SUCCESS) {
 221                XMEMCPY(output + idxOut, cipher, finalSz - idxOut);
 222                ret = finalSz;
 223            }
 224            else {
 225                WOLFSSL_MSG("R_TSIP_Tls13EncryptFinal error");
 226                ret = WC_HW_E;
 227            }
 228        }
 229        tsip_hw_unlock();
 230    }
 231
 232    WOLFSSL_LEAVE("tsip_Tls13AesEncrypt", ret);
 233    return ret;
 234}
 235
 236
 237
 238
 239/* decrypt encrypted handshake data for TLSv1.3
 240 * AES-GCM or AES-CCM can be used
 241 * return 0 on success, otherwise on error.
 242 */
 243WOLFSSL_LOCAL int tsip_Tls13AesDecrypt(
 244                            struct WOLFSSL* ssl,
 245                            byte* output,
 246                            const byte* input,
 247                            word16 sz)
 248{
 249    int ret = 0;
 250    e_tsip_err_t    err = TSIP_SUCCESS;
 251    TsipUserCtx_Internal* tuc = NULL;
 252    e_tsip_tls13_cipher_suite_t cs;
 253    word32          cipher[WC_AES_BLOCK_SIZE / sizeof(word32)];
 254    word32          plain[WC_AES_BLOCK_SIZE / sizeof(word32)];
 255    int             idxIn,idxOut;
 256    int             blocks;
 257    uint32_t        remain,conRemain;
 258    uint32_t        dataSz, finalSz;
 259    e_tsip_tls13_phase_t     phase;
 260    tsip_aes_key_index_t* key = NULL;
 261
 262    WOLFSSL_ENTER("tsip_Tls13AesDecrypt");
 263
 264    if ((ssl == NULL) || (input == NULL) || (output == NULL) ||
 265        (sz < TSIP_AES_GCM_AUTH_TAG_SIZE) || (ssl->RenesasUserCtx == NULL)) {
 266        return BAD_FUNC_ARG;
 267    }
 268
 269    if (ssl->options.side != WOLFSSL_CLIENT_END) {
 270        return CRYPTOCB_UNAVAILABLE;   /* expecting to fallback to S/W */
 271    }
 272
 273    /* get user context for TSIP */
 274    tuc = (TsipUserCtx_Internal*)
 275            ((TsipUserCtx*)(ssl->RenesasUserCtx))->internal;
 276    if (tuc == NULL) {
 277        WOLFSSL_MSG("TsipUserCtx hasn't been set to ssl.");
 278        return CRYPTOCB_UNAVAILABLE;
 279    }
 280
 281    /* select the appropriate encryption key and phase */
 282    if (ssl->options.handShakeDone) {
 283        if (!tuc->ServerWriteTrafficKey_set) {
 284            WOLFSSL_MSG("TSIP wasn't involved in the key-exchange.");
 285            return CRYPTOCB_UNAVAILABLE;
 286        }
 287
 288        key = &(tuc->serverAppWriteKey13Idx);
 289        phase = TSIP_TLS13_PHASE_APPLICATION;
 290    }
 291    else {
 292        if (!tuc->HandshakeServerTrafficKey_set) {
 293            WOLFSSL_MSG("TSIP wasn't involved in the key-exchange.");
 294            return CRYPTOCB_UNAVAILABLE;
 295        }
 296
 297        key = &(tuc->serverWriteKey13Idx);
 298        phase = TSIP_TLS13_PHASE_HANDSHAKE;
 299    }
 300
 301    /* select AES mode */
 302    if (ssl->specs.bulk_cipher_algorithm == wolfssl_aes_gcm)
 303        cs = TSIP_TLS13_CIPHER_SUITE_AES_128_GCM_SHA256;
 304    else if (ssl->specs.bulk_cipher_algorithm == wolfssl_aes_ccm)
 305        cs = TSIP_TLS13_CIPHER_SUITE_AES_128_CCM_SHA256;
 306    else
 307        return CRYPTOCB_UNAVAILABLE;
 308
 309
 310    blocks    = sz / WC_AES_BLOCK_SIZE;
 311    remain    = sz;
 312    conRemain = sz - TSIP_AES_GCM_AUTH_TAG_SIZE;
 313
 314    if ((ret = tsip_hw_lock()) == 0) {
 315
 316        err = R_TSIP_Tls13DecryptInit(
 317                                    &(tuc->handle13),
 318                                    phase,
 319                                    TSIP_TLS13_MODE_FULL_HANDSHAKE,
 320                                    cs,
 321                                    key,
 322                                    sz);
 323
 324        if (err != TSIP_SUCCESS) {
 325            WOLFSSL_MSG("R_TSIP_Tls13DecryptInit error");
 326            ret = WC_HW_E;
 327        }
 328
 329        idxIn  = 0;
 330        idxOut = 0;
 331
 332        while (err == TSIP_SUCCESS && (blocks--) >= 0) {
 333
 334            dataSz = min(remain, WC_AES_BLOCK_SIZE);
 335            XMEMCPY(cipher, input + idxIn, dataSz);
 336            ForceZero(plain, WC_AES_BLOCK_SIZE);
 337
 338            err = R_TSIP_Tls13DecryptUpdate(
 339                                    &(tuc->handle13),
 340                                    (uint8_t*)cipher,
 341                                    (uint8_t*)plain,
 342                                    dataSz);
 343
 344            if (err == TSIP_SUCCESS) {
 345                if (dataSz >= WC_AES_BLOCK_SIZE && conRemain >= WC_AES_BLOCK_SIZE) {
 346                    XMEMCPY(output + idxOut, plain, dataSz);
 347                    idxOut += dataSz;
 348                    conRemain -= min(conRemain, dataSz);
 349                }
 350                idxIn  += dataSz;
 351                remain -= dataSz;
 352            }
 353            else {
 354                WOLFSSL_MSG("R_TSIP_Tls13DecryptUpdate error");
 355                ret = WC_HW_E;
 356            }
 357        }
 358
 359        if (err == TSIP_SUCCESS) {
 360            err = R_TSIP_Tls13DecryptFinal(
 361                                    &(tuc->handle13),
 362                                    (uint8_t*)plain,
 363                                    &finalSz); /* total size will be returned */
 364
 365            if (err == TSIP_SUCCESS) {
 366                XMEMCPY(output + idxOut, plain, conRemain);
 367            }
 368            else if (err== TSIP_ERR_AUTHENTICATION) {
 369                WOLFSSL_MSG("tsip_Tls13AesDecrypt authentication error");
 370                ret = AES_GCM_AUTH_E;
 371            }
 372            else {
 373                WOLFSSL_MSG("R_TSIP_Tls13DecryptFinal error");
 374                ret = WC_HW_E;
 375            }
 376        }
 377        tsip_hw_unlock();
 378    }
 379
 380    WOLFSSL_LEAVE("tsip_Tls13AesDecrypt", ret);
 381    return ret;
 382}
 383#endif /* WOLFSSL_RENESAS_TSIP_TLS */
 384
 385
 386#if (WOLFSSL_RENESAS_TSIP_VER >= 109)
 387#ifdef WOLF_CRYPTO_CB
 388
 389static int _tsip_cpAesKeyIndex2AesCtx(wc_CryptoInfo* info, TsipUserCtx* cb)
 390{
 391    Aes* aes = NULL;
 392
 393    if (!info || !cb)
 394        return -1;
 395
 396    switch(info->cipher.type) {
 397    #ifdef HAVE_AESGCM
 398        case WC_CIPHER_AES_GCM:
 399            if (info->cipher.enc)
 400                aes = info->cipher.aesgcm_enc.aes;
 401            else
 402                aes = info->cipher.aesgcm_dec.aes;
 403            break;
 404    #endif
 405    #ifdef HAVE_AES_CBC
 406        case WC_CIPHER_AES_CBC:
 407            aes = info->cipher.aescbc.aes;
 408            break;
 409    #endif
 410    #ifdef WOLFSSL_AES_COUNTER
 411        case WC_CIPHER_AES_CTR:
 412            aes = info->cipher.aesctr.aes;
 413            break;
 414    #endif
 415        default:
 416            break;
 417    }
 418
 419    if (aes && cb->user_aes256_key_set == 1) {
 420        XMEMCPY(&aes->ctx.tsip_keyIdx, &cb->user_aes256_key_index,
 421                    sizeof(tsip_aes_key_index_t));
 422            aes->ctx.keySize = 32;
 423    }else if (aes && cb->user_aes128_key_set == 1) {
 424        XMEMCPY(&aes->ctx.tsip_keyIdx, &cb->user_aes128_key_index,
 425                    sizeof(tsip_aes_key_index_t));
 426        aes->ctx.keySize = 16;
 427    } else
 428        return -1;
 429
 430    return 0;
 431}
 432
 433int wc_tsip_AesCipher(int devIdArg, wc_CryptoInfo* info, void* ctx)
 434{
 435    int ret = WC_NO_ERR_TRACE(NOT_COMPILED_IN);
 436    TsipUserCtx* cbInfo = (TsipUserCtx*)ctx;
 437
 438    WOLFSSL_ENTER("wc_tsip_AesCipher");
 439
 440    if (info == NULL) {
 441        return BAD_FUNC_ARG;
 442    }
 443
 444    (void)devIdArg;
 445    (void)_tsip_cpAesKeyIndex2AesCtx;
 446    if (info->algo_type == WC_ALGO_TYPE_CIPHER) {
 447#if !defined(NO_AES)
 448#ifdef HAVE_AESGCM
 449        if (info->cipher.type == WC_CIPHER_AES_GCM
 450        #ifdef WOLFSSL_RENESAS_TSIP_TLS
 451            && cbInfo != NULL &&
 452                        cbInfo->internal->session_key_set == 1
 453        #endif
 454            ) {
 455            /* prioritize TLS Session Key than User TSIP Aes Key */
 456            /* TODO : identify if Aes API is called through      */
 457            /* while doing TLS handshake or Crypt API            */
 458        #ifdef WOLFSSL_RENESAS_TSIP_TLS
 459            if (cbInfo->internal->session_key_set == 1)
 460                ret = 0;
 461            else
 462        #else
 463                ret = _tsip_cpAesKeyIndex2AesCtx(info, cbInfo);
 464        #endif
 465            if (ret != 0) {
 466                WOLFSSL_MSG("Failed to copy Aes Key Index from "
 467                            "UserCtx to AES Ctx");
 468                return ret;
 469            }
 470            if (info->cipher.enc) {
 471                ret = wc_tsip_AesGcmEncrypt(
 472                        info->cipher.aesgcm_enc.aes,
 473                        (byte*)info->cipher.aesgcm_enc.out,
 474                        (byte*)info->cipher.aesgcm_enc.in,
 475                        info->cipher.aesgcm_enc.sz,
 476                        (byte*)info->cipher.aesgcm_enc.iv,
 477                        info->cipher.aesgcm_enc.ivSz,
 478                        (byte*)info->cipher.aesgcm_enc.authTag,
 479                        info->cipher.aesgcm_enc.authTagSz,
 480                        (byte*)info->cipher.aesgcm_enc.authIn,
 481                        info->cipher.aesgcm_enc.authInSz,
 482                        (void*)ctx);
 483
 484            }
 485            else {
 486                ret = wc_tsip_AesGcmDecrypt(
 487                        info->cipher.aesgcm_dec.aes,
 488                        (byte*)info->cipher.aesgcm_dec.out,
 489                        (byte*)info->cipher.aesgcm_dec.in,
 490                        info->cipher.aesgcm_dec.sz,
 491                        (byte*)info->cipher.aesgcm_dec.iv,
 492                        info->cipher.aesgcm_dec.ivSz,
 493                        (byte*)info->cipher.aesgcm_dec.authTag,
 494                        info->cipher.aesgcm_dec.authTagSz,
 495                        (byte*)info->cipher.aesgcm_dec.authIn,
 496                        info->cipher.aesgcm_dec.authInSz,
 497                        (void*)ctx);
 498            }
 499        }
 500    #endif /* HAVE_AESGCM */
 501
 502    #ifdef WOLFSSL_AES_COUNTER
 503        if (info->cipher.type == WC_CIPHER_AES_CTR
 504        #ifdef WOLFSSL_RENESAS_TSIP_TLS
 505            && cbInfo != NULL && cbInfo->internal->session_key_set == 1
 506        #endif
 507            ) {
 508            int remain = (int)(info->cipher.aesctr.sz % WC_AES_BLOCK_SIZE);
 509            if (remain == 0) {
 510            #ifdef WOLFSSL_RENESAS_TSIP_TLS
 511                if (cbInfo->internal->session_key_set == 1)
 512                    ret = 0;
 513                else
 514            #else
 515                    ret = _tsip_cpAesKeyIndex2AesCtx(info, cbInfo);
 516            #endif
 517                if (ret != 0) {
 518                    WOLFSSL_MSG("Failed to copy Aes Key Index from "
 519                                "UserCtx to AES Ctx");
 520                    return ret;
 521                }
 522                /* encrypt and decrypt use same routine */
 523                ret = wc_tsip_AesCtr(
 524                    info->cipher.aesctr.aes,
 525                    (byte*)info->cipher.aesctr.out,
 526                    (byte*)info->cipher.aesctr.in,
 527                    info->cipher.aesctr.sz);
 528            }
 529        }
 530    #endif /* WOLFSSL_AES_COUNTER */
 531
 532    #ifdef HAVE_AES_CBC
 533        if (info->cipher.type == WC_CIPHER_AES_CBC
 534        #ifdef WOLFSSL_RENESAS_TSIP_TLS
 535            && cbInfo != NULL && cbInfo->internal->session_key_set == 1
 536        #endif
 537            ) {
 538        #ifdef WOLFSSL_RENESAS_TSIP_TLS
 539            if (cbInfo->internal->session_key_set == 1)
 540                ret = 0;
 541            else
 542        #else
 543                ret = _tsip_cpAesKeyIndex2AesCtx(info, cbInfo);
 544        #endif
 545            if (ret != 0) {
 546                WOLFSSL_MSG("Failed to copy Aes Key Index from "
 547                            "UserCtx to AES Ctx");
 548                return ret;
 549            }
 550            if (info->cipher.enc) {
 551                ret = wc_tsip_AesCbcEncrypt(
 552                    info->cipher.aescbc.aes,
 553                    (byte*)info->cipher.aescbc.out,
 554                    (byte*)info->cipher.aescbc.in,
 555                    info->cipher.aescbc.sz);
 556
 557            }
 558            else {
 559                ret = wc_tsip_AesCbcDecrypt(
 560                    info->cipher.aescbc.aes,
 561                    (byte*)info->cipher.aescbc.out,
 562                    (byte*)info->cipher.aescbc.in,
 563                    info->cipher.aescbc.sz);
 564            }
 565        }
 566    #endif /* HAVE_AES_CBC */
 567    #endif /* !NO_AES */
 568
 569    }
 570    (void)cbInfo;
 571    WOLFSSL_LEAVE("wc_tsip_AesCipher", ret);
 572    return ret;
 573}
 574#endif /* WOLF_CRYPTO_CB */
 575#endif /* WOLFSSL_RENESAS_TSIP_VER >= 109 */
 576
 577#ifdef HAVE_AES_CBC
 578int wc_tsip_AesCbcEncrypt(struct Aes* aes, byte* out, const byte* in, word32 sz)
 579{
 580    tsip_aes_handle_t _handle;
 581    int ret;
 582    word32 blocks = (sz / WC_AES_BLOCK_SIZE);
 583    uint32_t dataLength;
 584    byte *iv;
 585
 586    if ((in == NULL) || (out == NULL) || (aes == NULL))
 587      return BAD_FUNC_ARG;
 588
 589    /* while doing TLS handshake, TSIP driver keeps true-key and iv *
 590     * on the device. iv is dummy                                   */
 591    iv = (uint8_t*)aes->reg;
 592
 593    if ((ret = tsip_hw_lock()) != 0) {
 594        WOLFSSL_MSG("Failed to lock");
 595        return ret;
 596    }
 597
 598    if (aes->ctx.keySize == 16) {
 599        ret = R_TSIP_Aes128CbcEncryptInit(&_handle, &aes->ctx.tsip_keyIdx, iv);
 600    }
 601    else if (aes->ctx.keySize == 32) {
 602        ret = R_TSIP_Aes256CbcEncryptInit(&_handle, &aes->ctx.tsip_keyIdx, iv);
 603    }
 604    else {
 605        tsip_hw_unlock();
 606        return -1;
 607    }
 608
 609    while (ret == TSIP_SUCCESS && blocks--) {
 610        if (aes->ctx.keySize == 16)
 611            ret = R_TSIP_Aes128CbcEncryptUpdate(&_handle, (uint8_t*)in,
 612                                    (uint8_t*)out, (uint32_t)WC_AES_BLOCK_SIZE);
 613        else
 614            ret = R_TSIP_Aes256CbcEncryptUpdate(&_handle, (uint8_t*)in,
 615                                    (uint8_t*)out, (uint32_t)WC_AES_BLOCK_SIZE);
 616
 617        in  += WC_AES_BLOCK_SIZE;
 618        out += WC_AES_BLOCK_SIZE;
 619    }
 620
 621    if (ret == TSIP_SUCCESS) {
 622        if (aes->ctx.keySize == 16) {
 623            ret = R_TSIP_Aes128CbcEncryptFinal(&_handle, out, &dataLength);
 624        }
 625        else {
 626            ret = R_TSIP_Aes256CbcEncryptFinal(&_handle, out, &dataLength);
 627        }
 628    }
 629    else {
 630        WOLFSSL_MSG("TSIP AES CBC encryption failed");
 631        ret = -1;
 632    }
 633
 634    tsip_hw_unlock();
 635    return ret;
 636}
 637
 638int wc_tsip_AesCbcDecrypt(struct Aes* aes, byte* out, const byte* in, word32 sz)
 639{
 640   tsip_aes_handle_t _handle;
 641    int ret;
 642    word32 blocks = (sz / WC_AES_BLOCK_SIZE);
 643    uint32_t dataLength;
 644    byte *iv;
 645
 646    if ((in == NULL) || (out == NULL) || (aes == NULL))
 647      return BAD_FUNC_ARG;
 648
 649    iv = (uint8_t*)aes->reg;
 650
 651    if ((ret = tsip_hw_lock()) != 0) {
 652        WOLFSSL_MSG("Failed to lock");
 653        return ret;
 654    }
 655
 656    if (aes->ctx.keySize == 16) {
 657        ret = R_TSIP_Aes128CbcDecryptInit(&_handle, &aes->ctx.tsip_keyIdx, iv);
 658    }
 659    else if (aes->ctx.keySize == 32) {
 660        ret = R_TSIP_Aes256CbcDecryptInit(&_handle, &aes->ctx.tsip_keyIdx, iv);
 661    }
 662    else {
 663        tsip_hw_unlock();
 664        return -1;
 665    }
 666
 667    while (ret == TSIP_SUCCESS && blocks--) {
 668
 669        if (aes->ctx.keySize == 16)
 670            ret = R_TSIP_Aes128CbcDecryptUpdate(&_handle, (uint8_t*)in,
 671                                        (uint8_t*)out, (uint32_t)WC_AES_BLOCK_SIZE);
 672        else
 673            ret = R_TSIP_Aes256CbcDecryptUpdate(&_handle, (uint8_t*)in,
 674                                        (uint8_t*)out, (uint32_t)WC_AES_BLOCK_SIZE);
 675
 676        in  += WC_AES_BLOCK_SIZE;
 677        out += WC_AES_BLOCK_SIZE;
 678    }
 679
 680    if (ret == TSIP_SUCCESS) {
 681        if (aes->ctx.keySize == 16)
 682            ret = R_TSIP_Aes128CbcDecryptFinal(&_handle, out, &dataLength);
 683        else
 684            ret = R_TSIP_Aes256CbcDecryptFinal(&_handle, out, &dataLength);
 685    }
 686    else {
 687        WOLFSSL_MSG("TSIP AES CBC decryption failed");
 688        ret = -1;
 689    }
 690
 691    tsip_hw_unlock();
 692    return ret;
 693}
 694#endif /* HAVE_AES_CBC */
 695
 696#ifdef WOLFSSL_AES_COUNTER
 697/* API only supports even blocks (16 byte) */
 698/* Use the public wc_AesCtrEncrypt with crypto callbacks to handle odd remain */
 699int wc_tsip_AesCtr(struct Aes* aes, byte* out, const byte* in, word32 sz)
 700{
 701    tsip_aes_handle_t _handle;
 702    int ret;
 703    int blocks = (int)(sz / WC_AES_BLOCK_SIZE);
 704    int remain = (int)(sz % WC_AES_BLOCK_SIZE);
 705    byte *iv;
 706
 707    if (aes == NULL || in == NULL || out == NULL || sz == 0 || remain != 0) {
 708        return BAD_FUNC_ARG;
 709    }
 710
 711    if ((ret = tsip_hw_lock()) != 0) {
 712        WOLFSSL_MSG("Failed to lock");
 713        return ret;
 714    }
 715
 716    /* while doing TLS handshake, TSIP driver keeps true-key and iv *
 717     * on the device. iv is dummy                                   */
 718    iv = (uint8_t*)aes->reg;
 719
 720    if (aes->ctx.keySize == 16) {
 721    #if defined(TSIP_AES_128_CTR) && TSIP_AES_128_CTR == 1
 722        ret = R_TSIP_Aes128CtrInit(&_handle, &aes->ctx.tsip_keyIdx, iv);
 723        if (ret == TSIP_SUCCESS) {
 724            ret = R_TSIP_Aes128CtrUpdate(&_handle, (uint8_t*)in,
 725                (uint8_t*)out, blocks * WC_AES_BLOCK_SIZE);
 726            if (ret == TSIP_SUCCESS) {
 727                ret = R_TSIP_Aes128CtrFinal(&_handle);
 728            }
 729        }
 730    #else
 731        ret = NOT_COMPILED_IN;
 732    #endif
 733    }
 734    if (aes->ctx.keySize == 32) {
 735    #if defined(TSIP_AES_256_CTR) && TSIP_AES_256_CTR == 1
 736        ret = R_TSIP_Aes256CtrInit(&_handle, &aes->ctx.tsip_keyIdx, iv);
 737        if (ret == TSIP_SUCCESS) {
 738            ret = R_TSIP_Aes256CtrUpdate(&_handle, (uint8_t*)in,
 739                (uint8_t*)out, blocks * WC_AES_BLOCK_SIZE);
 740            if (ret == TSIP_SUCCESS) {
 741                ret = R_TSIP_Aes256CtrFinal(&_handle);
 742            }
 743        }
 744    #else
 745        ret = NOT_COMPILED_IN;
 746    #endif
 747    }
 748
 749    if (ret == TSIP_SUCCESS) {
 750        /* increment IV counter */
 751        while (blocks--) {
 752            /* in network byte order so start at end and work back */
 753            int i;
 754            for (i = WC_AES_BLOCK_SIZE - 1; i >= 0; i--) {
 755                if (++iv[i]) /* we're done unless we overflow */
 756                    break;
 757            }
 758        }
 759    }
 760    else {
 761        WOLFSSL_ERROR(ret);
 762        WOLFSSL_MSG("TSIP AES CTR failed");
 763        ret = -1;
 764    }
 765
 766    tsip_hw_unlock();
 767
 768    return ret;
 769}
 770#endif /* WOLFSSL_AES_COUNTER */
 771
 772#ifdef HAVE_AESGCM
 773/*
 774 * Encrypt plain data then output encrypted data and authentication tag data.
 775 * The session key used for encryption is generated inside this function and
 776 * the key which has been generated and stored in Aes is not used.
 777 * parameter
 778 *  - aes:  Aes structure
 779 *  - out:  buffer where the cipher text is output
 780 *  - in:   buffer where the plain data is storead
 781 *  - sz:   size of plain data and also means output size
 782 *  - iv:   iv should be consist of implicit-iv of 4 bytes and exp-iv of 8 bytes
 783 *  - authTag: buffer where the authentication data is output.
 784 *  - authTagSz: buffer size for authentication data.
 785 *  - authIn: buffer holding Additional Authentication Data(AAD)
 786 *  - authInSz: AAD size
 787 *  - ctx:   TsipUserCtx
 788 * return 0 on success, otherwise on error.
 789 * Note: As of TSIPv1.13, only accept 128 and 256 bit of key size
 790 *
 791 */
 792int wc_tsip_AesGcmEncrypt(
 793    struct Aes*  aes,     byte* out,
 794    const  byte* in,       word32 sz,
 795           byte* iv,       word32 ivSz,
 796           byte* authTag,  word32 authTagSz, /* auth Tag */
 797    const  byte* authIn,   word32 authInSz,  /* AAD */
 798           void* ctx)
 799{
 800    int                 ret = -1;
 801    e_tsip_err_t        err;
 802    tsip_gcm_handle_t   hdl;
 803    uint32_t            dataLen = sz;
 804    uint32_t            cipherBufSz;
 805
 806    aesGcmEncInitFn     initFn;
 807    aesGcmEncUpdateFn   updateFn;
 808    aesGcmEncFinalFn    finalFn;
 809
 810    uint8_t* plainBuf  = NULL;
 811    uint8_t* cipherBuf = NULL;
 812    uint8_t* aTagBuf   = NULL;
 813    uint8_t* aadBuf    = NULL;
 814    const uint8_t* iv_l = NULL;
 815    uint32_t ivSz_l = 0;
 816
 817    tsip_aes_key_index_t key_client_aes;
 818    TsipUserCtx* userCtx;
 819
 820    WOLFSSL_ENTER("wc_tsip_AesGcmEncrypt");
 821
 822    if (aes == NULL || ctx == NULL || (ivSz == 0)   ||
 823       (sz != 0       && (in == NULL  || out == NULL)) ||
 824       (ivSz != 0     &&  iv == NULL) ||
 825       (authInSz != 0 && authIn == NULL)) {
 826        WOLFSSL_LEAVE("wc_tsip_AesGcmEncrypt", BAD_FUNC_ARG);
 827        return BAD_FUNC_ARG;
 828    }
 829    /* TSIP can handle 128 and 256 bit key only */
 830    if (aes->ctx.keySize != 16 && aes->ctx.keySize != 32) {
 831        WOLFSSL_MSG("illegal key size");
 832        WOLFSSL_LEAVE("wc_tsip_AesGcmEncrypt", BAD_FUNC_ARG);
 833        return BAD_FUNC_ARG;
 834    }
 835
 836    if (aes->ctx.keySize == 16) {
 837        initFn   = R_TSIP_Aes128GcmEncryptInit;
 838        updateFn = R_TSIP_Aes128GcmEncryptUpdate;
 839        finalFn  = R_TSIP_Aes128GcmEncryptFinal;
 840    }
 841    else {
 842        initFn   = R_TSIP_Aes256GcmEncryptInit;
 843        updateFn = R_TSIP_Aes256GcmEncryptUpdate;
 844        finalFn  = R_TSIP_Aes256GcmEncryptFinal;
 845    }
 846
 847    userCtx = ((TsipUserCtx*)ctx);
 848
 849    /* buffer for cipher data output must be multiple of WC_AES_BLOCK_SIZE */
 850    cipherBufSz = ((sz / WC_AES_BLOCK_SIZE) + 1) * WC_AES_BLOCK_SIZE;
 851
 852    if ((ret = tsip_hw_lock()) == 0) {
 853
 854        /* allocate buffers for plaintext, ciphertext, authTag and aad to make
 855         * sure those buffers 32bit aligned as TSIP requests.
 856         */
 857        plainBuf  = XMALLOC(sz, aes->heap, DYNAMIC_TYPE_AES);
 858        cipherBuf = XMALLOC(cipherBufSz, aes->heap, DYNAMIC_TYPE_AES);
 859        aTagBuf   = XMALLOC(TSIP_AES_GCM_AUTH_TAG_SIZE, aes->heap,
 860                                                        DYNAMIC_TYPE_AES);
 861        aadBuf    = XMALLOC(authInSz, aes->heap, DYNAMIC_TYPE_AES);
 862
 863        if (plainBuf == NULL || cipherBuf == NULL || aTagBuf == NULL ||
 864                                                      aadBuf == NULL ) {
 865            WOLFSSL_MSG("wc_tsip_AesGcmEncrypt: buffer allocation failed");
 866            ret = -1;
 867        }
 868
 869        if (ret == 0) {
 870            XMEMCPY(plainBuf, in, sz);
 871            ForceZero(cipherBuf, cipherBufSz);
 872            ForceZero(authTag, authTagSz);
 873            XMEMCPY(aadBuf, authIn, authInSz);
 874        }
 875
 876    #if defined(WOLFSSL_RENESAS_TSIP_TLS)
 877        if (ret == 0 &&
 878            userCtx->internal->session_key_set == 1) {
 879            /* generate AES-GCM session key. The key stored in
 880             * Aes.ctx.tsip_keyIdx is not used here.
 881             */
 882            err = R_TSIP_TlsGenerateSessionKey(
 883                    userCtx->internal->tsip_cipher,
 884                    (uint32_t*)userCtx->internal->tsip_masterSecret,
 885                    (uint8_t*) userCtx->internal->tsip_clientRandom,
 886                    (uint8_t*) userCtx->internal->tsip_serverRandom,
 887                    &iv[AESGCM_IMP_IV_SZ], /* use exp_IV */
 888                    NULL,
 889                    NULL,
 890                    &key_client_aes,
 891                    NULL,
 892                    NULL, NULL);
 893            if (err != TSIP_SUCCESS) {
 894
 895                WOLFSSL_MSG("R_TSIP_TlsGenerateSessionKey failed");
 896                ret = -1;
 897            }
 898        } else
 899    #endif
 900        if (ret == 0 &&
 901            (userCtx->user_aes128_key_set == 1 ||
 902             userCtx->user_aes256_key_set == 1)) {
 903            if (aes->ctx.keySize == 32) {
 904                XMEMCPY(&key_client_aes, &userCtx->user_aes256_key_index,
 905                        sizeof(tsip_aes_key_index_t));
 906            }
 907            else {
 908                 XMEMCPY(&key_client_aes, &userCtx->user_aes128_key_index,
 909                        sizeof(tsip_aes_key_index_t));
 910            }
 911
 912            iv_l = iv;
 913            ivSz_l = ivSz;
 914
 915        }
 916
 917        if (ret == 0) {
 918
 919            /* Since generated session key is coupled to iv, no need to pass
 920             * iv init func.
 921             * It expects to pass iv when users create their own key.
 922             */
 923            err = initFn(&hdl, &key_client_aes, (uint8_t*)iv_l, ivSz_l);
 924
 925            if (err == TSIP_SUCCESS) {
 926                err = updateFn(&hdl, NULL, NULL, 0UL, (uint8_t*)aadBuf, authInSz);
 927            }
 928            if (err == TSIP_SUCCESS) {
 929                err = updateFn(&hdl, plainBuf, cipherBuf, sz, NULL, 0UL);
 930            }
 931            if (err != TSIP_SUCCESS) {
 932                WOLFSSL_MSG("R_TSIP_AesXXXGcmEncryptUpdate: failed");
 933                ret = -1;
 934            }
 935
 936            /* Once R_TSIP_AesxxxGcmEncryptInit or R_TSIP_AesxxxEncryptUpdate is
 937            * called, R_TSIP_AesxxxGcmEncryptFinal must be called regardless of
 938            * the result of the previous call. Otherwise, TSIP can not come out
 939            * from its error state and all the trailing APIs will fail.
 940            */
 941            dataLen = 0;
 942            err = finalFn(&hdl,
 943                          cipherBuf + (sz / WC_AES_BLOCK_SIZE) * WC_AES_BLOCK_SIZE,
 944                          &dataLen,
 945                          aTagBuf); /* aad of 16 bytes will be output */
 946
 947            if (err == TSIP_SUCCESS) {
 948                /* copy encrypted data to out */
 949                XMEMCPY(out, cipherBuf, sz);
 950
 951                /* copy auth tag to caller's buffer */
 952                XMEMCPY((void*)authTag, (void*)aTagBuf,
 953                                min(authTagSz, TSIP_AES_GCM_AUTH_TAG_SIZE ));
 954
 955            }
 956            else {
 957                WOLFSSL_MSG("R_TSIP_AesxxxGcmEncryptFinal: failed");
 958                ret = -1;
 959            }
 960        }
 961
 962        XFREE(plainBuf,  aes->heap, DYNAMIC_TYPE_AES);
 963        XFREE(cipherBuf, aes->heap, DYNAMIC_TYPE_AES);
 964        XFREE(aTagBuf,   aes->heap, DYNAMIC_TYPE_AES);
 965        XFREE(aadBuf,    aes->heap, DYNAMIC_TYPE_AES);
 966
 967        tsip_hw_unlock();
 968    }
 969    return ret;
 970}
 971/*
 972 * Decrypt cipher data into plaindata and output authentication tag data.
 973 * The session key used for decryption is generated inside this function and
 974 * the key which has been generated and stored in Aes is not used.
 975 * parameter
 976 *  - aes:  Aes structure
 977 *  - out:  buffer where the plain text is output
 978 *  - in:   buffer where the cipher data is storead
 979 *  - sz:   size of cipher data and also means output size
 980 *  - iv:   iv should be consist of implicit-iv of 4 bytes and exp-iv of 8 bytes
 981 *  - authTag: buffer where the authentication data is stored.
 982 *  - authTagSz: buffer size for authentication data.
 983 *  - authIn: buffer where Additional Authentication Data(AAD) is stored
 984 *  - authInSz: AAD size
 985 * return 0 on success, otherwise on error.
 986 * Note: As of TSIPv1.13, only accept 128 and 256 bit of key size
 987 *
 988 */
 989int wc_tsip_AesGcmDecrypt(
 990    Aes*        aes,      byte* out,
 991    const byte* in,       word32 sz,
 992    const byte* iv,       word32 ivSz,
 993    const byte* authTag,  word32 authTagSz,
 994    const byte* authIn,   word32 authInSz,
 995          void* ctx)
 996{
 997    int                 ret = -1;
 998    e_tsip_err_t        err;
 999    tsip_gcm_handle_t   hdl;
1000
1001    uint32_t            dataLen;
1002    uint32_t            plainBufSz;
1003
1004    aesGcmDecInitFn     initFn;
1005    aesGcmDecUpdateFn   updateFn;
1006    aesGcmDecFinalFn    finalFn;
1007
1008    uint8_t* cipherBuf = NULL;
1009    uint8_t* plainBuf  = NULL;
1010    uint8_t* aTagBuf   = NULL;
1011    uint8_t* aadBuf    = NULL;
1012    const uint8_t* iv_l = NULL;
1013    uint32_t ivSz_l = 0;
1014
1015    tsip_aes_key_index_t key_server_aes;
1016    TsipUserCtx* userCtx;
1017
1018    WOLFSSL_ENTER("wc_tsip_AesGcmDecrypt");
1019
1020    if (aes == NULL || in == NULL || out == NULL || sz == 0 || ctx == NULL ||
1021        iv == 0 ||
1022        (authInSz != 0 && authIn == NULL) ||
1023        (authInSz == 0 && authIn != NULL) ||
1024        (authTagSz != 0 && authTag == NULL) ||
1025        (authTagSz == 0 && authTag != NULL)) {
1026        WOLFSSL_LEAVE("wc_tsip_AesGcmDecrypt", BAD_FUNC_ARG);
1027        return BAD_FUNC_ARG;
1028    }
1029    if (aes->ctx.keySize != 16 && aes->ctx.keySize != 32) {
1030        WOLFSSL_MSG("illegal key size");
1031        WOLFSSL_LEAVE("wc_tsip_AesGcmDecrypt", BAD_FUNC_ARG);
1032        return  BAD_FUNC_ARG;
1033    }
1034
1035    if (aes->ctx.keySize == 16) {
1036        initFn   = R_TSIP_Aes128GcmDecryptInit;
1037        updateFn = R_TSIP_Aes128GcmDecryptUpdate;
1038        finalFn  = R_TSIP_Aes128GcmDecryptFinal;
1039    }
1040    else {
1041        initFn   = R_TSIP_Aes256GcmDecryptInit;
1042        updateFn = R_TSIP_Aes256GcmDecryptUpdate;
1043        finalFn  = R_TSIP_Aes256GcmDecryptFinal;
1044    }
1045
1046    userCtx = ((TsipUserCtx *)ctx);
1047
1048    /* buffer for plain data output must be multiple of WC_AES_BLOCK_SIZE */
1049    plainBufSz = ((sz / WC_AES_BLOCK_SIZE) + 1) * WC_AES_BLOCK_SIZE;
1050
1051    if ((ret = tsip_hw_lock()) == 0) {
1052
1053        /* allocate buffers for plaintext, cipher-text, authTag and AAD.
1054         * TSIP requests those buffers 32bit aligned.
1055         */
1056        cipherBuf = XMALLOC(sz, aes->heap, DYNAMIC_TYPE_AES);
1057        plainBuf  = XMALLOC(plainBufSz, aes->heap, DYNAMIC_TYPE_AES);
1058        aTagBuf   = XMALLOC(TSIP_AES_GCM_AUTH_TAG_SIZE, aes->heap,
1059                                                        DYNAMIC_TYPE_AES);
1060        aadBuf    = XMALLOC(authInSz, aes->heap, DYNAMIC_TYPE_AES);
1061
1062        if (plainBuf == NULL || cipherBuf == NULL || aTagBuf == NULL ||
1063                                                        aadBuf == NULL) {
1064            ret = -1;
1065        }
1066
1067        if (ret == 0) {
1068            ForceZero(plainBuf, plainBufSz);
1069            XMEMCPY(cipherBuf, in, sz);
1070            ForceZero(aTagBuf, TSIP_AES_GCM_AUTH_TAG_SIZE);
1071            XMEMCPY(aTagBuf,authTag,min(authTagSz, TSIP_AES_GCM_AUTH_TAG_SIZE));
1072            XMEMCPY(aadBuf, authIn, authInSz);
1073        }
1074
1075    #if defined(WOLFSSL_RENESAS_TSIP_TLS)
1076        if (ret == 0 &&
1077            userCtx->internal->session_key_set == 1) {
1078            /* generate AES-GCM session key. The key stored in
1079             * Aes.ctx.tsip_keyIdx is not used here.
1080             */
1081            err = R_TSIP_TlsGenerateSessionKey(
1082                    userCtx->internal->tsip_cipher,
1083                    (uint32_t*)userCtx->internal->tsip_masterSecret,
1084                    (uint8_t*) userCtx->internal->tsip_clientRandom,
1085                    (uint8_t*) userCtx->internal->tsip_serverRandom,
1086                    (uint8_t*)&iv[AESGCM_IMP_IV_SZ], /* use exp_IV */
1087                    NULL,
1088                    NULL,
1089                    NULL,
1090                    &key_server_aes,
1091                    NULL, NULL);
1092            if (err != TSIP_SUCCESS) {
1093                WOLFSSL_MSG("R_TSIP_TlsGenerateSessionKey failed");
1094                ret = -1;
1095            }
1096        } else
1097
1098    #endif
1099        if (ret == 0 &&
1100            (userCtx->user_aes128_key_set == 1 ||
1101             userCtx->user_aes256_key_set == 1)) {
1102            if (aes->ctx.keySize == 32) {
1103                XMEMCPY(&key_server_aes, &userCtx->user_aes256_key_index,
1104                        sizeof(tsip_aes_key_index_t));
1105            }
1106            else {
1107                 XMEMCPY(&key_server_aes, &userCtx->user_aes128_key_index,
1108                        sizeof(tsip_aes_key_index_t));
1109            }
1110
1111            iv_l = iv;
1112            ivSz_l = ivSz;
1113
1114        }
1115
1116        if (ret == 0) {
1117            /* since key_index has iv and ivSz in it, no need to pass them init
1118             * func. Pass NULL and 0 as 3rd and 4th parameter respectively.
1119             *
1120             * It expects to pass iv when users create their own key.
1121             */
1122            err = initFn(&hdl, &key_server_aes, (uint8_t*)iv_l, ivSz_l);
1123
1124            if (err == TSIP_SUCCESS) {
1125                /* pass only AAD and it's size before passing cipher text */
1126                err = updateFn(&hdl, NULL, NULL, 0UL, (uint8_t*)authIn,
1127                                                                    authInSz);
1128            }
1129            if (err == TSIP_SUCCESS) {
1130                err = updateFn(&hdl, cipherBuf, plainBuf, sz, NULL, 0UL);
1131            }
1132            if (err != TSIP_SUCCESS) {
1133                WOLFSSL_MSG("R_TSIP_AesXXXGcmDecryptUpdate: failed in decrypt");
1134                ret = -1;
1135            }
1136            if (err == TSIP_SUCCESS) {
1137                dataLen = 0;
1138                err = finalFn(&hdl,
1139                        plainBuf + (sz / WC_AES_BLOCK_SIZE) * WC_AES_BLOCK_SIZE,
1140                        &dataLen,
1141                        aTagBuf,
1142                        min(16, authTagSz)); /* TSIP accepts upto 16 byte */
1143            }
1144            if (err == TSIP_SUCCESS) {
1145                /* copy plain data to out */
1146                XMEMCPY(out, plainBuf, sz);
1147            }
1148            else {
1149                WOLFSSL_MSG("R_TSIP_AesXXXGcmDecryptFinal: failed");
1150                ret = -1;
1151            }
1152        }
1153
1154        XFREE(plainBuf,  aes->heap, DYNAMIC_TYPE_AES);
1155        XFREE(cipherBuf, aes->heap, DYNAMIC_TYPE_AES);
1156        XFREE(aTagBuf,   aes->heap, DYNAMIC_TYPE_AES);
1157        XFREE(aadBuf,    aes->heap, DYNAMIC_TYPE_AES);
1158
1159        tsip_hw_unlock();
1160    }
1161    WOLFSSL_LEAVE("wc_tsip_AesGcmDecrypt", ret);
1162    return ret;
1163}
1164#endif /* HAVE_AESGCM */
1165#endif /* WOLFSSL_RENESAS_TSIP_TLS) || WOLFSSL_RENESAS_TSIP_CRYPTONLY
1166         && NO_WOLFSSL_RENESAS_TSIP_CRYPT_AES */
1167#endif /* NO_AES */