luna - wolfssl/wolfcrypt/src/port/intel/quickassist.c

   1/* quickassist.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
  28#ifdef HAVE_INTEL_QA
  29
  30#ifdef QAT_DEMO_MAIN
  31    #define QAT_USE_POLLING_THREAD
  32#endif
  33
  34
  35#include <wolfssl/internal.h>
  36#include <wolfssl/error-ssl.h>
  37#include <wolfssl/wolfcrypt/error-crypt.h>
  38#include <wolfssl/wolfcrypt/random.h>
  39#ifndef NO_RSA
  40    #include <wolfssl/wolfcrypt/rsa.h>
  41#endif
  42#ifndef NO_AES
  43    #include <wolfssl/wolfcrypt/aes.h>
  44#endif
  45#ifndef NO_HMAC
  46    #include <wolfssl/wolfcrypt/hmac.h>
  47#endif
  48#ifndef NO_DH
  49    #include <wolfssl/wolfcrypt/dh.h>
  50#endif
  51
  52#include <wolfssl/wolfcrypt/port/intel/quickassist.h>
  53
  54#include "icp_sal_user.h"
  55#include "icp_sal_poll.h"
  56#ifndef QAT_V2
  57#include "icp_sal_drbg_impl.h"
  58#endif
  59
  60#ifdef QAT_HASH_ENABLE_PARTIAL
  61#ifdef USE_LAC_SESSION_FOR_STRUCT_OFFSET
  62    #include "lac_session.h"
  63#endif
  64#endif
  65
  66#ifdef NO_INLINE
  67    #include <wolfssl/wolfcrypt/misc.h>
  68#else
  69    #define WOLFSSL_MISC_INCLUDED
  70    #include <wolfcrypt/src/misc.c>
  71#endif
  72
  73#include <pthread.h>
  74
  75/* Async enables (1=non-block, 0=block) */
  76#ifndef QAT_RSA_ASYNC
  77#define QAT_RSA_ASYNC        1
  78#endif
  79#ifndef QAT_EXPTMOD_ASYNC
  80#define QAT_EXPTMOD_ASYNC    1
  81#endif
  82#ifndef QAT_CIPHER_ASYNC
  83#define QAT_CIPHER_ASYNC     1
  84#endif
  85#ifndef QAT_ECDSA_ASYNC
  86#define QAT_ECDSA_ASYNC      1
  87#endif
  88#ifndef QAT_ECDHE_ASYNC
  89#define QAT_ECDHE_ASYNC      1
  90#endif
  91#ifndef QAT_ECMUL_ASYNC
  92#define QAT_ECMUL_ASYNC      1
  93#endif
  94#ifndef QAT_DH_ASYNC
  95#define QAT_DH_ASYNC         1
  96#endif
  97
  98/* Hash and Drbg do not support async in wolfSSL/wolfCrypt */
  99#ifndef QAT_HASH_ASYNC
 100#define QAT_HASH_ASYNC       0
 101#endif
 102#ifndef QAT_DRBG_ASYNC
 103#define QAT_DRBG_ASYNC       0
 104#endif
 105
 106#define OS_HOST_TO_NW_32(uData) ByteReverseWord32(uData)
 107
 108static CpaInstanceHandle* g_cyInstances = NULL;
 109static CpaInstanceInfo2* g_cyInstanceInfo = NULL;
 110static Cpa32U* g_cyInstMap = NULL;
 111static Cpa16U g_numInstances = 0;
 112static Cpa16U g_instCounter = 0;
 113static CpaBoolean g_cyServiceStarted = CPA_FALSE;
 114#ifdef QAT_USE_POLLING_CHECK
 115    static CpaBoolean* g_cyPolling = NULL;
 116    static pthread_mutex_t* g_PollLock;
 117#endif
 118static volatile int g_initCount = 0;
 119#if defined(HAVE_ECC) && defined(HAVE_ECC_DHE)
 120    static Cpa8U* g_qatEcdhY = NULL;
 121    static Cpa8U* g_qatEcdhCofactor1 = NULL;
 122#endif
 123static pthread_mutex_t g_Hwlock = PTHREAD_MUTEX_INITIALIZER;
 124
 125typedef struct qatCapabilities {
 126    /* capabilities */
 127    word32 supPartial:1;
 128#ifdef QAT_V2
 129    word32 supSha3:1;
 130#endif
 131} qatCapabilities_t;
 132static qatCapabilities_t g_qatCapabilities = {
 133    0
 134    #ifdef QAT_V2
 135    , 0
 136    #endif
 137};
 138
 139
 140#if defined(QAT_ENABLE_CRYPTO) || defined(QAT_ENABLE_HASH)
 141    static int IntelQaSymClose(WC_ASYNC_DEV* dev, int doFree);
 142#endif
 143#if defined(QAT_ENABLE_RNG)
 144static int IntelQaDrbgClose(WC_ASYNC_DEV* dev);
 145#endif
 146
 147extern Cpa32U osalLogLevelSet(Cpa32U level);
 148
 149
 150/* -------------------------------------------------------------------------- */
 151/* Polling */
 152/* -------------------------------------------------------------------------- */
 153
 154#ifdef QAT_USE_POLLING_THREAD
 155static void* IntelQaPollingThread(void* context)
 156{
 157    WC_ASYNC_DEV* dev = (WC_ASYNC_DEV*)context;
 158#ifdef QAT_DEBUG
 159    printf("Polling Thread Start\n");
 160#endif
 161    while (dev->qat.pollingCy) {
 162        icp_sal_CyPollInstance(dev->qat.handle, QAT_POLL_RESP_QUOTA);
 163        wc_AsyncSleep(10);
 164    }
 165#ifdef QAT_DEBUG
 166    printf("Polling Thread Exit\n");
 167#endif
 168    pthread_exit(NULL);
 169}
 170
 171static CpaStatus IntelQaStartPollingThread(WC_ASYNC_DEV* dev)
 172{
 173    if (dev->qat.pollingCy == 0) {
 174        dev->qat.pollingCy = 1;
 175    #ifdef QAT_DEBUG
 176        printf("Polling Thread Created\n");
 177    #endif
 178        if (pthread_create(&dev->qat.pollingThread, NULL, IntelQaPollingThread,
 179                                                            (void*)dev) != 0) {
 180            printf("Failed create polling thread!\n");
 181            return CPA_STATUS_FAIL;
 182        }
 183    }
 184    return CPA_STATUS_SUCCESS;
 185}
 186
 187static void IntelQaStopPollingThread(WC_ASYNC_DEV* dev)
 188{
 189    dev->qat.pollingCy = 0;
 190    pthread_join(dev->qat.pollingThread, 0);
 191}
 192#endif /* QAT_USE_POLLING_THREAD */
 193
 194
 195
 196/* -------------------------------------------------------------------------- */
 197/* Buffer Helpers */
 198/* -------------------------------------------------------------------------- */
 199#if defined(HAVE_ECC) || !defined(NO_DH) || !defined(NO_RSA)
 200static WC_INLINE int IntelQaAllocFlatBuffer(CpaFlatBuffer* buf, int size,
 201    void* heap)
 202{
 203    if (buf == NULL || size <= 0)
 204        return BAD_FUNC_ARG;
 205    buf->pData = (byte*)XMALLOC(size, heap, DYNAMIC_TYPE_ASYNC_NUMA);
 206    if (buf->pData == NULL)
 207        return MEMORY_E;
 208    buf->dataLenInBytes = size;
 209    return 0;
 210}
 211#if !defined(NO_DH) || defined(WOLFSSL_KEY_GEN)
 212static WC_INLINE void IntelQaFreeFlatBuffer(CpaFlatBuffer* buf, void* heap)
 213{
 214    if (buf && buf->pData) {
 215        XFREE(buf->pData, heap, DYNAMIC_TYPE_ASYNC_NUMA);
 216        buf->pData = NULL;
 217        buf->dataLenInBytes = 0;
 218    }
 219}
 220#endif
 221static WC_INLINE int IntelQaBigIntToFlatBuffer(WC_BIGINT* src,
 222    CpaFlatBuffer* dst)
 223{
 224    if (src == NULL || src->buf == NULL || dst == NULL) {
 225        return BAD_FUNC_ARG;
 226    }
 227
 228    dst->pData = src->buf;
 229    dst->dataLenInBytes = src->len;
 230
 231    return 0;
 232}
 233
 234static WC_INLINE int IntelQaFlatBufferToBigInt(CpaFlatBuffer* src,
 235    WC_BIGINT* dst)
 236{
 237    if (src == NULL || src->pData == NULL || dst == NULL) {
 238        return BAD_FUNC_ARG;
 239    }
 240
 241    dst->buf = src->pData;
 242    dst->len = src->dataLenInBytes;
 243
 244    return 0;
 245}
 246#endif
 247
 248
 249/* -------------------------------------------------------------------------- */
 250/* Device */
 251/* -------------------------------------------------------------------------- */
 252void IntelQaHardwareStop(void)
 253{
 254    int i;
 255    CpaStatus status;
 256
 257    g_initCount--;  /* track de-init count */
 258    if (g_initCount != 0) {
 259        return;
 260    }
 261
 262#if defined(HAVE_ECC) && defined(HAVE_ECC_DHE)
 263    if (g_qatEcdhY) {
 264        XFREE(g_qatEcdhY, NULL, DYNAMIC_TYPE_ASYNC_NUMA);
 265        g_qatEcdhY = NULL;
 266    }
 267    if (g_qatEcdhCofactor1) {
 268        XFREE(g_qatEcdhCofactor1, NULL, DYNAMIC_TYPE_ASYNC_NUMA);
 269        g_qatEcdhCofactor1 = NULL;
 270    }
 271#endif
 272
 273    if (g_cyServiceStarted == CPA_TRUE) {
 274        g_cyServiceStarted = CPA_FALSE;
 275        for (i=0; i<g_numInstances; i++) {
 276            status = cpaCyStopInstance(g_cyInstances[i]);
 277            if (status != CPA_STATUS_SUCCESS) {
 278                printf("IntelQA: Could not stop instance: %d\n", i);
 279                printf("\tInternal error has occur which probably can only be"
 280                    "fixed by a reboot\n");
 281            }
 282        }
 283    }
 284
 285    status = icp_sal_userStop();
 286    if (status != CPA_STATUS_SUCCESS) {
 287        printf("IntelQA: Could not stop sal for user space (status %d)\n",
 288                                                                        status);
 289    }
 290
 291    if (g_cyInstMap) {
 292        XFREE(g_cyInstMap, NULL, DYNAMIC_TYPE_ASYNC);
 293        g_cyInstMap = NULL;
 294    }
 295
 296    if (g_cyInstanceInfo) {
 297        XFREE(g_cyInstanceInfo, NULL, DYNAMIC_TYPE_ASYNC);
 298        g_cyInstanceInfo = NULL;
 299    }
 300
 301#ifdef QAT_USE_POLLING_CHECK
 302    if (g_cyPolling) {
 303        XFREE(g_cyPolling, NULL, DYNAMIC_TYPE_ASYNC);
 304        g_cyPolling = NULL;
 305    }
 306    if (g_PollLock) {
 307        for (i=0; i<g_numInstances; i++) {
 308            pthread_mutex_destroy(&g_PollLock[i]);
 309        }
 310        XFREE(g_PollLock, NULL, DYNAMIC_TYPE_ASYNC);
 311        g_PollLock = NULL;
 312    }
 313#endif
 314
 315    if (g_cyInstances) {
 316        XFREE(g_cyInstances, NULL, DYNAMIC_TYPE_ASYNC);
 317        g_cyInstances = NULL;
 318        g_numInstances = 0;
 319    }
 320
 321    qaeMemDestroy();
 322
 323    printf("IntelQA: Stop\n");
 324}
 325
 326int IntelQaHardwareStart(const char* process_name, int limitDevAccess)
 327{
 328    int ret = 0, i;
 329    CpaStatus status;
 330
 331    g_initCount++;
 332    if (g_initCount > 1) {
 333        return 0;
 334    }
 335
 336    status = qaeMemInit();
 337    if (status != CPA_STATUS_SUCCESS) {
 338        printf("IntelQA: Could not start qae mem for user space (status %d)\n",
 339                                                                        status);
 340        printf("\tHas the qaeMemDrv.ko module been loaded?\n");
 341        return ASYNC_INIT_E;
 342    }
 343
 344    status = icp_sal_userStartMultiProcess(process_name,
 345        limitDevAccess ? CPA_TRUE : CPA_FALSE);
 346    if (status != CPA_STATUS_SUCCESS) {
 347        printf("IntelQA: Could not start sal for user space! status %d\n",
 348                                                                        status);
 349        ret = ASYNC_INIT_E; goto error;
 350    }
 351
 352#ifdef QAT_DEBUG
 353    /* optionally enable debugging */
 354    /* osalLogLevelSet(8); */
 355#endif
 356
 357    status = cpaCyGetNumInstances(&g_numInstances);
 358    if (status != CPA_STATUS_SUCCESS || g_numInstances == 0) {
 359        printf("IntelQA: Failed to get num of instances! status %d\n",
 360                                                                    status);
 361        ret = INVALID_DEVID; goto error;
 362    }
 363
 364    /* Get handles / info */
 365    g_cyInstances = (CpaInstanceHandle*)XMALLOC(
 366        sizeof(CpaInstanceHandle) * g_numInstances, NULL, DYNAMIC_TYPE_ASYNC);
 367    if (g_cyInstances == NULL) {
 368        printf("IntelQA: Failed to allocate instances\n");
 369        ret = INVALID_DEVID; goto error;
 370    }
 371
 372#ifdef QAT_USE_POLLING_CHECK
 373    g_cyPolling = (CpaBoolean*)XMALLOC(sizeof(CpaBoolean) * g_numInstances,
 374        NULL, DYNAMIC_TYPE_ASYNC);
 375    if (g_cyPolling == NULL) {
 376        printf("IntelQA: Failed to allocate polling status\n");
 377        ret = INVALID_DEVID; goto error;
 378    }
 379    g_PollLock = (pthread_mutex_t*)XMALLOC(sizeof(pthread_mutex_t) *
 380        g_numInstances, NULL, DYNAMIC_TYPE_ASYNC);
 381    if (g_PollLock == NULL) {
 382        printf("IntelQA: Failed to allocate polling locks\n");
 383        ret = INVALID_DEVID; goto error;
 384    }
 385    for (i=0; i<g_numInstances; i++) {
 386        pthread_mutex_init(&g_PollLock[i], NULL);
 387    }
 388#endif
 389
 390    g_cyInstanceInfo = (CpaInstanceInfo2*)XMALLOC(
 391        sizeof(CpaInstanceInfo2) * g_numInstances, NULL, DYNAMIC_TYPE_ASYNC);
 392    if (g_cyInstanceInfo == NULL) {
 393        printf("IntelQA: Failed to allocate instance info\n");
 394        ret = INVALID_DEVID; goto error;
 395    }
 396
 397    g_cyInstMap = (Cpa32U*)XMALLOC(
 398        sizeof(Cpa32U) * g_numInstances, NULL, DYNAMIC_TYPE_ASYNC);
 399    if (g_cyInstMap == NULL) {
 400        printf("IntelQA: Failed to allocate instance map\n");
 401        ret = INVALID_DEVID; goto error;
 402    }
 403
 404    status = cpaCyGetInstances(g_numInstances, g_cyInstances);
 405    if (status != CPA_STATUS_SUCCESS) {
 406        printf("IntelQA: Failed to get IntelQA instances\n");
 407        ret = INVALID_DEVID; goto error;
 408    }
 409
 410    /* start all instances */
 411    g_cyServiceStarted = CPA_TRUE;
 412    for (i=0; i<g_numInstances; i++) {
 413        Cpa32U coreAffinity = 0;
 414        CpaCySymCapabilitiesInfo capabilities;
 415        int j;
 416        XMEMSET(&capabilities, 0, sizeof(capabilities));
 417
 418        status = cpaCyInstanceGetInfo2(g_cyInstances[i],
 419                                                    &g_cyInstanceInfo[i]);
 420        if (status != CPA_STATUS_SUCCESS) {
 421            printf("IntelQA: Error getting instance info for %d\n", i);
 422            ret = INVALID_DEVID; goto error;
 423        }
 424
 425        /* loop of the instanceInfo coreAffinity bitmask to find the core */
 426        for (j=0; j<CPA_MAX_CORES; j++) {
 427            if (CPA_BITMAP_BIT_TEST(g_cyInstanceInfo[i].coreAffinity, j)) {
 428                coreAffinity = i;
 429                break;
 430            }
 431        }
 432        g_cyInstMap[i] = coreAffinity;
 433
 434        /* capabilities */
 435        status = cpaCySymQueryCapabilities(g_cyInstances[i], &capabilities);
 436        if (status == CPA_STATUS_SUCCESS) {
 437            g_qatCapabilities.supPartial = capabilities.partialPacketSupported;
 438            if (capabilities.partialPacketSupported != CPA_TRUE) {
 439                printf("Warning: QAT does not support partial packets!\n");
 440            }
 441        }
 442    #ifdef QAT_V2
 443        g_qatCapabilities.supSha3 = CPA_BITMAP_BIT_TEST(capabilities.hashes,
 444            CPA_CY_SYM_HASH_SHA3_256) ? 1 : 0;
 445    #endif
 446
 447    #ifdef QAT_DEBUG
 448        printf("Inst %u, Node: %d, Affin: %u, Dev: %u, Accel %u",
 449                i, g_cyInstanceInfo[i].nodeAffinity, coreAffinity,
 450                g_cyInstanceInfo[i].physInstId.packageId,
 451                g_cyInstanceInfo[i].physInstId.acceleratorId);
 452        printf(", EE %u, BDF %02X:%02X:%02X, isPolled %d\n",
 453                g_cyInstanceInfo[i].physInstId.executionEngineId,
 454                (Cpa8U)((g_cyInstanceInfo[i].physInstId.busAddress) >> 8),
 455                (Cpa8U)((g_cyInstanceInfo[i].physInstId.busAddress)
 456                                                            & 0xFF) >> 3,
 457                (Cpa8U)((g_cyInstanceInfo[i].physInstId.busAddress) & 3),
 458                g_cyInstanceInfo[i].isPolled);
 459    #endif
 460
 461        status = cpaCySetAddressTranslation(g_cyInstances[i],
 462            qaeVirtToPhysNUMA);
 463        if (status != CPA_STATUS_SUCCESS) {
 464            printf("IntelQA: Error setting memory config for inst %d\n", i);
 465            ret = INVALID_DEVID; goto error;
 466        }
 467
 468        status = cpaCyStartInstance(g_cyInstances[i]);
 469        if (status != CPA_STATUS_SUCCESS) {
 470            printf("IntelQA: Error starting crypto instance %d\n", i);
 471            ret = INVALID_DEVID; goto error;
 472        }
 473    }
 474
 475#if defined(HAVE_ECC) && defined(HAVE_ECC_DHE)
 476    g_qatEcdhY = (Cpa8U*)XMALLOC(MAX_ECC_BYTES, NULL, DYNAMIC_TYPE_ASYNC_NUMA);
 477    if (g_qatEcdhY == NULL) {
 478        ret = MEMORY_E; goto error;
 479    }
 480    g_qatEcdhCofactor1 = (Cpa8U*)XMALLOC(MAX_ECC_BYTES, NULL, DYNAMIC_TYPE_ASYNC_NUMA);
 481    if (g_qatEcdhCofactor1 == NULL) {
 482        ret = MEMORY_E; goto error;
 483    }
 484    *((word32*)g_qatEcdhCofactor1) = OS_HOST_TO_NW_32(1);
 485#endif
 486
 487    printf("IntelQA: Instances %d\n", g_numInstances);
 488    return ret;
 489
 490error:
 491    IntelQaHardwareStop();
 492    return ret;
 493}
 494
 495
 496int IntelQaInit(void* threadId)
 497{
 498    int ret;
 499    int devId;
 500#if !defined(WC_NO_ASYNC_THREADING) && defined(WC_ASYNC_THREAD_BIND)
 501    pthread_t* thread = (pthread_t*)threadId;
 502#else
 503    (void)threadId;
 504#endif
 505
 506    ret = pthread_mutex_lock(&g_Hwlock);
 507    if (ret != 0) {
 508        printf("IntelQaInit: mutex lock failed! %d\n", ret);
 509        return BAD_MUTEX_E;
 510    }
 511
 512    ret = IntelQaHardwareStart(QAT_PROCESS_NAME, QAT_LIMIT_DEV_ACCESS);
 513    if (ret != 0) {
 514        pthread_mutex_unlock(&g_Hwlock);
 515        return ret;
 516    }
 517
 518    if (g_numInstances <= 0) {
 519        pthread_mutex_unlock(&g_Hwlock);
 520        return ASYNC_INIT_E;
 521    }
 522
 523    /* assign device id */
 524    devId = (g_instCounter % g_numInstances);
 525    g_instCounter++;
 526
 527    pthread_mutex_unlock(&g_Hwlock);
 528
 529#if !defined(WC_NO_ASYNC_THREADING) && defined(WC_ASYNC_THREAD_BIND)
 530    /* if no thread provided then just return instance and don't bind */
 531    if (thread) {
 532        ret = wc_AsyncThreadBind(thread, g_cyInstMap[devId]);
 533        if (ret != 0) {
 534            printf("IntelQA: Thread bind failed! %d\n", ret);
 535        }
 536    }
 537#endif /* !WC_NO_ASYNC_THREADING && !WC_NO_ASYNC_THREAD_BIND */
 538
 539    return devId;
 540}
 541
 542int IntelQaNumInstances(void)
 543{
 544    return g_numInstances;
 545}
 546
 547int IntelQaOpen(WC_ASYNC_DEV* dev, int devId)
 548{
 549    if (dev == NULL) {
 550        return BAD_FUNC_ARG;
 551    }
 552
 553    (void)devId;
 554
 555    /* clear device info */
 556    XMEMSET(&dev->qat, 0, sizeof(IntelQaDev));
 557
 558    if (g_cyInstances == NULL) {
 559        printf("IntelQA not initialized\n");
 560        return ASYNC_INIT_E;
 561    }
 562
 563    if (devId >= g_numInstances) {
 564        fprintf(stderr, "IntelQA: devId %d exceeds number of instances %u\n",
 565                devId, g_numInstances);
 566        return NO_VALID_DEVID;
 567    }
 568
 569    dev->qat.devId = devId;
 570    dev->qat.handle = g_cyInstances[devId];
 571
 572#ifdef QAT_DEBUG
 573    printf("IntelQaOpen %p\n", dev);
 574#endif
 575
 576#ifdef QAT_USE_POLLING_THREAD
 577    /* start polling thread */
 578    IntelQaStartPollingThread(dev);
 579#endif
 580
 581    return 0;
 582}
 583
 584#if defined(QAT_ENABLE_CRYPTO) || defined(QAT_ENABLE_HASH)
 585static int IntelQaDevIsHash(WC_ASYNC_DEV* dev)
 586{
 587    int isHash = 0;
 588
 589    switch (dev->marker) {
 590        case WOLFSSL_ASYNC_MARKER_ARC4:
 591        case WOLFSSL_ASYNC_MARKER_AES:
 592        case WOLFSSL_ASYNC_MARKER_3DES:
 593        case WOLFSSL_ASYNC_MARKER_RNG:
 594        case WOLFSSL_ASYNC_MARKER_RSA:
 595        case WOLFSSL_ASYNC_MARKER_ECC:
 596        case WOLFSSL_ASYNC_MARKER_DH:
 597            isHash = 0;
 598            break;
 599        case WOLFSSL_ASYNC_MARKER_HMAC:
 600        case WOLFSSL_ASYNC_MARKER_SHA512:
 601        case WOLFSSL_ASYNC_MARKER_SHA384:
 602        case WOLFSSL_ASYNC_MARKER_SHA256:
 603        case WOLFSSL_ASYNC_MARKER_SHA224:
 604        case WOLFSSL_ASYNC_MARKER_SHA:
 605        case WOLFSSL_ASYNC_MARKER_MD5:
 606        case WOLFSSL_ASYNC_MARKER_SHA3:
 607            isHash = 1;
 608            break;
 609    }
 610
 611    return isHash;
 612}
 613
 614static IntelQaSymCtx* IntelQaGetSymCtx(WC_ASYNC_DEV* dev)
 615{
 616#if defined(QAT_ENABLE_CRYPTO) && defined(QAT_ENABLE_HASH)
 617    return IntelQaDevIsHash(dev) ? &dev->qat.op.hash.ctx :
 618        &dev->qat.op.cipher.ctx;
 619#elif defined(QAT_ENABLE_CRYPTO)
 620    return IntelQaDevIsHash(dev) ? NULL : &dev->qat.op.cipher.ctx;
 621#elif defined(QAT_ENABLE_HASH)
 622    return IntelQaDevIsHash(dev) ? &dev->qat.op.hash.ctx : NULL;
 623#else
 624    return NULL;
 625#endif
 626}
 627
 628static int IntelQaDevIsSym(WC_ASYNC_DEV* dev)
 629{
 630    int isSym = 0;
 631
 632    switch (dev->marker) {
 633        case WOLFSSL_ASYNC_MARKER_RNG:
 634        case WOLFSSL_ASYNC_MARKER_RSA:
 635        case WOLFSSL_ASYNC_MARKER_ECC:
 636        case WOLFSSL_ASYNC_MARKER_DH:
 637            isSym = 0;
 638            break;
 639        case WOLFSSL_ASYNC_MARKER_ARC4:
 640        case WOLFSSL_ASYNC_MARKER_AES:
 641        case WOLFSSL_ASYNC_MARKER_3DES:
 642        case WOLFSSL_ASYNC_MARKER_HMAC:
 643        case WOLFSSL_ASYNC_MARKER_SHA512:
 644        case WOLFSSL_ASYNC_MARKER_SHA384:
 645        case WOLFSSL_ASYNC_MARKER_SHA256:
 646        case WOLFSSL_ASYNC_MARKER_SHA224:
 647        case WOLFSSL_ASYNC_MARKER_SHA:
 648        case WOLFSSL_ASYNC_MARKER_MD5:
 649        case WOLFSSL_ASYNC_MARKER_SHA3:
 650            isSym = 1;
 651            break;
 652    }
 653
 654    return isSym;
 655}
 656#endif
 657
 658void IntelQaClose(WC_ASYNC_DEV* dev)
 659{
 660    if (dev) {
 661    #ifdef QAT_DEBUG
 662        printf("IntelQaClose %p\n", dev);
 663    #endif
 664
 665    #if defined(QAT_ENABLE_CRYPTO) || defined(QAT_ENABLE_HASH)
 666        if (IntelQaDevIsSym(dev)) {
 667            /* close any active session */
 668            IntelQaSymClose(dev, 1);
 669        }
 670    #endif
 671    #if defined(QAT_ENABLE_RNG)
 672        if (dev->marker == WOLFSSL_ASYNC_MARKER_RNG) {
 673            IntelQaDrbgClose(dev);
 674        }
 675    #endif
 676
 677    #ifdef QAT_USE_POLLING_THREAD
 678        IntelQaStopPollingThread(dev);
 679    #endif
 680
 681        dev->qat.handle = NULL;
 682    }
 683}
 684
 685void IntelQaDeInit(int devId)
 686{
 687    (void)devId;
 688
 689    if (pthread_mutex_lock(&g_Hwlock) == 0) {
 690        IntelQaHardwareStop();
 691        pthread_mutex_unlock(&g_Hwlock);
 692    }
 693}
 694
 695int IntelQaDevCopy(WC_ASYNC_DEV* src, WC_ASYNC_DEV* dst)
 696{
 697    int ret = 0;
 698#if defined(QAT_ENABLE_HASH) || defined(QAT_ENABLE_CRYPTO)
 699    IntelQaSymCtx *ctxSrc, *ctxDst;
 700#ifdef QAT_ENABLE_HASH
 701    int isHash;
 702#endif
 703#endif
 704
 705    if (src == NULL || dst == NULL)
 706        return BAD_FUNC_ARG;
 707
 708#if defined(QAT_ENABLE_HASH) || defined(QAT_ENABLE_CRYPTO)
 709    ctxDst = IntelQaGetSymCtx(dst);
 710    ctxSrc = IntelQaGetSymCtx(src);
 711
 712    if (ctxDst == NULL || ctxSrc == NULL) {
 713        return ret;
 714    }
 715
 716#ifdef QAT_DEBUG
 717    printf("IntelQaDevCopy: dev %p->%p, symCtx %p (src %p), symCtxSize %d\n",
 718        src, dst, ctxSrc->symCtx, ctxSrc->symCtxSrc, ctxSrc->symCtxSize);
 719#endif
 720
 721    ctxDst->isCopy = 1;
 722    /* force alloc/init on open for copy */
 723    ctxDst->symCtx = NULL;
 724    ctxDst->isOpen = 0;
 725    /* if src is not open, then don't set source ctx */
 726    if (!ctxSrc->isOpen)
 727        ctxDst->symCtxSrc = NULL;
 728
 729#ifdef QAT_ENABLE_HASH
 730    isHash = IntelQaDevIsHash(src);
 731    if (isHash) {
 732        /* need to duplicate tmpIn */
 733        if (src->qat.op.hash.tmpIn) {
 734            dst->qat.op.hash.tmpIn = (byte*)XMALLOC(src->qat.op.hash.tmpInBufSz,
 735                src->heap, DYNAMIC_TYPE_ASYNC_NUMA);
 736            if (dst->qat.op.hash.tmpIn == NULL) {
 737                return MEMORY_E;
 738            }
 739            XMEMCPY(dst->qat.op.hash.tmpIn, src->qat.op.hash.tmpIn,
 740                src->qat.op.hash.tmpInSz);
 741            dst->qat.op.hash.tmpInSz = src->qat.op.hash.tmpInSz;
 742            dst->qat.op.hash.tmpInBufSz = src->qat.op.hash.tmpInBufSz;
 743        }
 744    }
 745#endif /* QAT_ENABLE_HASH */
 746#endif /* QAT_ENABLE_HASH || QAT_ENABLE_CRYPTO */
 747
 748    return ret;
 749}
 750
 751int IntelQaPoll(WC_ASYNC_DEV* dev)
 752{
 753    int ret = 0;
 754
 755#ifndef QAT_USE_POLLING_THREAD
 756    CpaStatus status;
 757    WOLF_EVENT* event = &dev->event;
 758
 759#ifdef QAT_USE_POLLING_CHECK
 760    pthread_mutex_t* lock = &g_PollLock[dev->qat.devId];
 761    if (pthread_mutex_lock(lock) == 0) {
 762        /* test if any other threads are polling */
 763        if (g_cyPolling[dev->qat.devId]) {
 764            pthread_mutex_unlock(lock);
 765
 766            /* return success even though its busy, caller will treat as
 767             * WC_PENDING_E */
 768            return 0;
 769        }
 770
 771        g_cyPolling[dev->qat.devId] = 1;
 772        pthread_mutex_unlock(lock);
 773    }
 774#endif
 775
 776    status = icp_sal_CyPollInstance(dev->qat.handle, QAT_POLL_RESP_QUOTA);
 777    if (status != CPA_STATUS_SUCCESS && status != CPA_STATUS_RETRY) {
 778        printf("IntelQa: Poll failure %d\n", status);
 779        ret = -1;
 780    }
 781
 782#ifndef WC_NO_ASYNC_THREADING
 783    if (event->threadId == 0 || event->threadId == wc_AsyncThreadId())
 784#endif
 785    {
 786        /* if event is done */
 787        if (dev->qat.ret != WC_PENDING_E) {
 788            /* perform cleanup */
 789            IntelQaFreeFunc freeFunc = dev->qat.freeFunc;
 790    #ifdef QAT_DEBUG
 791            printf("IntelQaOpFree: Dev %p, FreeFunc %p\n", dev, freeFunc);
 792    #endif
 793            if (freeFunc) {
 794                dev->qat.freeFunc = NULL;
 795                freeFunc(dev);
 796            }
 797
 798            /* return response code */
 799            event->ret = dev->qat.ret;
 800        }
 801    }
 802
 803#ifdef QAT_USE_POLLING_CHECK
 804    /* indicate we are done polling */
 805    if (pthread_mutex_lock(lock) == 0) {
 806        g_cyPolling[dev->qat.devId] = 0;
 807        pthread_mutex_unlock(lock);
 808    }
 809#endif
 810
 811#else
 812    (void)dev;
 813#endif
 814
 815    return ret;
 816}
 817
 818static int IntelQaPollBlockRet(WC_ASYNC_DEV* dev, int ret_wait)
 819{
 820    int ret;
 821
 822    do {
 823        ret = IntelQaPoll(dev);
 824        (void)ret; /* not used */
 825
 826        if (dev->qat.ret != ret_wait) {
 827            break;
 828        }
 829    #ifndef WC_NO_ASYNC_THREADING
 830        wc_AsyncThreadYield();
 831    #endif
 832    } while (1);
 833    ret = dev->qat.ret;
 834
 835    return ret;
 836}
 837
 838int IntelQaGetCyInstanceCount(void)
 839{
 840    return g_numInstances;
 841}
 842
 843static WC_INLINE int IntelQaHandleCpaStatus(WC_ASYNC_DEV* dev, CpaStatus status,
 844    int* ret, byte isAsync, void* callback, int* retryCount)
 845{
 846    int retry = 0;
 847
 848    if (status == CPA_STATUS_SUCCESS) {
 849        if (isAsync && callback) {
 850            *ret = WC_PENDING_E;
 851        }
 852        else {
 853            *ret = IntelQaPollBlockRet(dev, WC_PENDING_E);
 854        }
 855    }
 856    else if (status == CPA_STATUS_RETRY) {
 857        (*retryCount)++;
 858        if ((*retryCount % (QAT_RETRY_LIMIT + 1)) == QAT_RETRY_LIMIT) {
 859        #ifndef WC_NO_ASYNC_THREADING
 860            wc_AsyncThreadYield();
 861        #else
 862            wc_AsyncSleep(10);
 863        #endif
 864        }
 865        retry = 1;
 866    }
 867    else {
 868        *ret = ASYNC_OP_E;
 869    }
 870
 871    return retry;
 872}
 873
 874static WC_INLINE void IntelQaOpInit(WC_ASYNC_DEV* dev, IntelQaFreeFunc freeFunc)
 875{
 876    dev->qat.ret = WC_PENDING_E;
 877    dev->qat.freeFunc = freeFunc;
 878}
 879
 880
 881/* -------------------------------------------------------------------------- */
 882/* RSA Algo */
 883/* -------------------------------------------------------------------------- */
 884
 885#ifndef NO_RSA
 886
 887#ifdef WOLFSSL_KEY_GEN
 888static void IntelQaGenPrimeFree(WC_ASYNC_DEV* dev)
 889{
 890    CpaCyPrimeTestOpData* opData = dev->qat.op.prime_gen.opData;
 891    CpaFlatBuffer* primeCandidates = dev->qat.op.prime_gen.primeCandidates;
 892    byte* pMillerRabinData = dev->qat.op.prime_gen.pMillerRabinData;
 893
 894    if (opData) {
 895        XFREE(opData, dev->heap, DYNAMIC_TYPE_ASYNC_NUMA);
 896        dev->qat.op.prime_gen.opData = NULL;
 897    }
 898    if (primeCandidates) {
 899        int i;
 900        for (i = 0; i < QAT_PRIME_GEN_TRIES; i++) {
 901            if (primeCandidates[i].pData) {
 902                XFREE(primeCandidates[i].pData, dev->heap,
 903                    DYNAMIC_TYPE_ASYNC_NUMA);
 904                primeCandidates[i].pData = NULL;
 905                primeCandidates[i].dataLenInBytes = 0;
 906            }
 907        }
 908        XFREE(primeCandidates, dev->heap, DYNAMIC_TYPE_ASYNC_NUMA);
 909        dev->qat.op.prime_gen.primeCandidates = NULL;
 910    }
 911    if (pMillerRabinData) {
 912        XFREE(pMillerRabinData, dev->heap, DYNAMIC_TYPE_ASYNC_NUMA);
 913        dev->qat.op.prime_gen.pMillerRabinData = NULL;
 914    }
 915}
 916
 917static void IntelQaGenPrimeCallback(void *pCallbackTag,
 918    CpaStatus status, void *pOpData, CpaBoolean testPassed)
 919{
 920    WC_ASYNC_DEV* dev = (WC_ASYNC_DEV*)pCallbackTag;
 921    CpaCyPrimeTestOpData* opData = (CpaCyPrimeTestOpData*)pOpData;
 922    int opIndex = 0;
 923    int testStatus = QAT_PRIME_CHK_STATUS_FAILED;
 924
 925    /* calculate index based on opDate pointer offset */
 926    if (dev->qat.op.prime_gen.opData && opData) {
 927        byte* srcop = (byte*)dev->qat.op.prime_gen.opData;
 928        byte* curop = (byte*)opData;
 929        size_t offset;
 930        if (srcop <= curop) {
 931            offset = (size_t)curop - (size_t)srcop;
 932            offset /= sizeof(CpaCyPrimeTestOpData);
 933            if (offset < QAT_PRIME_GEN_TRIES)
 934                opIndex = (int)offset;
 935        }
 936    }
 937
 938#ifdef QAT_DEBUG
 939    printf("IntelQaGenPrimeCallback: dev %p, opIndex %d, status %d, "
 940        "testPassed %d\n", dev, opIndex, status, testPassed);
 941#endif
 942
 943    if (status == CPA_STATUS_SUCCESS) {
 944        testStatus = (testPassed == CPA_TRUE) ?
 945            QAT_PRIME_CHK_STATUS_PASSED :
 946            QAT_PRIME_CHK_STATUS_FAILED;
 947    }
 948
 949    dev->qat.op.prime_gen.testStatus[opIndex] = testStatus;
 950}
 951
 952#ifndef QAT_PRIME_CHECK_TIMEOUT
 953    /* times to wait in retry for operations */
 954    #define QAT_PRIME_CHECK_TIMEOUT 100000
 955#endif
 956int IntelQaGenPrime(WC_ASYNC_DEV* dev, WC_RNG* rng, byte* primeBuf,
 957    word32 primeSz)
 958{
 959    int ret = 0, retryCount = 0, i, attempt;
 960    CpaStatus status = CPA_STATUS_SUCCESS;
 961    CpaCyPrimeTestOpData* opData = NULL;
 962    CpaFlatBuffer* primeCandidates = NULL;
 963    byte* pMillerRabinData = NULL;
 964    CpaFlatBuffer millerRabins;
 965    CpaCyPrimeTestCbFunc callback = IntelQaGenPrimeCallback;
 966    CpaBoolean testPassed = CPA_FALSE;
 967
 968    if (dev == NULL || rng == NULL || primeBuf == NULL || primeSz < 64) {
 969        return BAD_FUNC_ARG;
 970    }
 971
 972#ifdef QAT_DEBUG
 973    printf("IntelQaGenPrime: dev %p, sz %d\n", dev, primeSz);
 974#endif
 975
 976    /* generate operation data and prime candidates */
 977    opData = (CpaCyPrimeTestOpData*)XMALLOC(
 978        sizeof(CpaCyPrimeTestOpData) * QAT_PRIME_GEN_TRIES,
 979        dev->heap, DYNAMIC_TYPE_ASYNC_NUMA);
 980    dev->qat.op.prime_gen.opData = opData;
 981    primeCandidates = (CpaFlatBuffer*)XMALLOC(
 982        sizeof(CpaFlatBuffer) * QAT_PRIME_GEN_TRIES,
 983        dev->heap, DYNAMIC_TYPE_ASYNC_NUMA);
 984    dev->qat.op.prime_gen.primeCandidates = primeCandidates;
 985    if (opData == NULL || primeCandidates == NULL) {
 986        ret = MEMORY_E; goto exit;
 987    }
 988    XMEMSET(opData, 0, sizeof(CpaCyPrimeTestOpData) * QAT_PRIME_GEN_TRIES);
 989    XMEMSET(primeCandidates, 0, sizeof(CpaFlatBuffer) * QAT_PRIME_GEN_TRIES);
 990    for (i = 0; i < QAT_PRIME_GEN_TRIES; i++) {
 991        primeCandidates[i].pData = (byte*)XMALLOC(primeSz, dev->heap,
 992            DYNAMIC_TYPE_ASYNC_NUMA);
 993        if (primeCandidates[i].pData == NULL) {
 994            ret = MEMORY_E; goto exit;
 995        }
 996        primeCandidates[i].dataLenInBytes = primeSz;
 997    }
 998
 999    /* generate miller rabbin data */
1000    pMillerRabinData = (byte*)XMALLOC(primeSz * QAT_PRIME_GEN_MR_ROUNDS,
1001        dev->heap, DYNAMIC_TYPE_ASYNC_NUMA);
1002    dev->qat.op.prime_gen.pMillerRabinData = pMillerRabinData;
1003    if (pMillerRabinData == NULL) {
1004        ret = MEMORY_E; goto exit;
1005    }
1006
1007    ret = wc_RNG_GenerateBlock(rng, pMillerRabinData,
1008        primeSz * QAT_PRIME_GEN_MR_ROUNDS);
1009    if (ret != 0)
1010        goto exit;
1011
1012    /* make sure each miller rabbin number is greater than 1 */
1013    for (i = 0; i < QAT_PRIME_GEN_MR_ROUNDS; i++) {
1014        word32 byteCheck = primeSz - 1;
1015        byte* round = &pMillerRabinData[i * primeSz];
1016        if (round[byteCheck] <= 1) {
1017            ret = wc_RNG_GenerateBlock(rng, &round[byteCheck], 1);
1018            if (ret != 0)
1019                goto exit;
1020            if (round[byteCheck] <= 1)
1021                round[byteCheck] += 2;
1022        }
1023    }
1024    millerRabins.pData = pMillerRabinData;
1025    millerRabins.dataLenInBytes = primeSz * QAT_PRIME_GEN_MR_ROUNDS;
1026
1027    /* populate operation data */
1028    for (i = 0; i < QAT_PRIME_GEN_TRIES; i++) {
1029        opData[i].primeCandidate = primeCandidates[i];
1030        opData[i].performGcdTest = CPA_TRUE;
1031        opData[i].performFermatTest = CPA_TRUE;
1032        opData[i].numMillerRabinRounds = QAT_PRIME_GEN_MR_ROUNDS;
1033        opData[i].millerRabinRandomInput = millerRabins;
1034        opData[i].performLucasTest = CPA_TRUE;
1035    }
1036
1037    /* store info needed for output */
1038    dev->qat.out = primeBuf;
1039    dev->qat.outLen = primeSz;
1040    IntelQaOpInit(dev, IntelQaGenPrimeFree);
1041
1042    for (attempt = 0; attempt < QAT_PRIME_GEN_RETRIES; attempt++) {
1043        int expectedDone, doneCount, primePassIndex, errorCount;
1044        byte* primeData = primeCandidates[0].pData;
1045        /* Generate primeCandidates */
1046        ret = wc_RNG_GenerateBlock(rng, primeData, primeSz);
1047        if (ret != 0)
1048            goto exit;
1049        /* prime lower bound has the MSB set, set it in candidate */
1050        primeData[0] |= 0x80;
1051        /* make candidate odd */
1052        primeData[primeSz-1] |= 0x01;
1053
1054        /* create candidates that are incremented by two */
1055        for (i = 1; i < QAT_PRIME_GEN_TRIES; i++) {
1056            word32 byteCheck = primeSz - 1;
1057            primeData = primeCandidates[i].pData;
1058            XMEMCPY(primeData,
1059                primeCandidates[i-1].pData,
1060                primeCandidates[i-1].dataLenInBytes);
1061
1062            if (primeData[byteCheck] != 0xFF) {
1063                primeData[byteCheck] += 2;
1064            }
1065            else {
1066                /* if rollover occurred increment high order bytes */
1067                /* increment by 1 does not affect odd/even */
1068                int j;
1069                for (j = primeSz - 2; j >= 0; j--) {
1070                    if (primeData[i] != 0xFF) {
1071                        primeData[i] += 1;
1072                        break;
1073                    }
1074                    else {
1075                        primeData[i] = 0;
1076                    }
1077                }
1078            }
1079        }
1080
1081        /* make sure miller rabbin must be less than prime candidate */
1082        for (i = 0; i < QAT_PRIME_GEN_MR_ROUNDS; i++) {
1083            byte* mrData = pMillerRabinData + (i * primeSz);
1084            int j;
1085            for (j = 0; j < (int)primeSz; j++) {
1086                /* if primeData is less then mrData, and primeData is not 0,
1087                 * then make mrData to be smaller than primeData,
1088                  * and we are done */
1089                if ((primeData[j] <= mrData[j]) && primeData[j] != 0) {
1090                    mrData[j] = primeData[j] - 1;
1091                    break;
1092                }
1093                /* if primeData is 0 then mrData needs to be zero and we check
1094                 * the next index */
1095                else if (primeData[j] == 0) {
1096                    mrData[j] = 0;
1097                }
1098                /* primeData is smaller than mrData so we are done */
1099                else {
1100                    break;
1101                }
1102            }
1103        }
1104
1105        /* setup and run prime tests */
1106        XMEMSET(dev->qat.op.prime_gen.testStatus, 0,
1107            sizeof(dev->qat.op.prime_gen.testStatus));
1108        retryCount = 0;
1109        expectedDone = 0;
1110        errorCount = 0;
1111        for (i = 0; i < QAT_PRIME_GEN_TRIES; i++) {
1112            /* perform prime test */
1113            do {
1114                status = cpaCyPrimeTest(dev->qat.handle,
1115                                        callback,
1116                                        dev,
1117                                        &opData[i],
1118                                        &testPassed);
1119                if (status == CPA_STATUS_RETRY) {
1120                    IntelQaPoll(dev);
1121                }
1122            } while (status == CPA_STATUS_RETRY &&
1123                retryCount++ < QAT_PRIME_CHECK_TIMEOUT);
1124
1125            /* handle error */
1126            if (status != CPA_STATUS_SUCCESS) {
1127                errorCount++;
1128                break;
1129            }
1130            expectedDone++;
1131        }
1132
1133        /* use blocking polling, till all have completed */
1134        retryCount = 0;
1135        primePassIndex = -1;
1136        do {
1137            IntelQaPoll(dev);
1138
1139            /* tally results */
1140            doneCount = 0;
1141            for (i = 0; i < expectedDone; i++) {
1142                byte* testStatus = &dev->qat.op.prime_gen.testStatus[i];
1143                if (*testStatus != QAT_PRIME_CHK_STATUS_INIT) {
1144                    doneCount++;
1145                    /* Track index of first passed operation */
1146                    if (primePassIndex == -1 &&
1147                             *testStatus == QAT_PRIME_CHK_STATUS_PASSED)
1148                        primePassIndex = i;
1149                    else if (*testStatus == QAT_PRIME_CHK_STATUS_ERROR)
1150                        errorCount++;
1151                }
1152            }
1153
1154            /* determine if all prime tests are done */
1155            if (doneCount == expectedDone) {
1156                break;
1157            }
1158
1159        #ifndef WC_NO_ASYNC_THREADING
1160            wc_AsyncThreadYield();
1161        #endif
1162        } while (retryCount++ < QAT_PRIME_CHECK_TIMEOUT);
1163        if (retryCount == QAT_PRIME_CHECK_TIMEOUT) {
1164        #ifdef QAT_DEBUG
1165            printf("cpaCyPrimeTest wait timeout! dev %p\n", dev);
1166        #endif
1167            errorCount++;
1168        }
1169
1170        /* check if we found a prime */
1171        if (primePassIndex != -1 && primePassIndex < QAT_PRIME_GEN_TRIES) {
1172            ret = 0;
1173            XMEMCPY(primeBuf, primeCandidates[primePassIndex].pData, primeSz);
1174            break; /* done with success */
1175        }
1176
1177        /* handle failure */
1178        if (errorCount != 0) {
1179            ret = ASYNC_OP_E;
1180            break; /* done with failure */
1181        }
1182
1183    #ifdef QAT_DEBUG
1184        printf("cpaCyPrimeTest attempt %d\n", attempt);
1185    #endif
1186    } /* for (attempt) */
1187
1188exit:
1189
1190    if (ret != 0) {
1191        printf("cpaCyPrimeTest failed! dev %p, status %d, ret %d\n",
1192            dev, status, ret);
1193    }
1194
1195    IntelQaGenPrimeFree(dev);
1196
1197    return ret;
1198}
1199
1200
1201static void IntelQaRsaKeyGenFree(WC_ASYNC_DEV* dev)
1202{
1203    CpaCyRsaPrivateKey* privateKey = &dev->qat.op.rsa_keygen.privateKey;
1204
1205    /* This one is not owned by RsaKey */
1206    IntelQaFreeFlatBuffer(&privateKey->privateKeyRep1.modulusN, dev->heap);
1207
1208    /* free remaining on failures only */
1209    /* ownership of these buffers goes to RsaKey */
1210    if (dev->qat.ret != 0) {
1211        CpaCyRsaKeyGenOpData* opData = &dev->qat.op.rsa_keygen.opData;
1212        CpaCyRsaPublicKey* publicKey = &dev->qat.op.rsa_keygen.publicKey;
1213
1214        IntelQaFreeFlatBuffer(&publicKey->modulusN, dev->heap);
1215        IntelQaFreeFlatBuffer(&publicKey->publicExponentE, dev->heap);
1216
1217        IntelQaFreeFlatBuffer(&privateKey->privateKeyRep1.privateExponentD,
1218            dev->heap);
1219        IntelQaFreeFlatBuffer(&privateKey->privateKeyRep2.prime1P, dev->heap);
1220        IntelQaFreeFlatBuffer(&privateKey->privateKeyRep2.prime2Q, dev->heap);
1221        IntelQaFreeFlatBuffer(&privateKey->privateKeyRep2.exponent1Dp,
1222            dev->heap);
1223        IntelQaFreeFlatBuffer(&privateKey->privateKeyRep2.exponent2Dq,
1224            dev->heap);
1225        IntelQaFreeFlatBuffer(&privateKey->privateKeyRep2.coefficientQInv,
1226            dev->heap);
1227
1228        (void)opData;
1229    }
1230}
1231
1232static void IntelQaRsaKeyGenCallback(void *pCallbackTag,
1233        CpaStatus status, void *pKeyGenOpData, CpaCyRsaPrivateKey *pPrivateKey,
1234        CpaCyRsaPublicKey *pPublicKey)
1235{
1236    WC_ASYNC_DEV* dev = (WC_ASYNC_DEV*)pCallbackTag;
1237    CpaCyRsaKeyGenOpData* opData = (CpaCyRsaKeyGenOpData*)pKeyGenOpData;
1238    int ret = ASYNC_OP_E;
1239
1240#ifdef QAT_DEBUG
1241    printf("IntelQaRsaKeyGenCallback: dev %p, status %d\n", dev, status);
1242#endif
1243
1244    if (status == CPA_STATUS_SUCCESS) {
1245        RsaKey* key = dev->qat.op.rsa_keygen.rsakey;
1246        if (key) {
1247            /* Populate RsaKey Parameters */
1248            /* raw BigInt buffer ownership is transferred to RsaKey */
1249            /* cleanup is handled in wc_FreeRsaKey */
1250
1251            /* modulusN */
1252            ret = IntelQaFlatBufferToBigInt(
1253                    &pPublicKey->modulusN, &key->n.raw);
1254            if (ret == 0)
1255                ret = mp_read_unsigned_bin(&key->n,
1256                    key->n.raw.buf, key->n.raw.len);
1257
1258            /* publicExponentE */
1259            if (ret == 0)
1260                ret = IntelQaFlatBufferToBigInt(
1261                    &pPublicKey->publicExponentE, &key->e.raw);
1262            if (ret == 0)
1263                ret = mp_read_unsigned_bin(&key->e,
1264                    key->e.raw.buf, key->e.raw.len);
1265
1266            /* privateExponentD */
1267            if (ret == 0)
1268                ret = IntelQaFlatBufferToBigInt(
1269                    &pPrivateKey->privateKeyRep1.privateExponentD, &key->d.raw);
1270            if (ret == 0)
1271                ret = mp_read_unsigned_bin(&key->d,
1272                    key->d.raw.buf, key->d.raw.len);
1273
1274            /* prime1P */
1275            if (ret == 0)
1276                ret = IntelQaFlatBufferToBigInt(
1277                    &pPrivateKey->privateKeyRep2.prime1P, &key->p.raw);
1278            if (ret == 0)
1279                ret = mp_read_unsigned_bin(&key->p,
1280                    key->p.raw.buf, key->p.raw.len);
1281
1282            /* prime2Q */
1283            if (ret == 0)
1284                ret = IntelQaFlatBufferToBigInt(
1285                    &pPrivateKey->privateKeyRep2.prime2Q, &key->q.raw);
1286            if (ret == 0)
1287                ret = mp_read_unsigned_bin(&key->q,
1288                    key->q.raw.buf, key->q.raw.len);
1289
1290            /* exponent1Dp */
1291            if (ret == 0)
1292                ret = IntelQaFlatBufferToBigInt(
1293                    &pPrivateKey->privateKeyRep2.exponent1Dp, &key->dP.raw);
1294            if (ret == 0)
1295                ret = mp_read_unsigned_bin(&key->dP,
1296                    key->dP.raw.buf, key->dP.raw.len);
1297
1298            /* exponent2Dq */
1299            if (ret == 0)
1300                ret = IntelQaFlatBufferToBigInt(
1301                    &pPrivateKey->privateKeyRep2.exponent2Dq, &key->dQ.raw);
1302            if (ret == 0)
1303                ret = mp_read_unsigned_bin(&key->dQ,
1304                    key->dQ.raw.buf, key->dQ.raw.len);
1305
1306            /* coefficientQInv */
1307            if (ret == 0)
1308                ret = IntelQaFlatBufferToBigInt(
1309                    &pPrivateKey->privateKeyRep2.coefficientQInv, &key->u.raw);
1310            if (ret == 0)
1311                ret = mp_read_unsigned_bin(&key->u,
1312                    key->u.raw.buf, key->u.raw.len);
1313
1314            /* mark as private key */
1315            if (ret == 0)
1316                key->type = RSA_PRIVATE;
1317        }
1318    }
1319    (void)opData;
1320
1321    /* set return code to mark complete */
1322    dev->qat.ret = ret;
1323}
1324
1325int IntelQaRsaKeyGen(WC_ASYNC_DEV* dev, RsaKey* key, int keyBits, long e,
1326    WC_RNG* rng)
1327{
1328    int ret = 0, retryCount = 0;
1329    CpaStatus status = CPA_STATUS_SUCCESS;
1330    CpaFlatBuffer prime1P;
1331    CpaFlatBuffer prime2Q;
1332    CpaCyRsaKeyGenOpData* opData = NULL;
1333    CpaCyRsaPrivateKey* privateKey = NULL;
1334    CpaCyRsaPublicKey* publicKey = NULL;
1335    CpaCyRsaKeyGenCbFunc callback = IntelQaRsaKeyGenCallback;
1336    int keySz = keyBits/8;
1337    int primeSz = keySz/2; /* P & Q */
1338
1339    if (dev == NULL || key == NULL) {
1340        return BAD_FUNC_ARG;
1341    }
1342
1343#ifdef QAT_DEBUG
1344    printf("IntelQaRsaKeyGen: dev %p, keyBits %d\n", dev, keyBits);
1345#endif
1346
1347    /* allocate and generate 2 primes (P/Q) */
1348    XMEMSET(&prime1P, 0, sizeof(prime1P));
1349    XMEMSET(&prime2Q, 0, sizeof(prime2Q));
1350    ret = IntelQaAllocFlatBuffer(&prime1P, primeSz, dev->heap);
1351    if (ret == 0)
1352        ret = IntelQaGenPrime(dev, rng, prime1P.pData, prime1P.dataLenInBytes);
1353    if (ret == 0)
1354        ret = IntelQaAllocFlatBuffer(&prime2Q, primeSz, dev->heap);
1355    if (ret == 0)
1356        ret = IntelQaGenPrime(dev, rng, prime2Q.pData, prime2Q.dataLenInBytes);
1357    if (ret != 0) {
1358        IntelQaFreeFlatBuffer(&prime1P, dev->heap);
1359        IntelQaFreeFlatBuffer(&prime2Q, dev->heap);
1360        return ret;
1361    }
1362
1363    /* setup key generation operation */
1364    opData = &dev->qat.op.rsa_keygen.opData;
1365    publicKey = &dev->qat.op.rsa_keygen.publicKey;
1366    privateKey = &dev->qat.op.rsa_keygen.privateKey;
1367
1368    /* init variables */
1369    XMEMSET(opData, 0, sizeof(CpaCyRsaDecryptOpData));
1370    XMEMSET(publicKey, 0, sizeof(CpaCyRsaPublicKey));
1371    XMEMSET(privateKey, 0, sizeof(CpaCyRsaPrivateKey));
1372
1373    /* setup private key */
1374    privateKey->version = CPA_CY_RSA_VERSION_TWO_PRIME;
1375    privateKey->privateKeyRepType = CPA_CY_RSA_PRIVATE_KEY_REP_TYPE_2;
1376    ret  = IntelQaAllocFlatBuffer(&privateKey->privateKeyRep1.modulusN,
1377        keySz, dev->heap);
1378    ret += IntelQaAllocFlatBuffer(&privateKey->privateKeyRep1.privateExponentD,
1379        keySz, dev->heap);
1380    ret += IntelQaAllocFlatBuffer(&privateKey->privateKeyRep2.exponent1Dp,
1381        primeSz, dev->heap);
1382    ret += IntelQaAllocFlatBuffer(&privateKey->privateKeyRep2.exponent2Dq,
1383        primeSz, dev->heap);
1384    ret += IntelQaAllocFlatBuffer(&privateKey->privateKeyRep2.coefficientQInv,
1385        primeSz, dev->heap);
1386    if (ret != 0) {
1387        ret = MEMORY_E; goto exit;
1388    }
1389
1390    /* setup public key */
1391    ret  = IntelQaAllocFlatBuffer(&publicKey->modulusN, keySz, dev->heap);
1392    ret += IntelQaAllocFlatBuffer(&publicKey->publicExponentE, sizeof(long),
1393        dev->heap);
1394    if (ret != 0) {
1395        ret = MEMORY_E; goto exit;
1396    }
1397
1398    /* populate exponent */
1399    publicKey->publicExponentE.pData[3] = (e >> 24) & 0xFF;
1400    publicKey->publicExponentE.pData[2] = (e >> 16) & 0xFF;
1401    publicKey->publicExponentE.pData[1] = (e >> 8)  & 0xFF;
1402    publicKey->publicExponentE.pData[0] =  e        & 0xFF;
1403    publicKey->publicExponentE.dataLenInBytes =
1404        publicKey->publicExponentE.pData[3] ? 4 :
1405        publicKey->publicExponentE.pData[2] ? 3 :
1406        publicKey->publicExponentE.pData[1] ? 2 :
1407        publicKey->publicExponentE.pData[0] ? 1 : 0;
1408
1409    /* populate primes P and Q */
1410    privateKey->privateKeyRep2.prime1P = prime1P;
1411    privateKey->privateKeyRep2.prime2Q = prime2Q;
1412
1413    /* setup operation data */
1414    opData->version = CPA_CY_RSA_VERSION_TWO_PRIME;
1415    opData->privateKeyRepType = CPA_CY_RSA_PRIVATE_KEY_REP_TYPE_2;
1416    opData->modulusLenInBytes = keySz;
1417    opData->prime1P = privateKey->privateKeyRep2.prime1P;
1418    opData->prime2Q = privateKey->privateKeyRep2.prime2Q;
1419    opData->publicExponentE = publicKey->publicExponentE;
1420
1421    /* parameters required for output callback */
1422    dev->qat.op.rsa_keygen.rsakey = key;
1423    IntelQaOpInit(dev, IntelQaRsaKeyGenFree);
1424
1425    /* perform RSA key generation */
1426    do {
1427        status = cpaCyRsaGenKey(dev->qat.handle,
1428                                callback,
1429                                dev,
1430                                opData,
1431                                privateKey,
1432                                publicKey);
1433    } while (IntelQaHandleCpaStatus(dev, status, &ret, 0,
1434        (void*)callback, &retryCount));
1435
1436exit:
1437
1438    if (ret != 0) {
1439        printf("cpaCyRsaGenKey failed! dev %p, status %d, ret %d\n",
1440            dev, status, ret);
1441    }
1442
1443    IntelQaRsaKeyGenFree(dev);
1444
1445    return ret;
1446}
1447#endif /* WOLFSSL_KEY_GEN */
1448
1449static void IntelQaRsaPrivateFree(WC_ASYNC_DEV* dev)
1450{
1451    CpaCyRsaDecryptOpData* opData = &dev->qat.op.rsa_priv.opData;
1452    CpaFlatBuffer *outBuf = &dev->qat.op.rsa_priv.outBuf;
1453
1454    if (opData) {
1455        if (opData->inputData.pData) {
1456            XFREE(opData->inputData.pData, dev->heap, DYNAMIC_TYPE_ASYNC_NUMA);
1457            opData->inputData.pData = NULL;
1458        }
1459        if (opData->pRecipientPrivateKey) {
1460            XMEMSET(opData->pRecipientPrivateKey, 0,
1461                sizeof(CpaCyRsaPrivateKey));
1462        }
1463        XMEMSET(opData, 0, sizeof(CpaCyRsaDecryptOpData));
1464    }
1465    if (outBuf) {
1466        if (outBuf->pData) {
1467            XFREE(outBuf->pData, dev->heap, DYNAMIC_TYPE_ASYNC_NUMA);
1468            outBuf->pData = NULL;
1469        }
1470        XMEMSET(outBuf, 0, sizeof(CpaFlatBuffer));
1471    }
1472
1473    /* clear temp pointers */
1474    dev->qat.out = NULL;
1475    dev->qat.outLenPtr = NULL;
1476}
1477
1478static void IntelQaRsaPrivateCallback(void *pCallbackTag,
1479        CpaStatus status, void *pOpdata, CpaFlatBuffer *pOut)
1480{
1481    WC_ASYNC_DEV* dev = (WC_ASYNC_DEV*)pCallbackTag;
1482    CpaCyRsaDecryptOpData* opData = (CpaCyRsaDecryptOpData*)pOpdata;
1483    int ret = ASYNC_OP_E;
1484
1485#ifdef QAT_DEBUG
1486    printf("IntelQaRsaPrivateCallback: dev %p, status %d, len %d\n",
1487        dev, status, pOut->dataLenInBytes);
1488#endif
1489
1490    if (status == CPA_STATUS_SUCCESS) {
1491        /* validate returned output */
1492
1493        if (dev->qat.outLenPtr) {
1494            if (pOut->dataLenInBytes > *dev->qat.outLenPtr) {
1495                pOut->dataLenInBytes = *dev->qat.outLenPtr;
1496            }
1497            *dev->qat.outLenPtr = pOut->dataLenInBytes;
1498        }
1499
1500        /* return data */
1501        if (dev->qat.out && dev->qat.out != pOut->pData) {
1502            XMEMCPY(dev->qat.out, pOut->pData, pOut->dataLenInBytes);
1503        }
1504
1505        /* mark event result */
1506        ret = 0; /* success */
1507    }
1508    (void)opData;
1509
1510    /* set return code to mark complete */
1511    dev->qat.ret = ret;
1512}
1513
1514int IntelQaRsaPrivate(WC_ASYNC_DEV* dev,
1515                    const byte* in, word32 inLen,
1516                    WC_BIGINT* d, WC_BIGINT* n,
1517                    byte* out, word32* outLen)
1518{
1519    int ret = 0, retryCount = 0;
1520    CpaStatus status = CPA_STATUS_SUCCESS;
1521    CpaCyRsaPrivateKey* privateKey = NULL;
1522    CpaCyRsaDecryptOpData* opData = NULL;
1523    CpaFlatBuffer* outBuf = NULL;
1524    CpaCyGenFlatBufCbFunc callback = IntelQaRsaPrivateCallback;
1525
1526    if (dev == NULL || in == NULL || inLen == 0 || out == NULL ||
1527            outLen == NULL) {
1528        return BAD_FUNC_ARG;
1529    }
1530
1531#ifdef QAT_DEBUG
1532    printf("IntelQaRsaPrivate: dev %p, in %p (%d), out %p\n",
1533        dev, in, inLen, out);
1534#endif
1535
1536    /* setup operation */
1537    opData = &dev->qat.op.rsa_priv.opData;
1538    outBuf = &dev->qat.op.rsa_priv.outBuf;
1539    privateKey = &dev->qat.op.rsa_priv.privateKey;
1540
1541    /* init variables */
1542    XMEMSET(opData, 0, sizeof(CpaCyRsaDecryptOpData));
1543    XMEMSET(outBuf, 0, sizeof(CpaFlatBuffer));
1544    XMEMSET(privateKey, 0, sizeof(CpaCyRsaPrivateKey));
1545
1546    /* assign buffers */
1547    ret =  IntelQaBigIntToFlatBuffer(d,
1548        &privateKey->privateKeyRep1.privateExponentD);
1549    ret += IntelQaBigIntToFlatBuffer(n, &privateKey->privateKeyRep1.modulusN);
1550    if (ret != 0) {
1551        ret = BAD_FUNC_ARG; goto exit;
1552    }
1553
1554    /* make sure output length is at least modulus len */
1555    if (*outLen < n->len) {
1556        ret = BAD_FUNC_ARG; goto exit;
1557    }
1558
1559    /* make sure outLen is not more than inLen */
1560    if (*outLen > inLen) {
1561        *outLen = inLen;
1562    }
1563
1564    opData->inputData.dataLenInBytes = inLen;
1565    opData->inputData.pData = (Cpa8U*)XREALLOC((byte*)in, inLen, dev->heap,
1566        DYNAMIC_TYPE_ASYNC_NUMA);
1567
1568    outBuf->dataLenInBytes = *outLen;
1569    outBuf->pData = (Cpa8U*)XREALLOC(out, *outLen, dev->heap, DYNAMIC_TYPE_ASYNC_NUMA);
1570
1571    /* check allocations */
1572    if (opData->inputData.pData == NULL || outBuf->pData == NULL) {
1573        ret = MEMORY_E; goto exit;
1574    }
1575
1576    /* setup private key */
1577    privateKey->version = CPA_CY_RSA_VERSION_TWO_PRIME;
1578    privateKey->privateKeyRepType = CPA_CY_RSA_PRIVATE_KEY_REP_TYPE_1;
1579
1580    /* assign private key to private op data */
1581    opData->pRecipientPrivateKey = privateKey;
1582
1583    /* store info needed for output */
1584    dev->qat.out = out;
1585    dev->qat.outLenPtr = outLen;
1586    IntelQaOpInit(dev, IntelQaRsaPrivateFree);
1587
1588    /* perform RSA decrypt */
1589    do {
1590        status = cpaCyRsaDecrypt(dev->qat.handle,
1591                                callback,
1592                                dev,
1593                                opData,
1594                                outBuf);
1595    } while (IntelQaHandleCpaStatus(dev, status, &ret, QAT_RSA_ASYNC,
1596        (void*)callback, &retryCount));
1597
1598    if (ret == WC_PENDING_E)
1599        return ret;
1600
1601exit:
1602
1603    if (ret != 0) {
1604        printf("cpaCyRsaDecrypt failed! dev %p, status %d, ret %d\n",
1605            dev, status, ret);
1606    }
1607
1608    /* handle cleanup */
1609    IntelQaRsaPrivateFree(dev);
1610
1611    return ret;
1612}
1613
1614int IntelQaRsaCrtPrivate(WC_ASYNC_DEV* dev,
1615                    const byte* in, word32 inLen,
1616                    WC_BIGINT* p, WC_BIGINT* q,
1617                    WC_BIGINT* dP, WC_BIGINT* dQ,
1618                    WC_BIGINT* qInv,
1619                    byte* out, word32* outLen)
1620{
1621    int ret = 0, retryCount = 0;
1622    CpaStatus status = CPA_STATUS_SUCCESS;
1623    CpaCyRsaPrivateKey* privateKey = NULL;
1624    CpaCyRsaDecryptOpData* opData = NULL;
1625    CpaFlatBuffer* outBuf = NULL;
1626    CpaCyGenFlatBufCbFunc callback = IntelQaRsaPrivateCallback;
1627
1628    if (dev == NULL || in == NULL || inLen == 0 || out == NULL ||
1629            outLen == NULL) {
1630        return BAD_FUNC_ARG;
1631    }
1632
1633#ifdef QAT_DEBUG
1634    printf("IntelQaRsaCrtPrivate: dev %p, in %p (%d), out %p\n",
1635        dev, in, inLen, out);
1636#endif
1637
1638    /* setup operation */
1639    opData = &dev->qat.op.rsa_priv.opData;
1640    outBuf = &dev->qat.op.rsa_priv.outBuf;
1641    privateKey = &dev->qat.op.rsa_priv.privateKey;
1642
1643    /* init variables */
1644    XMEMSET(opData, 0, sizeof(CpaCyRsaDecryptOpData));
1645    XMEMSET(outBuf, 0, sizeof(CpaFlatBuffer));
1646    XMEMSET(privateKey, 0, sizeof(CpaCyRsaPrivateKey));
1647
1648    /* assign buffers */
1649    ret =  IntelQaBigIntToFlatBuffer(p, &privateKey->privateKeyRep2.prime1P);
1650    ret += IntelQaBigIntToFlatBuffer(q, &privateKey->privateKeyRep2.prime2Q);
1651    ret += IntelQaBigIntToFlatBuffer(dP,
1652        &privateKey->privateKeyRep2.exponent1Dp);
1653    ret += IntelQaBigIntToFlatBuffer(dQ,
1654        &privateKey->privateKeyRep2.exponent2Dq);
1655    ret += IntelQaBigIntToFlatBuffer(qInv,
1656        &privateKey->privateKeyRep2.coefficientQInv);
1657    if (ret != 0) {
1658        ret = BAD_FUNC_ARG; goto exit;
1659    }
1660
1661    /* make sure output length is at least p len */
1662    if (*outLen < p->len)
1663        return BAD_FUNC_ARG;
1664
1665    /* make sure outLen is not more than inLen */
1666    if (*outLen > inLen)
1667        *outLen = inLen;
1668
1669    opData->inputData.dataLenInBytes = inLen;
1670    opData->inputData.pData = (Cpa8U*)XREALLOC((byte*)in, inLen, dev->heap,
1671        DYNAMIC_TYPE_ASYNC_NUMA);
1672
1673    outBuf->dataLenInBytes = *outLen;
1674    outBuf->pData = (Cpa8U*)XREALLOC(out, *outLen, dev->heap, DYNAMIC_TYPE_ASYNC_NUMA);
1675
1676    /* check allocations */
1677    if (opData->inputData.pData == NULL || outBuf->pData == NULL) {
1678        ret = MEMORY_E; goto exit;
1679    }
1680
1681    /* setup private key */
1682    privateKey->version = CPA_CY_RSA_VERSION_TWO_PRIME;
1683    privateKey->privateKeyRepType = CPA_CY_RSA_PRIVATE_KEY_REP_TYPE_2;
1684
1685    /* assign private key to private op data */
1686    opData->pRecipientPrivateKey = privateKey;
1687
1688    /* store info needed for output */
1689    dev->qat.out = out;
1690    dev->qat.outLenPtr = outLen;
1691    IntelQaOpInit(dev, IntelQaRsaPrivateFree);
1692
1693    /* perform RSA CRT decrypt */
1694    do {
1695        status = cpaCyRsaDecrypt(dev->qat.handle,
1696                                callback,
1697                                dev,
1698                                opData,
1699                                outBuf);
1700    } while (IntelQaHandleCpaStatus(dev, status, &ret, QAT_RSA_ASYNC,
1701        (void*)callback, &retryCount));
1702
1703    if (ret == WC_PENDING_E)
1704        return ret;
1705
1706exit:
1707
1708    if (ret != 0) {
1709        printf("cpaCyRsaDecrypt CRT failed! dev %p, status %d, ret %d\n",
1710            dev, status, ret);
1711    }
1712
1713    /* handle cleanup */
1714    IntelQaRsaPrivateFree(dev);
1715
1716    return ret;
1717}
1718
1719static void IntelQaRsaPublicFree(WC_ASYNC_DEV* dev)
1720{
1721    CpaCyRsaEncryptOpData* opData = &dev->qat.op.rsa_pub.opData;
1722    CpaFlatBuffer* outBuf = &dev->qat.op.rsa_pub.outBuf;
1723
1724    if (opData) {
1725        if (opData->inputData.pData) {
1726            XFREE(opData->inputData.pData, dev->heap, DYNAMIC_TYPE_ASYNC_NUMA);
1727            opData->inputData.pData = NULL;
1728        }
1729        XMEMSET(opData, 0, sizeof(CpaCyRsaEncryptOpData));
1730    }
1731    if (outBuf) {
1732        if (outBuf->pData) {
1733            XFREE(outBuf->pData, dev, DYNAMIC_TYPE_ASYNC_NUMA64);
1734            outBuf->pData = NULL;
1735        }
1736        XMEMSET(outBuf, 0, sizeof(CpaFlatBuffer));
1737    }
1738
1739    /* clear temp pointers */
1740    dev->qat.out = NULL;
1741    dev->qat.outLenPtr = NULL;
1742}
1743
1744static void IntelQaRsaPublicCallback(void *pCallbackTag,
1745        CpaStatus status, void *pOpdata, CpaFlatBuffer *pOut)
1746{
1747    WC_ASYNC_DEV* dev = (WC_ASYNC_DEV*)pCallbackTag;
1748    CpaCyRsaEncryptOpData* opData = (CpaCyRsaEncryptOpData*)pOpdata;
1749    int ret = ASYNC_OP_E;
1750
1751#ifdef QAT_DEBUG
1752    printf("IntelQaRsaPublicCallback: dev %p, status %d, len %d\n",
1753        dev, status, pOut->dataLenInBytes);
1754#endif
1755
1756    if (status == CPA_STATUS_SUCCESS) {
1757        /* validate returned output */
1758        if (dev->qat.outLenPtr) {
1759            if (pOut->dataLenInBytes > *dev->qat.outLenPtr) {
1760                pOut->dataLenInBytes = *dev->qat.outLenPtr;
1761            }
1762            *dev->qat.outLenPtr = pOut->dataLenInBytes;
1763        }
1764
1765        /* return data */
1766        if (dev->qat.out && dev->qat.out != pOut->pData) {
1767            XMEMCPY(dev->qat.out, pOut->pData, pOut->dataLenInBytes);
1768        }
1769
1770        /* mark event result */
1771        ret = 0; /* success */
1772    }
1773    (void)opData;
1774
1775    /* set return code to mark complete */
1776    dev->qat.ret = ret;
1777}
1778
1779int IntelQaRsaPublic(WC_ASYNC_DEV* dev,
1780                    const byte* in, word32 inLen,
1781                    WC_BIGINT* e, WC_BIGINT* n,
1782                    byte* out, word32* outLen)
1783{
1784    int ret = 0, retryCount = 0;
1785    CpaStatus status = CPA_STATUS_SUCCESS;
1786    CpaCyRsaPublicKey* publicKey = NULL;
1787    CpaCyRsaEncryptOpData* opData = NULL;
1788    CpaFlatBuffer* outBuf = NULL;
1789    CpaCyGenFlatBufCbFunc callback = IntelQaRsaPublicCallback;
1790
1791    if (dev == NULL || in == NULL || inLen == 0 || out == NULL ||
1792            outLen == NULL) {
1793        return BAD_FUNC_ARG;
1794    }
1795
1796#ifdef QAT_DEBUG
1797    printf("IntelQaRsaPublic: dev %p, in %p (%d), out %p\n",
1798        dev, in, inLen, out);
1799#endif
1800
1801    /* setup operation */
1802    opData = &dev->qat.op.rsa_pub.opData;
1803    outBuf = &dev->qat.op.rsa_pub.outBuf;
1804    publicKey = &dev->qat.op.rsa_pub.publicKey;
1805
1806    /* init variables */
1807    XMEMSET(opData, 0, sizeof(CpaCyRsaEncryptOpData));
1808    XMEMSET(outBuf, 0, sizeof(CpaFlatBuffer));
1809    XMEMSET(publicKey, 0, sizeof(CpaCyRsaPublicKey));
1810
1811    /* assign buffers */
1812    ret =  IntelQaBigIntToFlatBuffer(e, &publicKey->publicExponentE);
1813    ret += IntelQaBigIntToFlatBuffer(n, &publicKey->modulusN);
1814    if (ret != 0) {
1815        ret = BAD_FUNC_ARG; goto exit;
1816    }
1817
1818    /* make sure output length is at least modulus len */
1819    if (*outLen < n->len)
1820        return BAD_FUNC_ARG;
1821
1822    /* make sure output len is set to modulus size */
1823    *outLen = n->len;
1824
1825    opData->inputData.dataLenInBytes = inLen;
1826    opData->inputData.pData = (Cpa8U*)XREALLOC((byte*)in, inLen, dev->heap,
1827        DYNAMIC_TYPE_ASYNC_NUMA);
1828
1829    outBuf->dataLenInBytes = *outLen;
1830    outBuf->pData = (Cpa8U*)XREALLOC(out, *outLen, dev->heap,
1831        DYNAMIC_TYPE_ASYNC_NUMA64);
1832
1833    /* check allocations */
1834    if (opData->inputData.pData == NULL || outBuf->pData == NULL) {
1835        ret = MEMORY_E; goto exit;
1836    }
1837
1838    /* assign public key to public op data */
1839    opData->pPublicKey = publicKey;
1840
1841    /* store info needed for output */
1842    dev->qat.out = out;
1843    dev->qat.outLenPtr = outLen;
1844    IntelQaOpInit(dev, IntelQaRsaPublicFree);
1845
1846    /* perform RSA encrypt */
1847    do {
1848        status = cpaCyRsaEncrypt(dev->qat.handle,
1849                                callback,
1850                                dev,
1851                                opData,
1852                                outBuf);
1853    } while (IntelQaHandleCpaStatus(dev, status, &ret, QAT_RSA_ASYNC,
1854        (void*)callback, &retryCount));
1855
1856    if (ret == WC_PENDING_E)
1857        return ret;
1858
1859exit:
1860
1861    if (ret != 0) {
1862        printf("cpaCyRsaEncrypt failed! dev %p, status %d, ret %d\n",
1863            dev, status, ret);
1864    }
1865
1866    /* handle cleanup */
1867    IntelQaRsaPublicFree(dev);
1868
1869    return ret;
1870}
1871
1872static void IntelQaRsaModExpFree(WC_ASYNC_DEV* dev)
1873{
1874    CpaCyLnModExpOpData* opData = &dev->qat.op.rsa_modexp.opData;
1875    CpaFlatBuffer* target = &dev->qat.op.rsa_modexp.target;
1876
1877    if (opData) {
1878        if (opData->base.pData) {
1879            XFREE(opData->base.pData, dev->heap, DYNAMIC_TYPE_ASYNC_NUMA);
1880            opData->base.pData = NULL;
1881        }
1882        XMEMSET(opData, 0, sizeof(CpaCyLnModExpOpData));
1883    }
1884    if (target) {
1885        if (target->pData)
1886            XFREE(target->pData, dev->heap, DYNAMIC_TYPE_ASYNC_NUMA);
1887        XMEMSET(target, 0, sizeof(CpaFlatBuffer));
1888    }
1889
1890    /* clear temp pointers */
1891    dev->qat.out = NULL;
1892    dev->qat.outLenPtr = NULL;
1893}
1894
1895static void IntelQaRsaModExpCallback(void *pCallbackTag,
1896        CpaStatus status, void *pOpdata, CpaFlatBuffer *pOut)
1897{
1898    WC_ASYNC_DEV* dev = (WC_ASYNC_DEV*)pCallbackTag;
1899    CpaCyLnModExpOpData* opData = (CpaCyLnModExpOpData*)pOpdata;
1900    int ret = ASYNC_OP_E;
1901
1902#ifdef QAT_DEBUG
1903    printf("IntelQaRsaModExpCallback: dev %p, status %d, len %d\n",
1904        dev, status, pOut->dataLenInBytes);
1905#endif
1906
1907    if (status == CPA_STATUS_SUCCESS) {
1908        /* validate returned output */
1909        if (dev->qat.outLenPtr) {
1910            if (pOut->dataLenInBytes > *dev->qat.outLenPtr) {
1911                pOut->dataLenInBytes = *dev->qat.outLenPtr;
1912            }
1913            *dev->qat.outLenPtr = pOut->dataLenInBytes;
1914        }
1915
1916        /* return data */
1917        if (dev->qat.out && dev->qat.out != pOut->pData) {
1918            XMEMCPY(dev->qat.out, pOut->pData, pOut->dataLenInBytes);
1919        }
1920
1921        /* mark event result */
1922        ret = 0; /* success */
1923    }
1924    (void)opData;
1925
1926    /* set return code to mark complete */
1927    dev->qat.ret = ret;
1928}
1929
1930int IntelQaRsaExptMod(WC_ASYNC_DEV* dev,
1931                    const byte* in, word32 inLen,
1932                    WC_BIGINT* e, WC_BIGINT* n,
1933                    byte* out, word32* outLen)
1934{
1935    int ret = 0, retryCount = 0;
1936    CpaStatus status = CPA_STATUS_SUCCESS;
1937    CpaCyLnModExpOpData* opData = NULL;
1938    CpaFlatBuffer* target = NULL;
1939    CpaCyGenFlatBufCbFunc callback = IntelQaRsaModExpCallback;
1940
1941    if (dev == NULL || in == NULL || inLen == 0 || out == NULL) {
1942        return BAD_FUNC_ARG;
1943    }
1944
1945#ifdef QAT_DEBUG
1946    printf("IntelQaRsaExptMod: dev %p, in %p (%d), out %p\n",
1947        dev, in, inLen, out);
1948#endif
1949
1950    /* setup operation */
1951    opData = &dev->qat.op.rsa_modexp.opData;
1952    target = &dev->qat.op.rsa_modexp.target;
1953
1954    /* init variables */
1955    XMEMSET(opData, 0, sizeof(CpaCyLnModExpOpData));
1956    XMEMSET(target, 0, sizeof(CpaFlatBuffer));
1957
1958    /* assign buffers */
1959    ret =  IntelQaBigIntToFlatBuffer(e, &opData->exponent);
1960    ret += IntelQaBigIntToFlatBuffer(n, &opData->modulus);
1961    if (ret != 0) {
1962        ret = BAD_FUNC_ARG; goto exit;
1963    }
1964
1965    opData->base.dataLenInBytes = inLen;
1966    opData->base.pData = (Cpa8U*)XREALLOC((byte*)in, inLen, dev->heap,
1967        DYNAMIC_TYPE_ASYNC_NUMA);
1968
1969    target->dataLenInBytes = *outLen;
1970    target->pData = (Cpa8U*)XREALLOC(out, *outLen, dev->heap,
1971        DYNAMIC_TYPE_ASYNC_NUMA);
1972
1973    /* check allocations */
1974    if (opData->base.pData == NULL || target->pData == NULL) {
1975        ret = MEMORY_E; goto exit;
1976    }
1977
1978    /* store info needed for output */
1979    dev->qat.out = out;
1980    dev->qat.outLenPtr = outLen;
1981    IntelQaOpInit(dev, IntelQaRsaModExpFree);
1982
1983    /* make modexp call async */
1984    do {
1985        status = cpaCyLnModExp(dev->qat.handle,
1986                               callback,
1987                               dev,
1988                               opData,
1989                               target);
1990    } while (IntelQaHandleCpaStatus(dev, status, &ret, QAT_EXPTMOD_ASYNC,
1991        (void*)callback, &retryCount));
1992
1993    if (ret == WC_PENDING_E)
1994        return ret;
1995
1996exit:
1997
1998    if (ret != 0) {
1999        printf("cpaCyLnModExp failed! dev %p, status %d, ret %d\n",
2000            dev, status, ret);
2001    }
2002
2003    /* handle cleanup */
2004    IntelQaRsaModExpFree(dev);
2005
2006    return ret;
2007}
2008#endif /* !NO_RSA */
2009
2010
2011/* -------------------------------------------------------------------------- */
2012/* Symmetric Algos */
2013/* -------------------------------------------------------------------------- */
2014
2015#if defined(QAT_ENABLE_CRYPTO) || defined(QAT_ENABLE_HASH)
2016
2017static int IntelQaSymOpen(WC_ASYNC_DEV* dev, CpaCySymSessionSetupData* setup,
2018    CpaCySymCbFunc callback)
2019{
2020    int ret = 0;
2021    CpaStatus status = CPA_STATUS_SUCCESS;
2022    Cpa32U sessionCtxSize = 0;
2023    IntelQaSymCtx* ctx;
2024
2025    /* arg check */
2026    if (dev == NULL || setup == NULL) {
2027        return BAD_FUNC_ARG;
2028    }
2029
2030    ctx = IntelQaGetSymCtx(dev);
2031
2032    /* Determine size of session context to allocate - use max size */
2033    status = cpaCySymSessionCtxGetSize(dev->qat.handle, setup, &sessionCtxSize);
2034
2035    if (status != CPA_STATUS_SUCCESS || (ctx->symCtxSize > 0 &&
2036                                         ctx->symCtxSize > sessionCtxSize)) {
2037        printf("Symmetric context size error %d! Buf %d, Exp %d\n",
2038            status, ctx->symCtxSize, sessionCtxSize);
2039        return ASYNC_OP_E;
2040    }
2041
2042    /* make sure session context is allocated */
2043    if (ctx->symCtx == NULL) {
2044        /* Allocate session context */
2045        ctx->symCtx = XMALLOC(sessionCtxSize, dev->heap,
2046            DYNAMIC_TYPE_ASYNC_NUMA64);
2047        if (ctx->symCtx == NULL) {
2048            return MEMORY_E;
2049        }
2050    }
2051    ctx->symCtxSize = sessionCtxSize;
2052
2053    if (!ctx->isOpen) {
2054        ctx->isOpen = 1;
2055
2056    #ifdef QAT_DEBUG
2057        printf("IntelQaSymOpen: InitSession dev %p, symCtx %p\n",
2058            dev, ctx->symCtx);
2059    #endif
2060
2061        /* open symmetric session */
2062        status = cpaCySymInitSession(dev->qat.handle, callback, setup,
2063            ctx->symCtx);
2064        if (status != CPA_STATUS_SUCCESS) {
2065            printf("cpaCySymInitSession failed! dev %p, status %d\n",
2066                dev, status);
2067            XFREE(ctx->symCtx, dev->heap, DYNAMIC_TYPE_ASYNC_NUMA64);
2068            ctx->symCtx = NULL;
2069            return ASYNC_INIT_E;
2070        }
2071    }
2072
2073    if (ctx->symCtxSrc == NULL) {
2074        ctx->symCtxSrc = ctx->symCtx;
2075    }
2076
2077#ifdef QAT_DEBUG
2078    printf("IntelQaSymOpen: dev %p, symCtx %p (src %p), symCtxSize %d, "
2079           "isCopy %d, isOpen %d\n",
2080        dev, ctx->symCtx, ctx->symCtxSrc, ctx->symCtxSize, ctx->isCopy,
2081        ctx->isOpen);
2082#endif
2083
2084    return ret;
2085}
2086
2087static int IntelQaSymClose(WC_ASYNC_DEV* dev, int doFree)
2088{
2089    int ret = 0;
2090    CpaStatus status = CPA_STATUS_SUCCESS;
2091    IntelQaSymCtx* ctx;
2092#ifdef QAT_ENABLE_HASH
2093    int isHash;
2094#endif
2095
2096    if (dev == NULL) {
2097        return BAD_FUNC_ARG;
2098    }
2099
2100    ctx = IntelQaGetSymCtx(dev);
2101
2102#ifdef QAT_ENABLE_HASH
2103    isHash = IntelQaDevIsHash(dev);
2104#endif
2105
2106#ifdef QAT_DEBUG
2107    printf("IntelQaSymClose: dev %p, ctx %p, symCtx %p (src %p), "
2108           "symCtxSize %d, isCopy %d, isOpen %d, doFree %d\n",
2109        dev, ctx, ctx->symCtx, ctx->symCtxSrc, ctx->symCtxSize, ctx->isCopy,
2110        ctx->isOpen, doFree);
2111#endif
2112
2113    if (ctx->symCtx == ctx->symCtxSrc && ctx->symCtx != NULL) {
2114        if (ctx->isOpen) {
2115            ctx->isOpen = 0;
2116        #ifdef QAT_DEBUG
2117            printf("IntelQaSymClose: RemoveSession dev %p, symCtx %p\n",
2118                dev, ctx->symCtx);
2119        #endif
2120            status = cpaCySymRemoveSession(dev->qat.handle, ctx->symCtx);
2121            if (status == CPA_STATUS_RETRY) {
2122                printf("cpaCySymRemoveSession retry!\n");
2123                /* treat this as error, since session should not be active */
2124                ret = ASYNC_OP_E;
2125            }
2126            else if (status != CPA_STATUS_SUCCESS) {
2127                printf("cpaCySymRemoveSession failed! status %d\n", status);
2128                ret = ASYNC_OP_E;
2129            }
2130        }
2131    }
2132
2133    if (doFree) {
2134        XFREE(ctx->symCtx, dev->heap, DYNAMIC_TYPE_ASYNC_NUMA64);
2135        ctx->symCtx = NULL;
2136        ctx->symCtxSrc = NULL;
2137        ctx->symCtxSize = 0;
2138    }
2139
2140#ifdef QAT_ENABLE_HASH
2141    /* make sure hash temp buffer is cleared */
2142
2143    if (isHash) {
2144        if (dev->qat.op.hash.tmpIn) {
2145            XFREE(dev->qat.op.hash.tmpIn, dev->heap, DYNAMIC_TYPE_ASYNC_NUMA);
2146        }
2147    }
2148#endif
2149
2150    return ret;
2151}
2152
2153#endif /* QAT_ENABLE_CRYPTO || QAT_ENABLE_HASH */
2154
2155
2156/* -------------------------------------------------------------------------- */
2157/* AES/DES Algo */
2158/* -------------------------------------------------------------------------- */
2159
2160#ifdef QAT_ENABLE_CRYPTO
2161static void IntelQaSymCipherFree(WC_ASYNC_DEV* dev)
2162{
2163    IntelQaSymCtx* ctx = &dev->qat.op.cipher.ctx;
2164    CpaCySymOpData* opData = &ctx->opData;
2165    CpaBufferList* pDstBuffer = &dev->qat.op.cipher.bufferList;
2166
2167    if (opData) {
2168        if (opData->pAdditionalAuthData) {
2169            XFREE(opData->pAdditionalAuthData, dev->heap,
2170                DYNAMIC_TYPE_ASYNC_NUMA);
2171            opData->pAdditionalAuthData = NULL;
2172        }
2173        if (opData->pIv) {
2174            XFREE(opData->pIv, dev->heap, DYNAMIC_TYPE_ASYNC_NUMA);
2175            opData->pIv = NULL;
2176        }
2177        XMEMSET(opData, 0, sizeof(CpaCySymOpData));
2178    }
2179    if (pDstBuffer) {
2180        if (pDstBuffer->pBuffers) {
2181            if (pDstBuffer->pBuffers->pData) {
2182                XFREE(pDstBuffer->pBuffers->pData, dev->heap,
2183                    DYNAMIC_TYPE_ASYNC_NUMA);
2184                pDstBuffer->pBuffers->pData = NULL;
2185            }
2186            XMEMSET(pDstBuffer->pBuffers, 0, sizeof(CpaFlatBuffer));
2187        }
2188        if (pDstBuffer->pPrivateMetaData) {
2189            XFREE(pDstBuffer->pPrivateMetaData, dev->heap,
2190                DYNAMIC_TYPE_ASYNC_NUMA);
2191            pDstBuffer->pPrivateMetaData = NULL;
2192        }
2193        XMEMSET(pDstBuffer, 0, sizeof(CpaBufferList));
2194    }
2195
2196    /* close and free sym context */
2197    IntelQaSymClose(dev, 1);
2198
2199    /* clear temp pointers */
2200    dev->qat.out = NULL;
2201    dev->qat.outLen = 0;
2202#ifndef NO_AES
2203    dev->qat.op.cipher.authTag = NULL;
2204    dev->qat.op.cipher.authTagSz = 0;
2205#endif
2206}
2207
2208static void IntelQaSymCipherCallback(void *pCallbackTag, CpaStatus status,
2209    const CpaCySymOp operationType, void *pOpData, CpaBufferList *pDstBuffer,
2210    CpaBoolean verifyResult)
2211{
2212    WC_ASYNC_DEV* dev = (WC_ASYNC_DEV*)pCallbackTag;
2213    CpaCySymOpData* opData = (CpaCySymOpData*)pOpData;
2214    int ret = ASYNC_OP_E;
2215
2216    (void)opData;
2217    (void)pDstBuffer;
2218
2219#ifdef QAT_DEBUG
2220    printf("IntelQaSymCipherCallback: dev %p, type %d, status %d, "
2221           "verifyResult %d, num %d\n",
2222        dev, operationType, status, verifyResult, pDstBuffer->numBuffers);
2223#endif
2224
2225    if (status == CPA_STATUS_SUCCESS) {
2226        /* validate returned output */
2227        if (pDstBuffer && pDstBuffer->numBuffers >= 1) {
2228            /* check length */
2229            word32 outLen = pDstBuffer->pBuffers->dataLenInBytes;
2230
2231            if (outLen > dev->qat.outLen) {
2232                outLen = dev->qat.outLen;
2233            }
2234
2235            /* return data */
2236            if (dev->qat.out && dev->qat.out != pDstBuffer->pBuffers->pData) {
2237                XMEMCPY(dev->qat.out, pDstBuffer->pBuffers->pData, outLen);
2238            }
2239
2240            /* capture IV for next call */
2241            if (dev->qat.op.cipher.iv && dev->qat.op.cipher.ivSz > 0) {
2242                word32 ivSz = dev->qat.op.cipher.ivSz;
2243                if (ivSz > outLen)
2244                    ivSz = outLen;
2245                /* copy last block */
2246                XMEMCPY(dev->qat.op.cipher.iv,
2247                        &pDstBuffer->pBuffers->pData[outLen - ivSz],
2248                        ivSz);
2249            }
2250
2251        #ifndef NO_AES
2252            /* return authTag */
2253            if (dev->qat.op.cipher.authTag &&
2254                dev->qat.op.cipher.authTagSz > 0) {
2255                word32 authTagLen = dev->qat.op.cipher.authTagSz;
2256
2257                /* check authtag length */
2258                if (authTagLen + outLen > pDstBuffer->pBuffers->dataLenInBytes)
2259                    authTagLen = pDstBuffer->pBuffers->dataLenInBytes - outLen;
2260
2261                XMEMCPY(dev->qat.op.cipher.authTag,
2262                    pDstBuffer->pBuffers->pData + outLen, authTagLen);
2263            }
2264        #endif
2265
2266            /* return length */
2267            dev->qat.outLen = outLen;
2268
2269            /* mark event result */
2270            ret = 0; /* success */
2271
2272            /* check verify result for authenticated ciphers (AES-GCM).
2273             * Note: ALGORITHM_CHAINING is only used by AES-GCM in this
2274             * code path. For encrypt verifyResult will be CPA_TRUE. */
2275            if (operationType == CPA_CY_SYM_OP_ALGORITHM_CHAINING &&
2276                    verifyResult == CPA_FALSE) {
2277                /* wipe output - do not return unauthenticated plaintext */
2278                if (dev->qat.out) {
2279                    ForceZero(dev->qat.out, dev->qat.outLen);
2280                }
2281                ret = AES_GCM_AUTH_E;
2282            }
2283        }
2284    }
2285
2286    /* set return code to mark complete */
2287    dev->qat.ret = ret;
2288}
2289
2290static int IntelQaSymCipher(WC_ASYNC_DEV* dev, byte* out, const byte* in,
2291    word32 inOutSz, const byte* key, word32 keySz, byte* iv, word32 ivSz,
2292    CpaCySymOp symOperation, CpaCySymCipherAlgorithm cipherAlgorithm,
2293    CpaCySymCipherDirection cipherDirection,
2294
2295    /* for auth ciphers (CCM or GCM) */
2296    CpaCySymHashAlgorithm hashAlgorithm,
2297    byte* authTag, word32 authTagSz,
2298    const byte* authIn, word32 authInSz)
2299{
2300    int ret, retryCount = 0;
2301    CpaStatus status = CPA_STATUS_SUCCESS;
2302    CpaCySymOpData* opData = NULL;
2303    CpaCySymSessionSetupData setup;
2304    const Cpa32U numBuffers = 1;
2305    CpaBufferList* bufferList = NULL;
2306    CpaFlatBuffer* flatBuffer = NULL;
2307    CpaCySymCbFunc callback = IntelQaSymCipherCallback;
2308    Cpa8U* ivBuf = NULL;
2309    Cpa8U* dataBuf = NULL;
2310    Cpa32U dataLen = inOutSz;
2311    Cpa8U* metaBuf = NULL;
2312    Cpa32U metaSize = 0;
2313    Cpa8U* authInBuf = NULL;
2314    Cpa32U authInSzAligned = authInSz;
2315    IntelQaSymCtx* ctx;
2316
2317#ifdef QAT_DEBUG
2318    printf("IntelQaSymCipher: dev %p, out %p, in %p, inOutSz %d, op %d, "
2319           "algo %d, dir %d, hash %d\n",
2320        dev, out, in, inOutSz, symOperation, cipherAlgorithm, cipherDirection,
2321        hashAlgorithm);
2322#endif
2323
2324    /* check args */
2325    if (out == NULL || in == NULL || inOutSz == 0 ||
2326        key == NULL || keySz == 0 || iv == NULL || ivSz == 0) {
2327        return BAD_FUNC_ARG;
2328    }
2329    if (hashAlgorithm != CPA_CY_SYM_HASH_NONE &&
2330        (authTag == NULL || authTagSz == 0)) {
2331        return BAD_FUNC_ARG;
2332    }
2333
2334    /* get meta size */
2335    status = cpaCyBufferListGetMetaSize(dev->qat.handle, numBuffers, &metaSize);
2336    if (status != CPA_STATUS_SUCCESS && metaSize <= 0) {
2337        ret = BUFFER_E; goto exit;
2338    }
2339
2340    /* if authtag provided then it will be appended to end of input */
2341    if (authTag && authTagSz > 0) {
2342        dataLen += authTagSz;
2343    }
2344
2345    /* allocate buffers */
2346    ctx = &dev->qat.op.cipher.ctx;
2347    opData = &ctx->opData;
2348    bufferList = &dev->qat.op.cipher.bufferList;
2349    flatBuffer = &dev->qat.op.cipher.flatBuffer;
2350    metaBuf = (Cpa8U*)XMALLOC(metaSize, dev->heap, DYNAMIC_TYPE_ASYNC_NUMA);
2351    dataBuf = (Cpa8U*)XREALLOC((byte*)in, dataLen, dev->heap,
2352        DYNAMIC_TYPE_ASYNC_NUMA);
2353    ivBuf = (Cpa8U*)XREALLOC((byte*)iv, AES_BLOCK_SIZE, dev->heap,
2354        DYNAMIC_TYPE_ASYNC_NUMA);
2355
2356    /* check allocations */
2357    if (ivBuf == NULL || metaBuf == NULL || dataBuf == NULL) {
2358        ret = MEMORY_E; goto exit;
2359    }
2360
2361    /* AAD */
2362    if (authIn && authInSz > 0) {
2363        /* make sure AAD is block aligned */
2364        if (authInSzAligned % AES_BLOCK_SIZE) {
2365            authInSzAligned += AES_BLOCK_SIZE -
2366                (authInSzAligned % AES_BLOCK_SIZE);
2367        }
2368
2369        authInBuf = (Cpa8U*)XREALLOC((byte*)authIn, authInSzAligned, dev->heap,
2370            DYNAMIC_TYPE_ASYNC_NUMA);
2371        if (authInBuf == NULL) {
2372            ret = MEMORY_E; goto exit;
2373        }
2374        /* clear remainder */
2375        XMEMSET(authInBuf + authInSz, 0, authInSzAligned - authInSz);
2376    }
2377
2378    /* init buffers */
2379    XMEMSET(&setup, 0, sizeof(CpaCySymSessionSetupData));
2380    XMEMSET(opData, 0, sizeof(CpaCySymOpData));
2381    XMEMSET(bufferList, 0, sizeof(CpaBufferList));
2382    XMEMSET(flatBuffer, 0, sizeof(CpaFlatBuffer));
2383    XMEMSET(metaBuf, 0, metaSize);
2384
2385    bufferList->pBuffers = flatBuffer;
2386    bufferList->numBuffers = numBuffers;
2387    bufferList->pPrivateMetaData = metaBuf;
2388    flatBuffer->dataLenInBytes = dataLen;
2389    flatBuffer->pData = dataBuf;
2390
2391    /* setup */
2392    setup.sessionPriority = CPA_CY_PRIORITY_NORMAL;
2393    setup.symOperation = symOperation;
2394    setup.cipherSetupData.cipherAlgorithm = cipherAlgorithm;
2395    setup.cipherSetupData.cipherKeyLenInBytes = keySz;
2396    setup.cipherSetupData.pCipherKey = (byte*)key;
2397    setup.cipherSetupData.cipherDirection = cipherDirection;
2398
2399    /* setup auth ciphers */
2400    if (hashAlgorithm != CPA_CY_SYM_HASH_NONE) {
2401        setup.algChainOrder =
2402            (cipherDirection == CPA_CY_SYM_CIPHER_DIRECTION_ENCRYPT) ?
2403                CPA_CY_SYM_ALG_CHAIN_ORDER_CIPHER_THEN_HASH :
2404                CPA_CY_SYM_ALG_CHAIN_ORDER_HASH_THEN_CIPHER;
2405
2406        setup.hashSetupData.hashAlgorithm = hashAlgorithm;
2407        setup.hashSetupData.hashMode = CPA_CY_SYM_HASH_MODE_AUTH;
2408        setup.hashSetupData.digestResultLenInBytes = authTagSz;
2409        setup.hashSetupData.authModeSetupData.aadLenInBytes = authInSz;
2410
2411        setup.digestIsAppended = CPA_TRUE;
2412        if (cipherDirection == CPA_CY_SYM_CIPHER_DIRECTION_DECRYPT) {
2413            setup.verifyDigest = CPA_TRUE;
2414        }
2415    }
2416
2417    /* open session */
2418    ret = IntelQaSymOpen(dev, &setup, callback);
2419    if (ret != 0) {
2420        goto exit;
2421    }
2422
2423    /* operation data */
2424    opData->sessionCtx = ctx->symCtx;
2425    opData->packetType = CPA_CY_SYM_PACKET_TYPE_FULL;
2426    opData->pIv = ivBuf;
2427    opData->ivLenInBytes = ivSz;
2428    opData->cryptoStartSrcOffsetInBytes = 0;
2429    opData->messageLenToCipherInBytes = inOutSz;
2430    if (authIn && authInSz > 0) {
2431        opData->pAdditionalAuthData = authInBuf;
2432    }
2433    if (cipherDirection == CPA_CY_SYM_CIPHER_DIRECTION_DECRYPT) {
2434        if (authTag && authTagSz > 0) {
2435            /* append digest to end of data buffer */
2436            XMEMCPY(flatBuffer->pData + inOutSz, authTag, authTagSz);
2437        }
2438    }
2439
2440    /* store info needed for output */
2441    dev->qat.out = out;
2442    dev->qat.outLen = inOutSz;
2443    /* optional return of next IV */
2444    if (cipherAlgorithm != CPA_CY_SYM_CIPHER_AES_GCM && iv) {
2445        if (ivSz > inOutSz)
2446            ivSz = inOutSz;
2447        if (cipherDirection == CPA_CY_SYM_CIPHER_DIRECTION_ENCRYPT) {
2448            /* capture this on the callback */
2449            dev->qat.op.cipher.iv = iv;
2450            dev->qat.op.cipher.ivSz = ivSz;
2451        }
2452        else {
2453            /* capture last block of input as next IV */
2454            XMEMCPY(iv, &in[inOutSz - ivSz], ivSz);
2455        }
2456    }
2457    if (cipherDirection == CPA_CY_SYM_CIPHER_DIRECTION_ENCRYPT) {
2458        dev->qat.op.cipher.authTag = authTag;
2459        dev->qat.op.cipher.authTagSz = authTagSz;
2460    }
2461    else {
2462        dev->qat.op.cipher.authTag = NULL;
2463        dev->qat.op.cipher.authTagSz = 0;
2464    }
2465    IntelQaOpInit(dev, IntelQaSymCipherFree);
2466
2467    /* perform symmetric AES operation async */
2468    /* use same buffer list for in-place operation */
2469    do {
2470        status = cpaCySymPerformOp(dev->qat.handle,
2471                                   dev,
2472                                   opData,
2473                                   bufferList,
2474                                   bufferList,
2475                                   NULL);
2476    } while (IntelQaHandleCpaStatus(dev, status, &ret, QAT_CIPHER_ASYNC,
2477        (void*)callback, &retryCount));
2478
2479    if (ret == WC_PENDING_E)
2480        return ret;
2481
2482exit:
2483
2484    if (ret != 0) {
2485        printf("cpaCySymPerformOp Cipher failed! dev %p, status %d, ret %d\n",
2486            dev, status, ret);
2487    }
2488
2489    /* handle cleanup */
2490    IntelQaSymCipherFree(dev);
2491
2492    return ret;
2493}
2494
2495#ifdef HAVE_AES_CBC
2496int IntelQaSymAesCbcEncrypt(WC_ASYNC_DEV* dev,
2497            byte* out, const byte* in, word32 sz,
2498            const byte* key, word32 keySz,
2499            byte* iv, word32 ivSz)
2500{
2501    return IntelQaSymCipher(dev, out, in, sz,
2502        key, keySz, iv, ivSz,
2503        CPA_CY_SYM_OP_CIPHER, CPA_CY_SYM_CIPHER_AES_CBC,
2504        CPA_CY_SYM_CIPHER_DIRECTION_ENCRYPT,
2505        CPA_CY_SYM_HASH_NONE, NULL, 0, NULL, 0);
2506}
2507
2508#ifdef HAVE_AES_DECRYPT
2509int IntelQaSymAesCbcDecrypt(WC_ASYNC_DEV* dev,
2510            byte* out, const byte* in, word32 sz,
2511            const byte* key, word32 keySz,
2512            byte* iv, word32 ivSz)
2513{
2514    return IntelQaSymCipher(dev, out, in, sz,
2515        key, keySz, iv, ivSz,
2516        CPA_CY_SYM_OP_CIPHER, CPA_CY_SYM_CIPHER_AES_CBC,
2517        CPA_CY_SYM_CIPHER_DIRECTION_DECRYPT,
2518        CPA_CY_SYM_HASH_NONE, NULL, 0, NULL, 0);
2519}
2520#endif /* HAVE_AES_DECRYPT */
2521#endif /* HAVE_AES_CBC */
2522
2523
2524#ifdef HAVE_AESGCM
2525int IntelQaSymAesGcmEncrypt(WC_ASYNC_DEV* dev,
2526            byte* out, const byte* in, word32 sz,
2527            const byte* key, word32 keySz,
2528            const byte* iv, word32 ivSz,
2529            byte* authTag, word32 authTagSz,
2530            const byte* authIn, word32 authInSz)
2531{
2532    return IntelQaSymCipher(dev, out, in, sz,
2533        key, keySz, (byte*)iv, ivSz,
2534        CPA_CY_SYM_OP_ALGORITHM_CHAINING, CPA_CY_SYM_CIPHER_AES_GCM,
2535        CPA_CY_SYM_CIPHER_DIRECTION_ENCRYPT,
2536        CPA_CY_SYM_HASH_AES_GCM, authTag, authTagSz, authIn, authInSz);
2537}
2538#ifdef HAVE_AES_DECRYPT
2539int IntelQaSymAesGcmDecrypt(WC_ASYNC_DEV* dev,
2540            byte* out, const byte* in, word32 sz,
2541            const byte* key, word32 keySz,
2542            const byte* iv, word32 ivSz,
2543            const byte* authTag, word32 authTagSz,
2544            const byte* authIn, word32 authInSz)
2545{
2546    return IntelQaSymCipher(dev, out, in, sz,
2547        key, keySz, (byte*)iv, ivSz,
2548        CPA_CY_SYM_OP_ALGORITHM_CHAINING, CPA_CY_SYM_CIPHER_AES_GCM,
2549        CPA_CY_SYM_CIPHER_DIRECTION_DECRYPT,
2550        CPA_CY_SYM_HASH_AES_GCM, (byte*)authTag, authTagSz, authIn, authInSz);
2551}
2552#endif /* HAVE_AES_DECRYPT */
2553#endif /* HAVE_AESGCM */
2554
2555#ifndef NO_DES3
2556int IntelQaSymDes3CbcEncrypt(WC_ASYNC_DEV* dev,
2557            byte* out, const byte* in, word32 sz,
2558            const byte* key, word32 keySz,
2559            byte* iv, word32 ivSz)
2560{
2561    return IntelQaSymCipher(dev, out, in, sz,
2562        key, keySz, iv, ivSz,
2563        CPA_CY_SYM_OP_CIPHER, CPA_CY_SYM_CIPHER_3DES_CBC,
2564        CPA_CY_SYM_CIPHER_DIRECTION_ENCRYPT,
2565        CPA_CY_SYM_HASH_NONE, NULL, 0, NULL, 0);
2566}
2567
2568int IntelQaSymDes3CbcDecrypt(WC_ASYNC_DEV* dev,
2569            byte* out, const byte* in, word32 sz,
2570            const byte* key, word32 keySz,
2571            byte* iv, word32 ivSz)
2572{
2573    return IntelQaSymCipher(dev, out, in, sz,
2574        key, keySz, iv, ivSz,
2575        CPA_CY_SYM_OP_CIPHER, CPA_CY_SYM_CIPHER_3DES_CBC,
2576        CPA_CY_SYM_CIPHER_DIRECTION_DECRYPT,
2577        CPA_CY_SYM_HASH_NONE, NULL, 0, NULL, 0);
2578}
2579#endif /* !NO_DES3 */
2580
2581#endif /* QAT_ENABLE_CRYPTO */
2582
2583
2584/* -------------------------------------------------------------------------- */
2585/* Hashing Algo */
2586/* -------------------------------------------------------------------------- */
2587
2588#ifdef QAT_ENABLE_HASH
2589static int IntelQaSymHashGetInfo(CpaCySymHashAlgorithm hashAlgorithm,
2590    Cpa32U* pBlockSize, Cpa32U* pDigestSize)
2591{
2592    Cpa32U blockSize = 0;
2593    Cpa32U digestSize = 0;
2594
2595    switch(hashAlgorithm) {
2596        case CPA_CY_SYM_HASH_MD5:
2597        #ifndef NO_MD5
2598            blockSize = WC_MD5_BLOCK_SIZE;
2599            digestSize = WC_MD5_DIGEST_SIZE;
2600        #endif
2601            break;
2602        case CPA_CY_SYM_HASH_SHA1:
2603        #ifndef NO_SHA
2604            blockSize = WC_SHA_BLOCK_SIZE;
2605            digestSize = WC_SHA_DIGEST_SIZE;
2606        #endif
2607            break;
2608        case CPA_CY_SYM_HASH_SHA224:
2609        #ifdef WOLFSSL_SHA224
2610            blockSize = WC_SHA224_BLOCK_SIZE;
2611            digestSize = WC_SHA224_DIGEST_SIZE;
2612        #endif
2613            break;
2614        case CPA_CY_SYM_HASH_SHA256:
2615        #ifndef NO_SHA256
2616            blockSize = WC_SHA256_BLOCK_SIZE;
2617            digestSize = WC_SHA256_DIGEST_SIZE;
2618        #endif
2619            break;
2620        case CPA_CY_SYM_HASH_SHA384:
2621        #if defined(WOLFSSL_SHA512) && defined(WOLFSSL_SHA384)
2622            blockSize = WC_SHA384_BLOCK_SIZE;
2623            digestSize = WC_SHA384_DIGEST_SIZE;
2624        #endif
2625            break;
2626        case CPA_CY_SYM_HASH_SHA512:
2627        #ifdef WOLFSSL_SHA512
2628            blockSize = WC_SHA512_BLOCK_SIZE;
2629            digestSize = WC_SHA512_DIGEST_SIZE;
2630        #endif
2631            break;
2632    #ifdef QAT_V2
2633        case CPA_CY_SYM_HASH_SHA3_256:
2634        #ifdef WOLFSSL_SHA3
2635            blockSize = WC_SHA3_256_BLOCK_SIZE;
2636            digestSize = WC_SHA3_256_DIGEST_SIZE;
2637        #endif
2638            break;
2639    #endif
2640
2641        /* not supported */
2642        case CPA_CY_SYM_HASH_NONE:
2643        case CPA_CY_SYM_HASH_AES_XCBC:
2644        case CPA_CY_SYM_HASH_AES_CCM:
2645        case CPA_CY_SYM_HASH_AES_GCM:
2646        case CPA_CY_SYM_HASH_KASUMI_F9:
2647        case CPA_CY_SYM_HASH_SNOW3G_UIA2:
2648        case CPA_CY_SYM_HASH_AES_CMAC:
2649        case CPA_CY_SYM_HASH_AES_GMAC:
2650        case CPA_CY_SYM_HASH_AES_CBC_MAC:
2651    #ifdef QAT_V2
2652        case CPA_CY_SYM_HASH_ZUC_EIA3:
2653    #ifdef QAT_V2_4_PLUS
2654        case CPA_CY_SYM_HASH_SHA3_224:
2655        case CPA_CY_SYM_HASH_SHA3_384:
2656        case CPA_CY_SYM_HASH_SHA3_512:
2657        case CPA_CY_SYM_HASH_SHAKE_128:
2658        case CPA_CY_SYM_HASH_SHAKE_256:
2659        case CPA_CY_SYM_HASH_POLY:
2660        case CPA_CY_SYM_HASH_SM3:
2661    #endif /* QAT_V2_4_PLUS */
2662    #endif /* QAT_V2 */
2663        default:
2664            return -1;
2665    }
2666
2667    if (pBlockSize)
2668        *pBlockSize = blockSize;
2669    if (pDigestSize)
2670        *pDigestSize = digestSize;
2671
2672    return 0;
2673}
2674
2675static void IntelQaSymHashFree(WC_ASYNC_DEV* dev)
2676{
2677    IntelQaSymCtx* ctx = &dev->qat.op.hash.ctx;
2678    CpaCySymOpData* opData = &ctx->opData;
2679    CpaBufferList* pDstBuffer = dev->qat.op.hash.srcList;
2680    int idx;
2681
2682    if (opData) {
2683        if (opData->pDigestResult) {
2684            XFREE(opData->pDigestResult, dev->heap, DYNAMIC_TYPE_ASYNC_NUMA);
2685            opData->pDigestResult = NULL;
2686        }
2687        XMEMSET(opData, 0, sizeof(CpaCySymOpData));
2688    }
2689
2690    if (pDstBuffer) {
2691        idx = pDstBuffer->numBuffers;
2692        while (--idx >= 0) {
2693            if (pDstBuffer->pBuffers[idx].pData) {
2694                XFREE(pDstBuffer->pBuffers[idx].pData, dev->heap,
2695                    DYNAMIC_TYPE_ASYNC_NUMA);
2696                pDstBuffer->pBuffers[idx].pData = NULL;
2697            }
2698        }
2699
2700        XFREE(pDstBuffer, dev->heap, DYNAMIC_TYPE_ASYNC_NUMA);
2701    }
2702
2703    /* if final */
2704    if (dev->qat.out) {
2705        int doFree = 0;
2706
2707        /* free any tmp input */
2708        if (dev->qat.op.hash.tmpIn) {
2709            XFREE(dev->qat.op.hash.tmpIn, dev->heap, DYNAMIC_TYPE_ASYNC_NUMA);
2710        }
2711        dev->qat.op.hash.tmpIn = NULL;
2712        dev->qat.op.hash.tmpInSz = 0;
2713        dev->qat.op.hash.tmpInBufSz = 0;
2714
2715        if (ctx->isCopy || ctx->symCtx != ctx->symCtxSrc) {
2716            doFree = 1;
2717        }
2718
2719    #ifdef QAT_DEBUG
2720        printf("IntelQaSymHashFree: dev %p, doFree %d\n", dev, doFree);
2721    #endif
2722
2723        /* close session */
2724        IntelQaSymClose(dev, doFree);
2725    }
2726
2727    /* clear temp pointers */
2728    dev->qat.out = NULL;
2729    dev->qat.outLen = 0;
2730}
2731
2732static void IntelQaSymHashCallback(void *pCallbackTag, CpaStatus status,
2733    const CpaCySymOp operationType, void *pOpData, CpaBufferList *pDstBuffer,
2734    CpaBoolean verifyResult)
2735{
2736    WC_ASYNC_DEV* dev = (WC_ASYNC_DEV*)pCallbackTag;
2737    CpaCySymOpData* opData = (CpaCySymOpData*)pOpData;
2738    int ret = ASYNC_OP_E;
2739
2740    (void)opData;
2741    (void)verifyResult;
2742    (void)pDstBuffer;
2743    (void)operationType;
2744
2745#ifdef QAT_DEBUG
2746    printf("IntelQaSymHashCallback: dev %p, type %d, status %d, "
2747           "verifyResult %d, num %d\n",
2748        dev, operationType, status, verifyResult, pDstBuffer->numBuffers);
2749#endif
2750
2751    if (status == CPA_STATUS_SUCCESS) {
2752        if (dev->qat.out) {
2753            /* is final */
2754
2755            /* return digest */
2756            if (dev->qat.outLen > 0 && dev->qat.out != opData->pDigestResult) {
2757                XMEMCPY(dev->qat.out, opData->pDigestResult, dev->qat.outLen);
2758            }
2759        }
2760
2761        /* mark event result */
2762        ret = 0; /* success */
2763    }
2764
2765    /* set return code to mark complete */
2766    dev->qat.ret = ret;
2767}
2768
2769/* For hash update call with out == NULL */
2770/* For hash final call with out != NULL */
2771/* All input is cached in memory or only sent to hardware on final */
2772#ifndef QAT_HASH_ALLOC_BLOCK_SZ
2773    #define QAT_HASH_ALLOC_BLOCK_SZ 1024
2774#endif
2775static int IntelQaSymHashCache(WC_ASYNC_DEV* dev, byte* out, const byte* in,
2776    word32 inOutSz, CpaCySymHashMode hashMode,
2777    CpaCySymHashAlgorithm hashAlgorithm,
2778
2779    /* For HMAC auth mode only */
2780    Cpa8U* authKey, Cpa32U authKeyLenInBytes)
2781{
2782    int ret, retryCount = 0;
2783    CpaStatus status = CPA_STATUS_SUCCESS;
2784    CpaCySymOpData* opData = NULL;
2785    CpaCySymCbFunc callback = IntelQaSymHashCallback;
2786    CpaBufferList* srcList = NULL;
2787    Cpa32U bufferListSize = 0;
2788    Cpa8U* digestBuf = NULL;
2789    Cpa32U metaSize = 0;
2790    Cpa32U totalMsgSz = 0;
2791    Cpa32U blockSize;
2792    Cpa32U digestSize;
2793    CpaCySymPacketType packetType;
2794    IntelQaSymCtx* ctx;
2795    CpaCySymSessionSetupData setup;
2796    const int bufferCount = 1;
2797
2798    ret = IntelQaSymHashGetInfo(hashAlgorithm, &blockSize, &digestSize);
2799    if (ret != 0) {
2800        return BAD_FUNC_ARG;
2801    }
2802
2803#ifdef QAT_DEBUG
2804    printf("IntelQaSymHashCache: dev %p, out %p, in %p, inOutSz %d, mode %d"
2805        ", algo %d, digSz %d, blkSz %d\n",
2806        dev, out, in, inOutSz, hashMode, hashAlgorithm, digestSize, blockSize);
2807#endif
2808
2809    ctx = &dev->qat.op.hash.ctx;
2810
2811    /* handle input processing */
2812    if (in) {
2813        if (dev->qat.op.hash.tmpIn == NULL) {
2814            dev->qat.op.hash.tmpInSz = 0;
2815            dev->qat.op.hash.tmpInBufSz =
2816                (inOutSz + QAT_HASH_ALLOC_BLOCK_SZ - 1)
2817                       & ~(QAT_HASH_ALLOC_BLOCK_SZ - 1);
2818            if (dev->qat.op.hash.tmpInBufSz == 0)
2819                dev->qat.op.hash.tmpInBufSz = QAT_HASH_ALLOC_BLOCK_SZ;
2820            dev->qat.op.hash.tmpIn = (byte*)XMALLOC(dev->qat.op.hash.tmpInBufSz,
2821                dev->heap, DYNAMIC_TYPE_ASYNC_NUMA);
2822            if (dev->qat.op.hash.tmpIn == NULL) {
2823                ret = MEMORY_E; goto exit;
2824            }
2825        }
2826        /* determine if we need to grow buffer */
2827        else if ((dev->qat.op.hash.tmpInSz + inOutSz) >
2828                                                dev->qat.op.hash.tmpInBufSz) {
2829            byte* oldIn = dev->qat.op.hash.tmpIn;
2830            dev->qat.op.hash.tmpInBufSz = (dev->qat.op.hash.tmpInSz + inOutSz +
2831                QAT_HASH_ALLOC_BLOCK_SZ - 1) & ~(QAT_HASH_ALLOC_BLOCK_SZ - 1);
2832
2833             dev->qat.op.hash.tmpIn = (byte*)XMALLOC(
2834                dev->qat.op.hash.tmpInBufSz,
2835                dev->heap, DYNAMIC_TYPE_ASYNC_NUMA);
2836            if (dev->qat.op.hash.tmpIn == NULL) {
2837                ret = MEMORY_E; goto exit;
2838            }
2839            XMEMCPY(dev->qat.op.hash.tmpIn, oldIn, dev->qat.op.hash.tmpInSz);
2840            XFREE(oldIn, dev->heap, DYNAMIC_TYPE_ASYNC_NUMA);
2841        }
2842
2843        /* copy input to new buffer */
2844        XMEMCPY(&dev->qat.op.hash.tmpIn[dev->qat.op.hash.tmpInSz], in, inOutSz);
2845        dev->qat.op.hash.tmpInSz += inOutSz;
2846
2847        ret = 0; /* success */
2848        goto exit;
2849    }
2850    else if (out != NULL && dev->qat.op.hash.tmpIn == NULL) {
2851        /* QAT requires an input buffer even for an empty hash */
2852        dev->qat.op.hash.tmpInSz = 0;
2853        dev->qat.op.hash.tmpInBufSz = 16; /* use minimum alignment (16 bytes) */
2854        dev->qat.op.hash.tmpIn = (byte*)XMALLOC(dev->qat.op.hash.tmpInBufSz,
2855            dev->heap, DYNAMIC_TYPE_ASYNC_NUMA);
2856        if (dev->qat.op.hash.tmpIn == NULL) {
2857            ret = MEMORY_E; goto exit;
2858        }
2859    }
2860
2861    /* handle output processing */
2862    packetType = CPA_CY_SYM_PACKET_TYPE_FULL;
2863
2864    /* get meta size */
2865    status = cpaCyBufferListGetMetaSize(dev->qat.handle, bufferCount,
2866        &metaSize);
2867    if (status != CPA_STATUS_SUCCESS && metaSize <= 0) {
2868        ret = BUFFER_E; goto exit;
2869    }
2870
2871    /* allocate buffer list */
2872    bufferListSize = sizeof(CpaBufferList) +
2873        (bufferCount * sizeof(CpaFlatBuffer)) + metaSize;
2874    srcList = (CpaBufferList*)XMALLOC(bufferListSize, dev->heap,
2875        DYNAMIC_TYPE_ASYNC_NUMA);
2876    if (srcList == NULL) {
2877        ret = MEMORY_E; goto exit;
2878    }
2879    dev->qat.op.hash.srcList = srcList;
2880    XMEMSET(srcList, 0, bufferListSize);
2881    srcList->pBuffers = (CpaFlatBuffer*)(
2882        (byte*)srcList + sizeof(CpaBufferList));
2883    srcList->pPrivateMetaData = (byte*)srcList + sizeof(CpaBufferList) +
2884        (bufferCount * sizeof(CpaFlatBuffer));
2885
2886    srcList->numBuffers = bufferCount;
2887    srcList->pBuffers[0].dataLenInBytes = dev->qat.op.hash.tmpInSz;
2888    srcList->pBuffers[0].pData = dev->qat.op.hash.tmpIn;
2889    totalMsgSz = dev->qat.op.hash.tmpInSz;
2890
2891    dev->qat.op.hash.tmpInSz = 0;
2892    dev->qat.op.hash.tmpInBufSz = 0;
2893    dev->qat.op.hash.tmpIn = NULL;
2894
2895    /* build output */
2896    if (out) {
2897        /* use blockSize for alloc, but we are only returning digestSize */
2898        digestBuf = (Cpa8U*)XMALLOC(blockSize, dev->heap,
2899            DYNAMIC_TYPE_ASYNC_NUMA);
2900        if (digestBuf == NULL) {
2901            ret = MEMORY_E; goto exit;
2902        }
2903    }
2904
2905    /* setup */
2906    XMEMSET(&setup, 0, sizeof(CpaCySymSessionSetupData));
2907    setup.sessionPriority = CPA_CY_PRIORITY_NORMAL;
2908    setup.symOperation = CPA_CY_SYM_OP_HASH;
2909    setup.partialsNotRequired = CPA_TRUE;
2910    setup.hashSetupData.hashMode = hashMode;
2911    setup.hashSetupData.hashAlgorithm = hashAlgorithm;
2912    setup.hashSetupData.digestResultLenInBytes = digestSize;
2913    setup.hashSetupData.authModeSetupData.authKey = authKey;
2914    setup.hashSetupData.authModeSetupData.authKeyLenInBytes = authKeyLenInBytes;
2915
2916    /* open session */
2917    ret = IntelQaSymOpen(dev, &setup, callback);
2918    if (ret != 0) {
2919        goto exit;
2920    }
2921
2922    /* operation data */
2923    opData = &ctx->opData;
2924    XMEMSET(opData, 0, sizeof(CpaCySymOpData));
2925    opData->sessionCtx = ctx->symCtx;
2926    opData->packetType = packetType;
2927    opData->messageLenToHashInBytes = totalMsgSz;
2928    opData->pDigestResult = digestBuf;
2929
2930    /* store info needed for output */
2931    dev->qat.out = out;
2932    dev->qat.outLen = inOutSz;
2933    IntelQaOpInit(dev, IntelQaSymHashFree);
2934
2935    /* perform symmetric hash operation async */
2936    /* use same buffer list for in-place operation */
2937    do {
2938        status = cpaCySymPerformOp(dev->qat.handle,
2939                                   dev,
2940                                   opData,
2941                                   srcList,
2942                                   srcList,
2943                                   NULL);
2944    } while (IntelQaHandleCpaStatus(dev, status, &ret, QAT_HASH_ASYNC,
2945        (void*)callback, &retryCount));
2946
2947    if (ret == WC_PENDING_E)
2948        return ret;
2949
2950exit:
2951
2952    if (ret != 0) {
2953        printf("cpaCySymPerformOp Hash failed! dev %p, status %d, ret %d\n",
2954            dev, status, ret);
2955
2956        /* handle cleanup */
2957        IntelQaSymHashFree(dev);
2958    }
2959
2960    return ret;
2961}
2962
2963#ifdef QAT_HASH_ENABLE_PARTIAL
2964
2965/* For hash update call with out == NULL */
2966/* For hash final call with out != NULL */
2967static int IntelQaSymHashPartial(WC_ASYNC_DEV* dev, byte* out, const byte* in,
2968    word32 inOutSz, CpaCySymHashMode hashMode,
2969    CpaCySymHashAlgorithm hashAlgorithm,
2970
2971    /* For HMAC auth mode only */
2972    Cpa8U* authKey, Cpa32U authKeyLenInBytes)
2973{
2974    int ret, retryCount = 0, i;
2975    CpaStatus status = CPA_STATUS_SUCCESS;
2976    CpaCySymOpData* opData = NULL;
2977    CpaCySymCbFunc callback = IntelQaSymHashCallback;
2978    CpaBufferList* srcList = NULL;
2979    Cpa32U bufferListSize = 0;
2980    Cpa8U* digestBuf = NULL;
2981    Cpa32U metaSize = 0;
2982    Cpa32U totalMsgSz = 0;
2983    Cpa32U blockSize;
2984    Cpa32U digestSize;
2985    CpaCySymPacketType packetType;
2986    IntelQaSymCtx* ctx;
2987    CpaCySymSessionSetupData setup;
2988
2989    int* bufferCount;
2990    byte** buffers;
2991    word32* buffersSz;
2992
2993    ret = IntelQaSymHashGetInfo(hashAlgorithm, &blockSize, &digestSize);
2994    if (ret != 0) {
2995        return BAD_FUNC_ARG;
2996    }
2997
2998#ifdef QAT_DEBUG
2999    printf("IntelQaSymHashPartial: dev %p, out %p, in %p, inOutSz %d, mode %d, "
3000        "algo %d, digSz %d, blkSz %d\n",
3001        dev, out, in, inOutSz, hashMode, hashAlgorithm, digestSize, blockSize);
3002#endif
3003
3004    ctx = &dev->qat.op.hash.ctx;
3005
3006    bufferCount = &dev->qat.op.hash.bufferCount;
3007    buffers = dev->qat.op.hash.buffers;
3008    buffersSz = dev->qat.op.hash.buffersSz;
3009
3010    /* handle input processing */
3011    if (in) {
3012        /* if tmp has data or input is not block aligned */
3013        if (dev->qat.op.hash.tmpInSz > 0 || inOutSz == 0 ||
3014            (inOutSz % blockSize) != 0) {
3015            /* need to handle unaligned hashing, using local tmp */
3016
3017            /* make sure we have tmpIn allocated */
3018            if (dev->qat.op.hash.tmpIn == NULL) {
3019                dev->qat.op.hash.tmpInSz = 0;
3020                dev->qat.op.hash.tmpIn = XMALLOC(blockSize, dev->heap,
3021                    DYNAMIC_TYPE_ASYNC_NUMA);
3022                if (dev->qat.op.hash.tmpIn == NULL) {
3023                    ret = MEMORY_E; goto exit;
3024                }
3025                dev->qat.op.hash.tmpInBufSz = blockSize;
3026            }
3027
3028            /* setup processing for block aligned part of input or use tmpIn */
3029            if (dev->qat.op.hash.tmpInSz > 0) {
3030                word32 remainSz = blockSize - dev->qat.op.hash.tmpInSz;
3031
3032                /* attempt to fill tmpIn and process block */
3033                if (inOutSz < remainSz) {
3034                    /* not enough to fill buffer */
3035                    XMEMCPY(&dev->qat.op.hash.tmpIn[dev->qat.op.hash.tmpInSz],
3036                        in, inOutSz);
3037                    dev->qat.op.hash.tmpInSz += inOutSz;
3038                }
3039                else {
3040                    /* fill tmp buffer and add */
3041                    XMEMCPY(&dev->qat.op.hash.tmpIn[dev->qat.op.hash.tmpInSz],
3042                        in, remainSz);
3043                    dev->qat.op.hash.tmpInSz += remainSz;
3044                    buffers[*bufferCount] = dev->qat.op.hash.tmpIn;
3045                    buffersSz[*bufferCount] = dev->qat.op.hash.tmpInSz;
3046                    (*bufferCount)++;
3047                    inOutSz -= remainSz;
3048                    in += remainSz;
3049                    dev->qat.op.hash.tmpIn = NULL;
3050                    dev->qat.op.hash.tmpInSz = 0;
3051
3052                    /* use remainder of block aligned */
3053                    if (inOutSz >= blockSize) {
3054                        word32 unalignedSz = (inOutSz % blockSize);
3055                        word32 inSz = inOutSz - unalignedSz;
3056
3057                        buffersSz[*bufferCount] = inSz;
3058                        buffers[*bufferCount] = (byte*)XMALLOC(inSz,
3059                                    dev->heap, DYNAMIC_TYPE_ASYNC_NUMA);
3060                        if (buffers[*bufferCount] == NULL) {
3061                            ret = MEMORY_E; goto exit;
3062                        }
3063                        XMEMCPY(buffers[*bufferCount], (byte*)in, inSz);
3064
3065                        (*bufferCount)++;
3066                        inOutSz -= inSz;
3067                        in += inSz;
3068                    }
3069
3070                    /* save remainder to tmpIn */
3071                    if (inOutSz > 0) {
3072                        dev->qat.op.hash.tmpInSz = 0;
3073                        dev->qat.op.hash.tmpIn = XMALLOC(blockSize, dev->heap,
3074                            DYNAMIC_TYPE_ASYNC_NUMA);
3075                        if (dev->qat.op.hash.tmpIn == NULL) {
3076                            ret = MEMORY_E; goto exit;
3077                        }
3078                        dev->qat.op.hash.tmpInBufSz = blockSize;
3079
3080                        XMEMCPY(dev->qat.op.hash.tmpIn, in, inOutSz);
3081                        dev->qat.op.hash.tmpInSz = inOutSz;
3082                    }
3083                }
3084            }
3085            else {
3086                /* if not enough to fit into blockSize store into tmpIn */
3087                if (inOutSz < blockSize) {
3088                    dev->qat.op.hash.tmpInSz = inOutSz;
3089                    XMEMCPY(dev->qat.op.hash.tmpIn, in, inOutSz);
3090                }
3091                else {
3092                    word32 unalignedSz = (inOutSz % blockSize);
3093                    word32 inSz = inOutSz - unalignedSz;
3094
3095                    buffersSz[*bufferCount] = inSz;
3096                    buffers[*bufferCount] = (byte*)XREALLOC((byte*)in,
3097                        inSz, dev->heap, DYNAMIC_TYPE_ASYNC_NUMA);
3098                    if (buffers[*bufferCount] == NULL) {
3099                        ret = MEMORY_E; goto exit;
3100                    }
3101                    (*bufferCount)++;
3102
3103                    /* store remainder */
3104                    dev->qat.op.hash.tmpInSz = unalignedSz;
3105                    XMEMCPY(dev->qat.op.hash.tmpIn, &in[inSz], unalignedSz);
3106                }
3107            }
3108
3109        }
3110        else {
3111            /* use input directly */
3112            buffersSz[*bufferCount] = inOutSz;
3113            buffers[*bufferCount] = (byte*)XREALLOC((byte*)in,
3114                buffersSz[*bufferCount], dev->heap, DYNAMIC_TYPE_ASYNC_NUMA);
3115            if (buffers[*bufferCount] == NULL) {
3116                ret = MEMORY_E; goto exit;
3117            }
3118            (*bufferCount)++;
3119        }
3120    }
3121
3122    /* determine if early exit is okay */
3123    if (out == NULL) {
3124        /* if not final and no in buffers then exit with success */
3125        if (*bufferCount == 0) {
3126            ret = 0; /* return success */
3127            goto exit;
3128        }
3129
3130        /* for auth must pass in buffer, so leave one in buffer cache */
3131        else if (hashMode == CPA_CY_SYM_HASH_MODE_AUTH && *bufferCount <= 1) {
3132            ret = 0; /* return success */
3133            goto exit;
3134        }
3135    }
3136
3137    /* determine packet type and add any remainder to input processing */
3138    packetType = CPA_CY_SYM_PACKET_TYPE_PARTIAL;
3139    if (out) {
3140        /* if remainder then add it */
3141        if (dev->qat.op.hash.tmpIn) {
3142            /* add buffer and use final hash type */
3143            buffers[*bufferCount] = dev->qat.op.hash.tmpIn;
3144            buffersSz[*bufferCount] = dev->qat.op.hash.tmpInSz;
3145            (*bufferCount)++;
3146            dev->qat.op.hash.tmpIn = NULL;
3147            dev->qat.op.hash.tmpInSz = 0;
3148        }
3149
3150        /* determine if this is full or partial */
3151        if (ctx->symCtxSrc == NULL || (!ctx->isOpen && !ctx->isCopy)) {
3152            packetType = CPA_CY_SYM_PACKET_TYPE_FULL;
3153        }
3154        else {
3155            packetType = CPA_CY_SYM_PACKET_TYPE_LAST_PARTIAL;
3156        }
3157    }
3158
3159    /* get meta size */
3160    status = cpaCyBufferListGetMetaSize(dev->qat.handle, *bufferCount,
3161        &metaSize);
3162    if (status != CPA_STATUS_SUCCESS && metaSize <= 0) {
3163        ret = BUFFER_E; goto exit;
3164    }
3165
3166    /* allocate buffer list */
3167    bufferListSize = sizeof(CpaBufferList) +
3168        (*bufferCount * sizeof(CpaFlatBuffer)) + metaSize;
3169    srcList = XMALLOC(bufferListSize, dev->heap, DYNAMIC_TYPE_ASYNC_NUMA);
3170    if (srcList == NULL) {
3171        ret = MEMORY_E; goto exit;
3172    }
3173    dev->qat.op.hash.srcList = srcList;
3174    XMEMSET(srcList, 0, bufferListSize);
3175    srcList->pBuffers = (CpaFlatBuffer*)(
3176        (byte*)srcList + sizeof(CpaBufferList));
3177    srcList->pPrivateMetaData = (byte*)srcList + sizeof(CpaBufferList) +
3178        (*bufferCount * sizeof(CpaFlatBuffer));
3179    for (i = 0; i < *bufferCount; i++) {
3180        srcList->pBuffers[i].dataLenInBytes = buffersSz[i];
3181        srcList->pBuffers[i].pData = buffers[i];
3182        totalMsgSz += buffersSz[i];
3183    }
3184    srcList->numBuffers = *bufferCount;
3185
3186    /* clear buffer cache */
3187    dev->qat.op.hash.bufferCount = 0;
3188    for (i=0; i<MAX_QAT_HASH_BUFFERS; i++) {
3189        dev->qat.op.hash.buffers[i] = NULL;
3190        dev->qat.op.hash.buffersSz[i] = 0;
3191    }
3192
3193    /* build output */
3194    if (out) {
3195        /* use blockSize for alloc, but we are only returning digestSize */
3196        digestBuf = XMALLOC(blockSize, dev->heap, DYNAMIC_TYPE_ASYNC_NUMA);
3197        if (digestBuf == NULL) {
3198            ret = MEMORY_E; goto exit;
3199        }
3200    }
3201
3202    /* setup */
3203    XMEMSET(&setup, 0, sizeof(CpaCySymSessionSetupData));
3204    setup.sessionPriority = CPA_CY_PRIORITY_NORMAL;
3205    setup.symOperation = CPA_CY_SYM_OP_HASH;
3206    setup.partialsNotRequired = (packetType == CPA_CY_SYM_PACKET_TYPE_FULL) ?
3207        CPA_TRUE : CPA_FALSE;
3208    setup.hashSetupData.hashMode = hashMode;
3209    setup.hashSetupData.hashAlgorithm = hashAlgorithm;
3210    setup.hashSetupData.digestResultLenInBytes = digestSize;
3211    setup.hashSetupData.authModeSetupData.authKey = authKey;
3212    setup.hashSetupData.authModeSetupData.authKeyLenInBytes = authKeyLenInBytes;
3213
3214    /* open session */
3215    ret = IntelQaSymOpen(dev, &setup, callback);
3216    if (ret != 0) {
3217        goto exit;
3218    }
3219
3220    /* workarounds for handling symmetric context copies */
3221    if (packetType == CPA_CY_SYM_PACKET_TYPE_LAST_PARTIAL) {
3222        /* set the partialState for partial  */
3223    #ifdef USE_LAC_SESSION_FOR_STRUCT_OFFSET
3224        word32 parStaOffset = (word32)offsetof(lac_session_desc_t,
3225            partialState);
3226    #else
3227        word32 parStaOffset = (28 * 16);
3228    #endif
3229
3230        /* make sure partialState is partial, try + 16 alignments as well */
3231        for (i = 0; i < 4; i++) {
3232            word32* priorVal = (word32*)((byte*)ctx->symCtx + parStaOffset +
3233                (i * 16));
3234            if (*priorVal == CPA_CY_SYM_PACKET_TYPE_FULL) {
3235                *priorVal = CPA_CY_SYM_PACKET_TYPE_PARTIAL;
3236                break;
3237            }
3238        }
3239    }
3240    if (ctx->symCtx != ctx->symCtxSrc) {
3241        /* copy hash state (digest into new symmetric context) */
3242        byte* symCtxDst = (byte*)ctx->symCtx;
3243        byte* symCtxSrc = (byte*)ctx->symCtxSrc;
3244        /* copy from hashStatePrefixBuffer to end */
3245    #ifdef USE_LAC_SESSION_FOR_STRUCT_OFFSET
3246        const word32 copyRegion = (word32)offsetof(lac_session_desc_t,
3247            hashStatePrefixBuffer);
3248    #else
3249        const word32 copyRegion = (41 * 16);
3250    #endif
3251        XMEMCPY(&symCtxDst[copyRegion], &symCtxSrc[copyRegion],
3252            ctx->symCtxSize - copyRegion);
3253    }
3254
3255    /* operation data */
3256    opData = &ctx->opData;
3257    XMEMSET(opData, 0, sizeof(CpaCySymOpData));
3258    opData->sessionCtx = ctx->symCtx;
3259    opData->packetType = packetType;
3260    opData->messageLenToHashInBytes = totalMsgSz;
3261    opData->pDigestResult = digestBuf;
3262
3263    /* store info needed for output */
3264    dev->qat.out = out;
3265    dev->qat.outLen = inOutSz;
3266    IntelQaOpInit(dev, IntelQaSymHashFree);
3267
3268    /* perform symmetric hash operation async */
3269    /* use same buffer list for in-place operation */
3270    do {
3271        status = cpaCySymPerformOp(dev->qat.handle,
3272                                   dev,
3273                                   opData,
3274                                   srcList,
3275                                   srcList,
3276                                   NULL);
3277    } while (IntelQaHandleCpaStatus(dev, status, &ret, QAT_HASH_ASYNC, callback,
3278        &retryCount));
3279
3280    if (ret == WC_PENDING_E)
3281        return ret;
3282
3283exit:
3284
3285    if (ret != 0) {
3286        printf("cpaCySymPerformOp Hash partial failed! dev %p, status %d, "
3287               "ret %d\n", dev, status, ret);
3288
3289        /* handle cleanup */
3290        IntelQaSymHashFree(dev);
3291    }
3292
3293    return ret;
3294}
3295#endif /* QAT_HASH_ENABLE_PARTIAL */
3296
3297
3298/* For hash update call with out == NULL */
3299/* For hash final call with out != NULL */
3300static int IntelQaSymHash(WC_ASYNC_DEV* dev, byte* out, const byte* in,
3301    word32 inOutSz, CpaCySymHashMode hashMode,
3302    CpaCySymHashAlgorithm hashAlgorithm,
3303
3304    /* For HMAC auth mode only */
3305    Cpa8U* authKey, Cpa32U authKeyLenInBytes)
3306{
3307    /* check args */
3308    if (dev == NULL || (out == NULL && in == NULL) ||
3309                                    hashAlgorithm == CPA_CY_SYM_HASH_NONE) {
3310        return BAD_FUNC_ARG;
3311    }
3312
3313    /* trap call with both in and out set */
3314    if (in != NULL && out != NULL) {
3315        printf("IntelQaSymHash: Cannot call with in and out both set\n");
3316        return BAD_FUNC_ARG;
3317    }
3318
3319    if (inOutSz == 0) {
3320        return 0; /* nothing to do, return success */
3321    }
3322
3323#ifdef QAT_HASH_ENABLE_PARTIAL
3324    if (g_qatCapabilities.supPartial
3325    #ifdef QAT_V2
3326        && hashAlgorithm != CPA_CY_SYM_HASH_SHA3_256
3327    #endif
3328    ) {
3329        return IntelQaSymHashPartial(dev, out, in, inOutSz, hashMode,
3330            hashAlgorithm, authKey, authKeyLenInBytes);
3331    }
3332    else
3333#endif
3334    return IntelQaSymHashCache(dev, out, in, inOutSz, hashMode,
3335        hashAlgorithm, authKey, authKeyLenInBytes);
3336}
3337
3338#ifdef WOLFSSL_SHA512
3339int IntelQaSymSha512(WC_ASYNC_DEV* dev, byte* out, const byte* in, word32 sz)
3340{
3341    return IntelQaSymHash(dev, out, in, sz,
3342        CPA_CY_SYM_HASH_MODE_PLAIN, CPA_CY_SYM_HASH_SHA512, NULL, 0);
3343}
3344
3345#ifdef WOLFSSL_SHA384
3346int IntelQaSymSha384(WC_ASYNC_DEV* dev, byte* out, const byte* in, word32 sz)
3347{
3348    return IntelQaSymHash(dev, out, in, sz,
3349        CPA_CY_SYM_HASH_MODE_PLAIN, CPA_CY_SYM_HASH_SHA384, NULL, 0);
3350}
3351#endif /* WOLFSSL_SHA384 */
3352#endif /* WOLFSSL_SHA512 */
3353
3354#ifndef NO_SHA256
3355int IntelQaSymSha256(WC_ASYNC_DEV* dev, byte* out, const byte* in, word32 sz)
3356{
3357    return IntelQaSymHash(dev, out, in, sz,
3358        CPA_CY_SYM_HASH_MODE_PLAIN, CPA_CY_SYM_HASH_SHA256, NULL, 0);
3359}
3360#ifdef WOLFSSL_SHA224
3361int IntelQaSymSha224(WC_ASYNC_DEV* dev, byte* out, const byte* in, word32 sz)
3362{
3363    return IntelQaSymHash(dev, out, in, sz,
3364        CPA_CY_SYM_HASH_MODE_PLAIN, CPA_CY_SYM_HASH_SHA224, NULL, 0);
3365}
3366#endif /* WOLFSSL_SHA224 */
3367#endif /* !NO_SHA256 */
3368
3369#ifndef NO_SHA
3370int IntelQaSymSha(WC_ASYNC_DEV* dev, byte* out, const byte* in, word32 sz)
3371{
3372    return IntelQaSymHash(dev, out, in, sz,
3373        CPA_CY_SYM_HASH_MODE_PLAIN, CPA_CY_SYM_HASH_SHA1, NULL, 0);
3374}
3375#endif /* !NO_SHA */
3376
3377#ifndef NO_MD5
3378int IntelQaSymMd5(WC_ASYNC_DEV* dev, byte* out, const byte* in, word32 sz)
3379{
3380    return IntelQaSymHash(dev, out, in, sz,
3381        CPA_CY_SYM_HASH_MODE_PLAIN, CPA_CY_SYM_HASH_MD5, NULL, 0);
3382}
3383#endif /* !NO_MD5 */
3384
3385#if defined(WOLFSSL_SHA3) && defined(QAT_V2)
3386int IntelQaSymSha3(WC_ASYNC_DEV* dev, byte* out, const byte* in, word32 sz)
3387{
3388    if (g_qatCapabilities.supSha3) {
3389        return IntelQaSymHash(dev, out, in, sz,
3390            CPA_CY_SYM_HASH_MODE_PLAIN, CPA_CY_SYM_HASH_SHA3_256, NULL, 0);
3391    }
3392    return NOT_COMPILED_IN;
3393}
3394#endif
3395
3396#ifndef NO_HMAC
3397    int IntelQaHmacGetType(int macType, word32* hashAlgorithm)
3398    {
3399        int ret = NOT_COMPILED_IN;
3400
3401        switch (macType) {
3402        #ifndef NO_MD5
3403            case WC_MD5:
3404                if (hashAlgorithm) *hashAlgorithm = CPA_CY_SYM_HASH_MD5;
3405                ret = 0;
3406                break;
3407        #endif
3408        #ifndef NO_SHA
3409            case WC_SHA:
3410                if (hashAlgorithm) *hashAlgorithm = CPA_CY_SYM_HASH_SHA1;
3411                ret = 0;
3412                break;
3413        #endif
3414        #ifdef WOLFSSL_SHA224
3415            case WC_SHA224:
3416                if (hashAlgorithm) *hashAlgorithm = CPA_CY_SYM_HASH_SHA224;
3417                ret = 0;
3418                break;
3419        #endif
3420        #ifndef NO_SHA256
3421            case WC_SHA256:
3422                if (hashAlgorithm) *hashAlgorithm = CPA_CY_SYM_HASH_SHA256;
3423                ret = 0;
3424                break;
3425        #endif
3426        #ifdef WOLFSSL_SHA512
3427        #ifdef WOLFSSL_SHA384
3428            case WC_SHA384:
3429                if (hashAlgorithm) *hashAlgorithm = CPA_CY_SYM_HASH_SHA384;
3430                ret = 0;
3431                break;
3432        #endif
3433            case WC_SHA512:
3434                if (hashAlgorithm) *hashAlgorithm = CPA_CY_SYM_HASH_SHA512;
3435                ret = 0;
3436                break;
3437        #endif
3438        #if defined(WOLFSSL_SHA3) && defined(QAT_V2)
3439            case WC_SHA3_256:
3440                if (g_qatCapabilities.supSha3) {
3441                    if (hashAlgorithm)
3442                        *hashAlgorithm = CPA_CY_SYM_HASH_SHA3_256;
3443                    ret = 0;
3444                }
3445                break;
3446        #endif
3447        #ifdef HAVE_BLAKE2B
3448            case BLAKE2B_ID:
3449        #endif
3450        #ifdef WOLFSSL_SHA3
3451            case WC_SHA3_224:
3452            case WC_SHA3_384:
3453            case WC_SHA3_512:
3454        #endif
3455            default:
3456                ret = NOT_COMPILED_IN;
3457        }
3458        return ret;
3459    }
3460
3461    int IntelQaHmac(struct WC_ASYNC_DEV* dev,
3462        int macType, byte* keyRaw, word16 keyLen,
3463        byte* out, const byte* in, word32 sz)
3464    {
3465        int ret;
3466        CpaCySymHashAlgorithm hashAlgorithm;
3467
3468        ret = IntelQaHmacGetType(macType, (word32*)&hashAlgorithm);
3469        if (ret != 0)
3470            return ret;
3471
3472        return IntelQaSymHash(dev, out, in, sz,
3473            CPA_CY_SYM_HASH_MODE_AUTH, hashAlgorithm, keyRaw, keyLen);
3474    }
3475#endif /* !NO_HMAC */
3476
3477#endif /* QAT_ENABLE_HASH */
3478
3479
3480
3481/* -------------------------------------------------------------------------- */
3482/* ECC Algo */
3483/* -------------------------------------------------------------------------- */
3484
3485#ifdef HAVE_ECC
3486
3487#ifdef HAVE_ECC_DHE
3488
3489/* ECC Point Multiple Used for Public Key computation Key Gen */
3490static void IntelQaEccPointMulFree(WC_ASYNC_DEV* dev)
3491{
3492    CpaCyEcPointMultiplyOpData* opData = &dev->qat.op.ecc_mul.opData;
3493    CpaFlatBuffer* pXk = &dev->qat.op.ecc_mul.pXk;
3494    CpaFlatBuffer* pYk = &dev->qat.op.ecc_mul.pYk;
3495
3496    if (pXk) {
3497        if (pXk->pData != NULL) {
3498            XFREE(pXk->pData, dev->heap, DYNAMIC_TYPE_ASYNC_NUMA);
3499        }
3500        XMEMSET(pXk, 0, sizeof(CpaFlatBuffer));
3501    }
3502    if (pYk) {
3503        if (pYk->pData != NULL) {
3504            XFREE(pYk->pData, dev->heap, DYNAMIC_TYPE_ASYNC_NUMA);
3505        }
3506        XMEMSET(pYk, 0, sizeof(CpaFlatBuffer));
3507    }
3508
3509    if (opData) {
3510        if (opData->h.pData) {
3511            if (opData->h.pData != g_qatEcdhCofactor1) {
3512                XFREE(opData->h.pData, dev->heap, DYNAMIC_TYPE_ASYNC_NUMA);
3513            }
3514            opData->h.pData = NULL;
3515        }
3516        XMEMSET(opData, 0, sizeof(CpaCyEcPointMultiplyOpData));
3517    }
3518
3519    /* clear temp pointers */
3520    dev->qat.op.ecc_mul.pubX = NULL;
3521    dev->qat.op.ecc_mul.pubY = NULL;
3522    dev->qat.op.ecc_mul.pubZ = NULL;
3523}
3524
3525static void IntelQaEccPointMulCallback(void *pCallbackTag, CpaStatus status,
3526    void* pOpData, CpaBoolean multiplyStatus, CpaFlatBuffer* pXk,
3527    CpaFlatBuffer* pYk)
3528{
3529    WC_ASYNC_DEV* dev = (WC_ASYNC_DEV*)pCallbackTag;
3530    CpaCyEcPointMultiplyOpData* opData = (CpaCyEcPointMultiplyOpData*)pOpData;
3531    int ret = ASYNC_OP_E;
3532
3533#ifdef QAT_DEBUG
3534    printf("IntelQaEccPointMulCallback: dev %p, status %d, multiplyStatus %d, "
3535           "xLen %d, yLen %d\n",
3536        dev, status, multiplyStatus, pXk->dataLenInBytes, pYk->dataLenInBytes);
3537#endif
3538
3539    if (status == CPA_STATUS_SUCCESS) {
3540        /* check multiply status */
3541        if (multiplyStatus == 0) {
3542            /* fail */
3543            WOLFSSL_MSG("IntelQaEccPointMulCallback: multiply failed");
3544            ret = ECC_CURVE_OID_E;
3545        }
3546        else {
3547            ret = mp_read_unsigned_bin(dev->qat.op.ecc_mul.pubX,
3548                pXk->pData, pXk->dataLenInBytes);
3549            if (ret == 0)
3550                ret = mp_read_unsigned_bin(dev->qat.op.ecc_mul.pubY,
3551                    pYk->pData, pYk->dataLenInBytes);
3552            if (ret == 0)
3553                ret = mp_set(dev->qat.op.ecc_mul.pubZ, 1); /* always 1 */
3554        }
3555    }
3556    (void)opData;
3557
3558    /* set return code to mark complete */
3559    dev->qat.ret = ret;
3560}
3561
3562int IntelQaEccPointMul(WC_ASYNC_DEV* dev, WC_BIGINT* k,
3563    MATH_INT_T* pubX, MATH_INT_T* pubY, MATH_INT_T* pubZ,
3564    WC_BIGINT* xG, WC_BIGINT* yG, WC_BIGINT* a, WC_BIGINT* b, WC_BIGINT* q,
3565    word32 cofactor)
3566{
3567    int ret, retryCount = 0;
3568    CpaStatus status = CPA_STATUS_SUCCESS;
3569    CpaCyEcPointMultiplyOpData* opData = NULL;
3570    CpaFlatBuffer* pXk = NULL;
3571    CpaFlatBuffer* pYk = NULL;
3572    CpaCyEcPointMultiplyCbFunc callback = IntelQaEccPointMulCallback;
3573    CpaBoolean* multiplyStatus;
3574
3575    /* check arguments */
3576    if (dev == NULL) {
3577        return BAD_FUNC_ARG;
3578    }
3579
3580#ifdef QAT_DEBUG
3581    printf("IntelQaEccPointMul dev %p\n", dev);
3582#endif
3583
3584    /* setup operation */
3585    opData = &dev->qat.op.ecc_mul.opData;
3586    pXk = &dev->qat.op.ecc_mul.pXk;
3587    pYk = &dev->qat.op.ecc_mul.pYk;
3588    multiplyStatus = &dev->qat.op.ecc_mul.multiplyStatus;
3589
3590    /* init buffers */
3591    XMEMSET(opData, 0, sizeof(CpaCyEcPointMultiplyOpData));
3592    XMEMSET(pXk, 0, sizeof(CpaFlatBuffer));
3593    XMEMSET(pYk, 0, sizeof(CpaFlatBuffer));
3594    XMEMSET(multiplyStatus, 0, sizeof(CpaBoolean));
3595
3596    /* setup operation data */
3597    opData->fieldType = CPA_CY_EC_FIELD_TYPE_PRIME;
3598    ret = IntelQaBigIntToFlatBuffer(k, &opData->k);
3599    ret += IntelQaBigIntToFlatBuffer(xG, &opData->xg);
3600    ret += IntelQaBigIntToFlatBuffer(yG, &opData->yg);
3601    if (a != NULL && a->buf == NULL) {
3602        /* The Koblitz curves can have a zero param "a" */
3603        ret += IntelQaAllocFlatBuffer(&opData->a, k->len, dev->heap);
3604        XMEMSET(opData->a.pData, 0, k->len);
3605    }
3606    else {
3607        ret += IntelQaBigIntToFlatBuffer(a, &opData->a);
3608    }
3609    ret += IntelQaBigIntToFlatBuffer(b, &opData->b);
3610    ret += IntelQaBigIntToFlatBuffer(q, &opData->q);
3611    if (ret != 0) {
3612        ret = BAD_FUNC_ARG; goto exit;
3613    }
3614
3615    /* setup cofactor */
3616    /* for this point multiply the cofactor should not be used,
3617     * so always pass 1 */
3618    /* if using default value 1 then use shared global */
3619    opData->h.dataLenInBytes = 4;
3620    opData->h.pData = g_qatEcdhCofactor1;
3621    (void)cofactor;
3622
3623    ret =  IntelQaAllocFlatBuffer(pXk, q->len, dev->heap);
3624    ret += IntelQaAllocFlatBuffer(pYk, q->len, dev->heap);
3625    if (ret != 0) {
3626        ret = MEMORY_E; goto exit;
3627    }
3628
3629    /* store info needed for output */
3630    dev->qat.op.ecc_mul.pubX = pubX;
3631    dev->qat.op.ecc_mul.pubY = pubY;
3632    dev->qat.op.ecc_mul.pubZ = pubZ;
3633    IntelQaOpInit(dev, IntelQaEccPointMulFree);
3634
3635    /* perform point multiply */
3636    do {
3637        status = cpaCyEcPointMultiply(dev->qat.handle,
3638            callback,
3639            dev,
3640            opData,
3641            multiplyStatus,
3642            pXk,
3643            pYk);
3644    } while (IntelQaHandleCpaStatus(dev, status, &ret, QAT_ECMUL_ASYNC,
3645        (void*)callback, &retryCount));
3646
3647    if (ret == WC_PENDING_E)
3648        return ret;
3649
3650exit:
3651
3652    if (ret != 0) {
3653        printf("cpaCyEcPointMultiply failed! dev %p, status %d, ret %d\n",
3654            dev, status, ret);
3655    }
3656
3657    /* handle cleanup */
3658    IntelQaEccPointMulFree(dev);
3659
3660    return ret;
3661}
3662
3663static void IntelQaEcdhFree(WC_ASYNC_DEV* dev)
3664{
3665    CpaCyEcdhPointMultiplyOpData* opData = &dev->qat.op.ecc_ecdh.opData;
3666    CpaFlatBuffer* resultX = &dev->qat.op.ecc_ecdh.pXk;
3667    CpaFlatBuffer* resultY = &dev->qat.op.ecc_ecdh.pYk;
3668
3669    if (resultX) {
3670        if (resultX->pData) {
3671            XFREE(resultX->pData, dev->heap, DYNAMIC_TYPE_ASYNC_NUMA);
3672            resultX->pData = NULL;
3673        }
3674        if (resultY->pData) {
3675            /* Don't free, since isn't used, persist global */
3676            /* XFREE(resultY->pData, dev->heap, DYNAMIC_TYPE_ASYNC_NUMA); */
3677            resultY->pData = NULL;
3678        }
3679        XMEMSET(resultX, 0, sizeof(CpaFlatBuffer));
3680        XMEMSET(resultY, 0, sizeof(CpaFlatBuffer));
3681    }
3682
3683    if (opData) {
3684        if (opData->h.pData) {
3685            if (opData->h.pData != g_qatEcdhCofactor1) {
3686                XFREE(opData->h.pData, dev->heap, DYNAMIC_TYPE_ASYNC_NUMA);
3687            }
3688            opData->h.pData = NULL;
3689        }
3690        XMEMSET(opData, 0, sizeof(CpaCyEcdhPointMultiplyOpData));
3691    }
3692
3693    /* clear temp pointers */
3694    dev->qat.out = NULL;
3695    dev->qat.outLenPtr = NULL;
3696}
3697
3698static void IntelQaEcdhCallback(void *pCallbackTag, CpaStatus status,
3699    void* pOpData, CpaBoolean multiplyStatus, CpaFlatBuffer* pXk,
3700    CpaFlatBuffer* pYk)
3701{
3702    WC_ASYNC_DEV* dev = (WC_ASYNC_DEV*)pCallbackTag;
3703    CpaCyEcdhPointMultiplyOpData* opData =
3704        (CpaCyEcdhPointMultiplyOpData*)pOpData;
3705    int ret = ASYNC_OP_E;
3706
3707#ifdef QAT_DEBUG
3708    printf("IntelQaEcdhCallback: dev %p, status %d, multiplyStatus %d, "
3709           "xLen %d, yLen %d\n",
3710        dev, status, multiplyStatus, pXk->dataLenInBytes, pYk->dataLenInBytes);
3711#endif
3712
3713    if (status == CPA_STATUS_SUCCESS) {
3714        /* validate returned output */
3715        if (dev->qat.outLenPtr) {
3716            if (pXk->dataLenInBytes > *dev->qat.outLenPtr) {
3717                pXk->dataLenInBytes = *dev->qat.outLenPtr;
3718            }
3719            *dev->qat.outLenPtr = pXk->dataLenInBytes;
3720        }
3721
3722        /* return data */
3723        if (dev->qat.out && dev->qat.out != pXk->pData) {
3724            XMEMCPY(dev->qat.out, pXk->pData, pXk->dataLenInBytes);
3725        }
3726
3727        /* check multiply status */
3728        if (multiplyStatus == 0) {
3729            /* fail */
3730            WOLFSSL_MSG("IntelQaEcdhCallback: multiply failed");
3731            ret = ECC_CURVE_OID_E;
3732        }
3733        else {
3734            /* mark event result */
3735            ret = 0; /* success */
3736        }
3737    }
3738    (void)opData;
3739    (void)pYk;
3740
3741    /* set return code to mark complete */
3742    dev->qat.ret = ret;
3743}
3744
3745int IntelQaEcdh(WC_ASYNC_DEV* dev, WC_BIGINT* k, WC_BIGINT* xG,
3746    WC_BIGINT* yG, byte* out, word32* outlen,
3747    WC_BIGINT* a, WC_BIGINT* b, WC_BIGINT* q,
3748    word32 cofactor)
3749{
3750    int ret, retryCount = 0;
3751    CpaStatus status = CPA_STATUS_SUCCESS;
3752    CpaCyEcdhPointMultiplyOpData* opData = NULL;
3753    CpaFlatBuffer* pXk = NULL;
3754    CpaFlatBuffer* pYk = NULL;
3755    CpaCyEcdhPointMultiplyCbFunc callback = IntelQaEcdhCallback;
3756    CpaBoolean* multiplyStatus;
3757
3758    /* check arguments */
3759    if (dev == NULL) {
3760        return BAD_FUNC_ARG;
3761    }
3762
3763#ifdef QAT_DEBUG
3764    printf("IntelQaEcdh dev %p\n", dev);
3765#endif
3766
3767    /* setup operation */
3768    opData = &dev->qat.op.ecc_ecdh.opData;
3769    pXk = &dev->qat.op.ecc_ecdh.pXk;
3770    pYk = &dev->qat.op.ecc_ecdh.pYk;
3771    multiplyStatus = &dev->qat.op.ecc_ecdh.multiplyStatus;
3772
3773    /* init buffers */
3774    XMEMSET(opData, 0, sizeof(CpaCyEcdhPointMultiplyOpData));
3775    XMEMSET(pXk, 0, sizeof(CpaFlatBuffer));
3776    XMEMSET(pYk, 0, sizeof(CpaFlatBuffer));
3777    XMEMSET(multiplyStatus, 0, sizeof(CpaBoolean));
3778
3779    /* setup operation data */
3780    opData->fieldType = CPA_CY_EC_FIELD_TYPE_PRIME;
3781    ret = IntelQaBigIntToFlatBuffer(k, &opData->k);
3782    ret += IntelQaBigIntToFlatBuffer(xG, &opData->xg);
3783    ret += IntelQaBigIntToFlatBuffer(yG, &opData->yg);
3784    if (a != NULL && a->buf == NULL) {
3785        /* The Koblitz curves can have a zero param "a" */
3786        ret += IntelQaAllocFlatBuffer(&opData->a, k->len, dev->heap);
3787        XMEMSET(opData->a.pData, 0, k->len);
3788    }
3789    else {
3790        ret += IntelQaBigIntToFlatBuffer(a, &opData->a);
3791    }
3792    ret += IntelQaBigIntToFlatBuffer(b, &opData->b);
3793    ret += IntelQaBigIntToFlatBuffer(q, &opData->q);
3794    if (ret != 0) {
3795        ret = BAD_FUNC_ARG; goto exit;
3796    }
3797
3798    /* setup cofactor */
3799    /* for this point multiply the cofactor should not be used,
3800     * so always pass 1 */
3801    /* if using default value 1 then use shared global */
3802    opData->h.dataLenInBytes = 4;
3803    opData->h.pData = g_qatEcdhCofactor1;
3804    (void)cofactor;
3805
3806    pXk->dataLenInBytes = q->len; /* bytes key size / 8 (aligned) */
3807    pXk->pData = (Cpa8U*)XREALLOC(out, pXk->dataLenInBytes, dev->heap,
3808        DYNAMIC_TYPE_ASYNC_NUMA);
3809    pYk->dataLenInBytes = q->len;
3810    pYk->pData = g_qatEcdhY;
3811
3812    /* store info needed for output */
3813    dev->qat.out = out;
3814    dev->qat.outLenPtr = outlen;
3815    IntelQaOpInit(dev, IntelQaEcdhFree);
3816
3817    /* perform point multiply */
3818    do {
3819        status = cpaCyEcdhPointMultiply(dev->qat.handle,
3820            callback,
3821            dev,
3822            opData,
3823            multiplyStatus,
3824            pXk,
3825            pYk);
3826    } while (IntelQaHandleCpaStatus(dev, status, &ret, QAT_ECDHE_ASYNC,
3827        (void*)callback, &retryCount));
3828
3829    if (ret == WC_PENDING_E)
3830        return ret;
3831
3832exit:
3833
3834    if (ret != 0) {
3835        printf("cpaCyEcdhPointMultiply failed! dev %p, status %d, ret %d\n",
3836            dev, status, ret);
3837    }
3838
3839    /* handle cleanup */
3840    IntelQaEcdhFree(dev);
3841
3842    return ret;
3843}
3844#endif /* HAVE_ECC_DHE */
3845
3846
3847#ifdef HAVE_ECC_SIGN
3848
3849static void IntelQaEcdsaSignFree(WC_ASYNC_DEV* dev)
3850{
3851    CpaCyEcdsaSignRSOpData* opData = &dev->qat.op.ecc_sign.opData;
3852    CpaFlatBuffer *pR = &dev->qat.op.ecc_sign.R;
3853    CpaFlatBuffer *pS = &dev->qat.op.ecc_sign.S;
3854
3855    if (opData) {
3856        XMEMSET(opData, 0, sizeof(CpaCyEcdsaSignRSOpData));
3857    }
3858
3859    if (pR) {
3860        if (pR->pData)
3861            XFREE(pR->pData, dev->heap, DYNAMIC_TYPE_ASYNC_NUMA);
3862        XMEMSET(pR, 0, sizeof(CpaFlatBuffer));
3863    }
3864    if (pS) {
3865        if (pS->pData)
3866            XFREE(pS->pData, dev->heap, DYNAMIC_TYPE_ASYNC_NUMA);
3867        XMEMSET(pS, 0, sizeof(CpaFlatBuffer));
3868    }
3869
3870    /* clear temp pointers */
3871    dev->qat.op.ecc_sign.pR = NULL;
3872    dev->qat.op.ecc_sign.pS = NULL;
3873}
3874
3875static void IntelQaEcdsaSignCallback(void *pCallbackTag,
3876        CpaStatus status, void *pOpData, CpaBoolean signStatus,
3877        CpaFlatBuffer *pR, CpaFlatBuffer *pS)
3878{
3879    WC_ASYNC_DEV* dev = (WC_ASYNC_DEV*)pCallbackTag;
3880    CpaCyEcdsaSignRSOpData* opData = (CpaCyEcdsaSignRSOpData*)pOpData;
3881    int ret = ASYNC_OP_E;
3882
3883    (void)signStatus;
3884
3885#ifdef QAT_DEBUG
3886    printf("IntelQaEcdsaSignCallback: dev %p, status %d, signStatus %d, "
3887           "rLen %d, sLen %d\n",
3888        dev, status, signStatus, pR->dataLenInBytes, pS->dataLenInBytes);
3889#endif
3890
3891    if (status == CPA_STATUS_SUCCESS) {
3892        /* check sign status */
3893        if (signStatus == 0) {
3894            /* fail */
3895            WOLFSSL_MSG("IntelQaEcdsaSignCallback: sign failed");
3896            ret = ECC_CURVE_OID_E;
3897        }
3898        else {
3899            /* success - populate result */
3900            ret = IntelQaFlatBufferToBigInt(pR, dev->qat.op.ecc_sign.pR);
3901            if (ret == 0) {
3902                ret = IntelQaFlatBufferToBigInt(pS, dev->qat.op.ecc_sign.pS);
3903            }
3904        }
3905    }
3906    (void)opData;
3907
3908    /* set return code to mark complete */
3909    dev->qat.ret = ret;
3910}
3911
3912int IntelQaEcdsaSign(WC_ASYNC_DEV* dev,
3913            WC_BIGINT* m, WC_BIGINT* d,
3914            WC_BIGINT* k,
3915            WC_BIGINT* r, WC_BIGINT* s,
3916            WC_BIGINT* a, WC_BIGINT* b,
3917            WC_BIGINT* q, WC_BIGINT* n,
3918            WC_BIGINT* xg, WC_BIGINT* yg)
3919{
3920    int ret, retryCount = 0;
3921    CpaStatus status = CPA_STATUS_SUCCESS;
3922    CpaCyEcdsaSignRSOpData* opData = NULL;
3923    CpaCyEcdsaSignRSCbFunc callback = IntelQaEcdsaSignCallback;
3924    CpaBoolean* signStatus;
3925    CpaFlatBuffer* pR = NULL;
3926    CpaFlatBuffer* pS = NULL;
3927
3928    if (dev == NULL) {
3929        return BAD_FUNC_ARG;
3930    }
3931
3932#ifdef QAT_DEBUG
3933    printf("IntelQaEcdsaSign dev %p\n", dev);
3934#endif
3935
3936    /* setup operation */
3937    opData = &dev->qat.op.ecc_sign.opData;
3938    pR = &dev->qat.op.ecc_sign.R;
3939    pS = &dev->qat.op.ecc_sign.S;
3940    signStatus = &dev->qat.op.ecc_sign.signStatus;
3941
3942    /* init buffers */
3943    XMEMSET(opData, 0, sizeof(CpaCyEcdsaSignRSOpData));
3944    XMEMSET(pR, 0, sizeof(CpaFlatBuffer));
3945    XMEMSET(pS, 0, sizeof(CpaFlatBuffer));
3946    XMEMSET(signStatus, 0, sizeof(CpaBoolean));
3947
3948    /* setup operation data */
3949    opData->fieldType = CPA_CY_EC_FIELD_TYPE_PRIME;
3950    ret =  IntelQaBigIntToFlatBuffer(m, &opData->m);
3951    ret += IntelQaBigIntToFlatBuffer(d, &opData->d);
3952    ret += IntelQaBigIntToFlatBuffer(k, &opData->k);
3953    ret += IntelQaBigIntToFlatBuffer(a, &opData->a);
3954    ret += IntelQaBigIntToFlatBuffer(b, &opData->b);
3955    ret += IntelQaBigIntToFlatBuffer(q, &opData->q);
3956    ret += IntelQaBigIntToFlatBuffer(n, &opData->n);
3957    ret += IntelQaBigIntToFlatBuffer(xg, &opData->xg);
3958    ret += IntelQaBigIntToFlatBuffer(yg, &opData->yg);
3959    if (ret != 0) {
3960        ret = BAD_FUNC_ARG; goto exit;
3961    }
3962
3963    pR->dataLenInBytes = n->len; /* bytes key size / 8 (aligned) */
3964    pS->dataLenInBytes = n->len;
3965    pR->pData = (Cpa8U*)XREALLOC(r->buf, pR->dataLenInBytes, dev->heap,
3966        DYNAMIC_TYPE_ASYNC_NUMA);
3967    pS->pData = (Cpa8U*)XREALLOC(s->buf, pS->dataLenInBytes, dev->heap,
3968        DYNAMIC_TYPE_ASYNC_NUMA);
3969
3970    if (pR->pData == NULL || pS->pData == NULL) {
3971        ret = MEMORY_E; goto exit;
3972    }
3973
3974    /* store info needed for output */
3975    dev->qat.op.ecc_sign.pR = r;
3976    dev->qat.op.ecc_sign.pS = s;
3977    IntelQaOpInit(dev, IntelQaEcdsaSignFree);
3978
3979    /* Perform ECDSA sign */
3980    do {
3981        status = cpaCyEcdsaSignRS(dev->qat.handle,
3982            callback,
3983            dev,
3984            opData,
3985            signStatus,
3986            pR,
3987            pS);
3988    } while (IntelQaHandleCpaStatus(dev, status, &ret, QAT_ECDSA_ASYNC,
3989        (void*)callback, &retryCount));
3990
3991    if (ret == WC_PENDING_E)
3992        return ret;
3993
3994exit:
3995
3996    if (ret != 0) {
3997        printf("cpaCyEcdsaSignRS failed! dev %p, status %d, ret %d\n",
3998            dev, status, ret);
3999    }
4000
4001    /* handle cleanup */
4002    IntelQaEcdsaSignFree(dev);
4003
4004    return ret;
4005}
4006
4007#endif /* HAVE_ECC_SIGN */
4008
4009
4010#ifdef HAVE_ECC_VERIFY
4011static void IntelQaEcdsaVerifyFree(WC_ASYNC_DEV* dev)
4012{
4013    CpaCyEcdsaVerifyOpData* opData = &dev->qat.op.ecc_verify.opData;
4014
4015    if (opData) {
4016        XMEMSET(opData, 0, sizeof(CpaCyEcdsaVerifyOpData));
4017    }
4018
4019    /* clear temp pointers */
4020    dev->qat.op.ecc_verify.stat = NULL;
4021}
4022
4023static void IntelQaEcdsaVerifyCallback(void *pCallbackTag,
4024        CpaStatus status, void *pOpData, CpaBoolean verifyStatus)
4025{
4026    WC_ASYNC_DEV* dev = (WC_ASYNC_DEV*)pCallbackTag;
4027    CpaCyEcdsaVerifyOpData* opData = (CpaCyEcdsaVerifyOpData*)pOpData;
4028    int ret = ASYNC_OP_E;
4029
4030#ifdef QAT_DEBUG
4031    printf("IntelQaEcdsaVerifyCallback: dev %p, status %d, verifyStatus %d\n",
4032        dev, status, verifyStatus);
4033#endif
4034
4035    if (status == CPA_STATUS_SUCCESS) {
4036        /* populate result */
4037        *dev->qat.op.ecc_verify.stat = verifyStatus;
4038
4039        /* check verify status */
4040        if (verifyStatus == 0) {
4041            /* fail */
4042            WOLFSSL_MSG("IntelQaEcdsaVerifyCallback: verify failed");
4043            ret = ECC_CURVE_OID_E;
4044        }
4045        else {
4046            /* mark event result */
4047            ret = 0; /* success */
4048        }
4049    }
4050    (void)opData;
4051
4052    /* set return code to mark complete */
4053    dev->qat.ret = ret;
4054}
4055
4056int IntelQaEcdsaVerify(WC_ASYNC_DEV* dev, WC_BIGINT* m,
4057    WC_BIGINT* xp, WC_BIGINT* yp,
4058    WC_BIGINT* r, WC_BIGINT* s,
4059    WC_BIGINT* a, WC_BIGINT* b,
4060    WC_BIGINT* q, WC_BIGINT* n,
4061    WC_BIGINT* xg, WC_BIGINT* yg, int* pVerifyStatus)
4062{
4063    int ret, retryCount = 0;
4064    CpaStatus status = CPA_STATUS_SUCCESS;
4065    CpaCyEcdsaVerifyOpData* opData = NULL;
4066    CpaCyEcdsaVerifyCbFunc callback = IntelQaEcdsaVerifyCallback;
4067    CpaBoolean* verifyStatus;
4068
4069    if (dev == NULL) {
4070        return BAD_FUNC_ARG;
4071    }
4072
4073#ifdef QAT_DEBUG
4074    printf("IntelQaEcdsaVerify dev %p\n", dev);
4075#endif
4076
4077    /* setup operation */
4078    opData = &dev->qat.op.ecc_verify.opData;
4079    verifyStatus = &dev->qat.op.ecc_verify.verifyStatus;
4080
4081    /* init buffers */
4082    XMEMSET(opData, 0, sizeof(CpaCyEcdsaVerifyOpData));
4083    XMEMSET(verifyStatus, 0, sizeof(CpaBoolean));
4084
4085    /* setup operation data */
4086    opData->fieldType = CPA_CY_EC_FIELD_TYPE_PRIME;
4087    ret =  IntelQaBigIntToFlatBuffer(m,  &opData->m);
4088    ret += IntelQaBigIntToFlatBuffer(r,  &opData->r);
4089    ret += IntelQaBigIntToFlatBuffer(s,  &opData->s);
4090    ret += IntelQaBigIntToFlatBuffer(xp, &opData->xp);
4091    ret += IntelQaBigIntToFlatBuffer(yp, &opData->yp);
4092    ret += IntelQaBigIntToFlatBuffer(a,  &opData->a);
4093    ret += IntelQaBigIntToFlatBuffer(b,  &opData->b);
4094    ret += IntelQaBigIntToFlatBuffer(q,  &opData->q);
4095    ret += IntelQaBigIntToFlatBuffer(n,  &opData->n);
4096    ret += IntelQaBigIntToFlatBuffer(xg, &opData->xg);
4097    ret += IntelQaBigIntToFlatBuffer(yg, &opData->yg);
4098    if (ret != 0) {
4099        ret = BAD_FUNC_ARG; goto exit;
4100    }
4101
4102    /* store info needed for output */
4103    dev->qat.op.ecc_verify.stat = pVerifyStatus;
4104    IntelQaOpInit(dev, IntelQaEcdsaVerifyFree);
4105
4106    /* Perform ECDSA verify */
4107    do {
4108        status = cpaCyEcdsaVerify(dev->qat.handle,
4109            callback,
4110            dev,
4111            opData,
4112            verifyStatus);
4113    } while (IntelQaHandleCpaStatus(dev, status, &ret, QAT_ECDSA_ASYNC,
4114        (void*)callback, &retryCount));
4115
4116    if (ret == WC_PENDING_E)
4117        return ret;
4118
4119exit:
4120
4121    if (ret != 0) {
4122        printf("cpaCyEcdsaVerify failed! dev %p, status %d, ret %d\n",
4123            dev, status, ret);
4124    }
4125
4126    /* handle cleanup */
4127    IntelQaEcdsaVerifyFree(dev);
4128
4129    return ret;
4130}
4131#endif /* HAVE_ECC_VERIFY */
4132
4133#endif /* HAVE_ECC */
4134
4135
4136#ifndef NO_DH
4137
4138static void IntelQaDhKeyGenFree(WC_ASYNC_DEV* dev)
4139{
4140    CpaCyDhPhase1KeyGenOpData* opData = &dev->qat.op.dh_gen.opData;
4141    CpaFlatBuffer* pOut = &dev->qat.op.dh_gen.pOut;
4142
4143    if (opData) {
4144        IntelQaFreeFlatBuffer(&opData->privateValueX, dev->heap);
4145
4146        XMEMSET(opData, 0, sizeof(CpaCyDhPhase1KeyGenOpData));
4147    }
4148
4149    if (pOut) {
4150        if (pOut->pData) {
4151            XFREE(pOut->pData, dev->heap, DYNAMIC_TYPE_ASYNC_NUMA);
4152            pOut->pData = NULL;
4153        }
4154        XMEMSET(pOut, 0, sizeof(CpaFlatBuffer));
4155    }
4156
4157    /* clear temp pointers */
4158    dev->qat.out = NULL;
4159    dev->qat.outLenPtr = NULL;
4160}
4161
4162static void IntelQaDhKeyGenCallback(void *pCallbackTag, CpaStatus status,
4163        void *pOpData, CpaFlatBuffer *pOut)
4164{
4165    WC_ASYNC_DEV* dev = (WC_ASYNC_DEV*)pCallbackTag;
4166    CpaCyDhPhase1KeyGenOpData* opData = (CpaCyDhPhase1KeyGenOpData*)pOpData;
4167    int ret = ASYNC_OP_E;
4168
4169#ifdef QAT_DEBUG
4170    printf("IntelQaDhKeyGenCallback: dev %p, status %d, len %d\n",
4171        dev, status, pOut->dataLenInBytes);
4172#endif
4173
4174    if (status == CPA_STATUS_SUCCESS) {
4175        /* validate returned output */
4176        if (dev->qat.outLenPtr) {
4177            if (pOut->dataLenInBytes > *dev->qat.outLenPtr) {
4178                pOut->dataLenInBytes = *dev->qat.outLenPtr;
4179            }
4180            *dev->qat.outLenPtr = pOut->dataLenInBytes;
4181        }
4182
4183        /* return data */
4184        if (dev->qat.out && dev->qat.out != pOut->pData) {
4185            XMEMCPY(dev->qat.out, pOut->pData, pOut->dataLenInBytes);
4186        }
4187
4188        /* mark event result */
4189        ret = 0; /* success */
4190    }
4191    (void)opData;
4192
4193    /* set return code to mark complete */
4194    dev->qat.ret = ret;
4195}
4196
4197int IntelQaDhKeyGen(WC_ASYNC_DEV* dev, WC_BIGINT* p, WC_BIGINT* g,
4198    WC_BIGINT* x, byte* pub, word32* pubSz)
4199{
4200    int ret, retryCount = 0;
4201    CpaStatus status = CPA_STATUS_SUCCESS;
4202    CpaCyDhPhase1KeyGenOpData* opData = NULL;
4203    CpaCyGenFlatBufCbFunc callback = IntelQaDhKeyGenCallback;
4204    CpaFlatBuffer* pOut = NULL;
4205
4206    if (dev == NULL || p == NULL || p->buf == NULL || g == NULL || x == NULL ||
4207                                  pub == NULL || pubSz == NULL) {
4208        return BAD_FUNC_ARG;
4209    }
4210
4211#ifdef QAT_DEBUG
4212    printf("IntelQaDhKeyGen dev %p\n", dev);
4213#endif
4214
4215    /* setup operation */
4216    opData = &dev->qat.op.dh_gen.opData;
4217    pOut = &dev->qat.op.dh_gen.pOut;
4218
4219    /* init buffers */
4220    XMEMSET(opData, 0, sizeof(CpaCyDhPhase1KeyGenOpData));
4221    XMEMSET(pOut, 0, sizeof(CpaFlatBuffer));
4222
4223    /* setup operation data */
4224    ret =  IntelQaBigIntToFlatBuffer(p, &opData->primeP);
4225    ret += IntelQaBigIntToFlatBuffer(g, &opData->baseG);
4226    /* transfer control of big int buffer to opData structure */
4227    ret += IntelQaBigIntToFlatBuffer(x, &opData->privateValueX);
4228    /* don't let caller free x, do it in IntelQaDhKeyGenFree */
4229    x->buf = NULL;
4230    x->len = 0;
4231    if (ret != 0) {
4232        ret = BAD_FUNC_ARG; goto exit;
4233    }
4234    pOut->dataLenInBytes = p->len;
4235    pOut->pData = (Cpa8U*)XREALLOC(pub, p->len, dev->heap,
4236        DYNAMIC_TYPE_ASYNC_NUMA);
4237    if (pOut->pData == NULL) {
4238        ret = MEMORY_E; goto exit;
4239    }
4240
4241    /* store info needed for output */
4242    *pubSz = p->len;
4243    dev->qat.out = pub;
4244    dev->qat.outLenPtr = pubSz;
4245    IntelQaOpInit(dev, IntelQaDhKeyGenFree);
4246
4247    /* Perform DhKeyGen */
4248    do {
4249        status = cpaCyDhKeyGenPhase1(dev->qat.handle,
4250            callback,
4251            dev,
4252            opData,
4253            pOut);
4254    } while (IntelQaHandleCpaStatus(dev, status, &ret, QAT_DH_ASYNC,
4255        (void*)callback, &retryCount));
4256
4257    if (ret == WC_PENDING_E)
4258        return ret;
4259
4260exit:
4261
4262    if (ret != 0) {
4263        printf("cpaCyDhKeyGenPhase1 failed! dev %p, status %d, ret %d\n",
4264            dev, status, ret);
4265    }
4266
4267    /* handle cleanup */
4268    IntelQaDhKeyGenFree(dev);
4269
4270    return ret;
4271}
4272
4273static void IntelQaDhAgreeFree(WC_ASYNC_DEV* dev)
4274{
4275    CpaCyDhPhase2SecretKeyGenOpData* opData = &dev->qat.op.dh_agree.opData;
4276    CpaFlatBuffer* pOut = &dev->qat.op.dh_agree.pOut;
4277
4278    if (pOut) {
4279        if (pOut->pData) {
4280            XFREE(pOut->pData, dev->heap, DYNAMIC_TYPE_ASYNC_NUMA);
4281            pOut->pData = NULL;
4282        }
4283        XMEMSET(pOut, 0, sizeof(CpaFlatBuffer));
4284    }
4285    if (opData) {
4286        if (opData->remoteOctetStringPV.pData) {
4287            XFREE(opData->remoteOctetStringPV.pData, dev->heap,
4288                DYNAMIC_TYPE_ASYNC_NUMA);
4289            opData->remoteOctetStringPV.pData = NULL;
4290        }
4291        if (opData->privateValueX.pData) {
4292            XFREE(opData->privateValueX.pData, dev->heap,
4293                DYNAMIC_TYPE_ASYNC_NUMA);
4294            opData->privateValueX.pData = NULL;
4295        }
4296        XMEMSET(opData, 0, sizeof(CpaCyDhPhase2SecretKeyGenOpData));
4297    }
4298
4299    /* clear temp pointers */
4300    dev->qat.out = NULL;
4301    dev->qat.outLenPtr = NULL;
4302}
4303
4304static void IntelQaDhAgreeCallback(void *pCallbackTag, CpaStatus status,
4305        void *pOpData, CpaFlatBuffer *pOut)
4306{
4307    WC_ASYNC_DEV* dev = (WC_ASYNC_DEV*)pCallbackTag;
4308    CpaCyDhPhase2SecretKeyGenOpData* opData =
4309        (CpaCyDhPhase2SecretKeyGenOpData*)pOpData;
4310    int ret = ASYNC_OP_E;
4311
4312#ifdef QAT_DEBUG
4313    printf("IntelQaDhAgreeCallback: dev %p, status %d, len %d\n",
4314        dev, status, pOut->dataLenInBytes);
4315#endif
4316
4317    if (status == CPA_STATUS_SUCCESS) {
4318        word32 idxTrim = 0;
4319        byte* out = (byte*)pOut->pData;
4320
4321        /* check output size */
4322        if (dev->qat.outLenPtr) {
4323            if (pOut->dataLenInBytes > *dev->qat.outLenPtr) {
4324                pOut->dataLenInBytes = *dev->qat.outLenPtr;
4325            }
4326        }
4327
4328        /* count leading zeros */
4329        while (out[idxTrim] == 0 && idxTrim < pOut->dataLenInBytes) {
4330            idxTrim++;
4331        }
4332        pOut->dataLenInBytes -= idxTrim;
4333
4334        /* return data and trim leading zeros */
4335        if (dev->qat.out && (dev->qat.out != pOut->pData || idxTrim > 0)) {
4336            XMEMMOVE(dev->qat.out, &out[idxTrim], pOut->dataLenInBytes);
4337        }
4338
4339        /* return final length */
4340        if (dev->qat.outLenPtr) {
4341            *dev->qat.outLenPtr = pOut->dataLenInBytes;
4342        }
4343
4344        /* mark event result */
4345        ret = 0; /* success */
4346    }
4347    (void)opData;
4348
4349    /* set return code to mark complete */
4350    dev->qat.ret = ret;
4351}
4352
4353int IntelQaDhAgree(WC_ASYNC_DEV* dev, WC_BIGINT* p,
4354    byte* agree, word32* agreeSz, const byte* priv, word32 privSz,
4355    const byte* otherPub, word32 pubSz)
4356{
4357    int ret, retryCount = 0;
4358    CpaStatus status = CPA_STATUS_SUCCESS;
4359    CpaCyDhPhase2SecretKeyGenOpData* opData = NULL;
4360    CpaCyGenFlatBufCbFunc callback = IntelQaDhAgreeCallback;
4361    CpaFlatBuffer* pOut = NULL;
4362
4363    if (dev == NULL || agree == NULL || agreeSz == NULL ||
4364            priv == NULL || privSz == 0 || otherPub == NULL || pubSz == 0) {
4365        return BAD_FUNC_ARG;
4366    }
4367
4368#ifdef QAT_DEBUG
4369    printf("IntelQaDhAgree dev %p, agreeSz %d\n", dev, *agreeSz);
4370#endif
4371
4372    /* setup operation */
4373    opData = &dev->qat.op.dh_agree.opData;
4374    pOut = &dev->qat.op.dh_agree.pOut;
4375
4376    /* init buffers */
4377    XMEMSET(opData, 0, sizeof(CpaCyDhPhase2SecretKeyGenOpData));
4378    XMEMSET(pOut, 0, sizeof(CpaFlatBuffer));
4379
4380    /* setup operation data */
4381    ret = IntelQaBigIntToFlatBuffer(p, &opData->primeP);
4382    if (ret != 0) {
4383        goto exit;
4384    }
4385
4386    opData->remoteOctetStringPV.dataLenInBytes = pubSz;
4387    opData->remoteOctetStringPV.pData = (Cpa8U*)XREALLOC((byte*)otherPub, pubSz,
4388        dev->heap, DYNAMIC_TYPE_ASYNC_NUMA);
4389    opData->privateValueX.dataLenInBytes = privSz;
4390    opData->privateValueX.pData = (Cpa8U*)XREALLOC((byte*)priv, privSz,
4391        dev->heap, DYNAMIC_TYPE_ASYNC_NUMA);
4392    pOut->dataLenInBytes = p->len;
4393    pOut->pData = (Cpa8U*)XREALLOC(agree, p->len, dev->heap,
4394        DYNAMIC_TYPE_ASYNC_NUMA);
4395
4396    if (opData->remoteOctetStringPV.pData == NULL ||
4397        opData->privateValueX.pData == NULL || pOut->pData == NULL) {
4398        ret = MEMORY_E; goto exit;
4399    }
4400
4401    /* store info needed for output */
4402    dev->qat.out = agree;
4403    dev->qat.outLenPtr = agreeSz;
4404    IntelQaOpInit(dev, IntelQaDhAgreeFree);
4405
4406    /* Perform DhKeyGen */
4407    do {
4408        status = cpaCyDhKeyGenPhase2Secret(dev->qat.handle,
4409            callback,
4410            dev,
4411            opData,
4412            pOut);
4413    } while (IntelQaHandleCpaStatus(dev, status, &ret, QAT_DH_ASYNC,
4414        (void*)callback, &retryCount));
4415
4416    if (ret == WC_PENDING_E)
4417        return ret;
4418
4419exit:
4420
4421    if (ret != 0) {
4422        printf("cpaCyDhKeyGenPhase2Secret failed! dev %p, status %d, ret %d\n",
4423            dev, status, ret);
4424    }
4425
4426    /* handle cleanup */
4427    IntelQaDhAgreeFree(dev);
4428
4429    return ret;
4430}
4431
4432#endif /* !NO_DH */
4433
4434
4435#if defined(QAT_ENABLE_RNG)
4436/* -------------------------------------------------------------------------- */
4437/* Random NRBG/DRBG */
4438/* -------------------------------------------------------------------------- */
4439int IntelQaNrbg(CpaFlatBuffer* pBuffer, Cpa32U length)
4440{
4441    CpaStatus status;
4442    CpaCyNrbgOpData opData;
4443    CpaInstanceHandle instanceHandle = CPA_INSTANCE_HANDLE_SINGLE;
4444
4445    if (pBuffer == NULL || length == 0) {
4446        return BAD_FUNC_ARG;
4447    }
4448
4449    if (pBuffer->dataLenInBytes < length) {
4450        return BAD_FUNC_ARG;
4451    }
4452
4453    /* For now use the first crypto instance - assumed to be started already */
4454    status = cpaCyGetInstances(1, &instanceHandle);
4455    if (instanceHandle == NULL || status != CPA_STATUS_SUCCESS) {
4456        return ASYNC_INIT_E;
4457    }
4458
4459    /* init buffers */
4460    XMEMSET(&opData, 0, sizeof(CpaCyNrbgOpData));
4461    opData.lengthInBytes = length;
4462
4463    /* Perform NRBG generation */
4464    status = cpaCyNrbgGetEntropy(instanceHandle, NULL, NULL, &opData, pBuffer);
4465    if (status != CPA_STATUS_SUCCESS) {
4466        printf("cpaCyNrbgGetEntropy failed! status %d\n", status);
4467    }
4468
4469    return status;
4470}
4471
4472static CpaStatus IntelQaGetEntropyInputFunc(
4473        IcpSalDrbgGetEntropyInputCbFunc pCb,
4474        void* pCallbackTag,
4475        icp_sal_drbg_get_entropy_op_data_t *pOpData,
4476        CpaFlatBuffer *pBuffer,
4477        Cpa32U *pLengthReturned)
4478{
4479    CpaStatus status = CPA_STATUS_SUCCESS;
4480
4481    *pLengthReturned = pOpData->maxLength;
4482
4483    status = IntelQaNrbg(pBuffer, pOpData->maxLength);
4484    if (status != CPA_STATUS_SUCCESS) {
4485        return CPA_STATUS_FAIL;
4486    }
4487
4488    if (pCb != NULL) {
4489        pCb(pCallbackTag, CPA_STATUS_SUCCESS, pOpData,
4490                                    pOpData->maxLength, pBuffer);
4491    }
4492
4493    return CPA_STATUS_SUCCESS;
4494}
4495
4496static CpaStatus IntelQaGetNonceFunc(
4497        icp_sal_drbg_get_entropy_op_data_t *pOpData,
4498        CpaFlatBuffer *pBuffer,
4499        Cpa32U *pLengthReturned)
4500{
4501
4502    CpaStatus status = CPA_STATUS_SUCCESS;
4503
4504    status = IntelQaNrbg(pBuffer, pOpData->maxLength);
4505    if (status != CPA_STATUS_SUCCESS) {
4506        return CPA_STATUS_FAIL;
4507    }
4508    *pLengthReturned = pOpData->maxLength;
4509
4510    return CPA_STATUS_SUCCESS;
4511}
4512
4513static CpaBoolean IntelQaNotDFRequired(void)
4514{
4515    return CPA_FALSE;
4516}
4517
4518static int IntelQaDrbgClose(WC_ASYNC_DEV* dev)
4519{
4520    CpaStatus status;
4521
4522    if (dev == NULL)
4523        return BAD_FUNC_ARG;
4524
4525#ifdef QAT_DEBUG
4526    printf("cpaCyDrbgRemoveSession dev %p\n", dev);
4527#endif
4528
4529    if (dev->qat.op.drbg.handle) {
4530        CpaCyDrbgSessionHandle handle = dev->qat.op.drbg.handle;
4531        dev->qat.op.drbg.handle = NULL;
4532
4533        status = cpaCyDrbgRemoveSession(dev->qat.handle, handle);
4534        if (status != CPA_STATUS_SUCCESS) {
4535            printf("cpaCyDrbgRemoveSession failed! status %d\n", status);
4536        }
4537
4538        XFREE(handle, dev->heap, DYNAMIC_TYPE_ASYNC_NUMA64);
4539    }
4540
4541    return 0;
4542}
4543
4544static void IntelQaDrbgFree(WC_ASYNC_DEV* dev)
4545{
4546    CpaCyDrbgGenOpData* opData = &dev->qat.op.drbg.opData;
4547    CpaFlatBuffer* pOut = &dev->qat.op.drbg.pOut;
4548
4549    if (pOut) {
4550        if (pOut->pData) {
4551            XFREE(pOut->pData, dev->heap, DYNAMIC_TYPE_ASYNC_NUMA);
4552            pOut->pData = NULL;
4553        }
4554        XMEMSET(pOut, 0, sizeof(CpaFlatBuffer));
4555    }
4556
4557    if (opData) {
4558        XMEMSET(opData, 0, sizeof(CpaCyDrbgGenOpData));
4559    }
4560
4561    /* clear temp pointers */
4562    dev->qat.out = NULL;
4563}
4564
4565static void IntelQaDrbgCallback(void *pCallbackTag, CpaStatus status,
4566    void *pOpdata, CpaFlatBuffer *pOut)
4567{
4568    WC_ASYNC_DEV* dev = (WC_ASYNC_DEV*)pCallbackTag;
4569    CpaCyDrbgGenOpData* opData = (CpaCyDrbgGenOpData*)pOpdata;
4570    int ret = ASYNC_OP_E;
4571
4572#ifdef QAT_DEBUG
4573    printf("IntelQaDrbgCallback: dev %p, status %d, len %d\n",
4574        dev, status, pOut->dataLenInBytes);
4575#endif
4576
4577    if (status == CPA_STATUS_SUCCESS) {
4578        /* return data */
4579        if (dev->qat.out && dev->qat.out != pOut->pData) {
4580            XMEMCPY(dev->qat.out, pOut->pData, pOut->dataLenInBytes);
4581        }
4582
4583        /* mark event result */
4584        ret = 0; /* success */
4585    }
4586    (void)opData;
4587
4588    /* set return code to mark complete */
4589    dev->qat.ret = ret;
4590}
4591
4592int IntelQaDrbg(WC_ASYNC_DEV* dev, byte* rngBuf, word32 rngSz)
4593{
4594    int ret = 0, retryCount = 0;
4595    CpaStatus status = CPA_STATUS_SUCCESS;
4596    CpaCyDrbgGenOpData* opData = NULL;
4597    CpaCyGenFlatBufCbFunc callback = IntelQaDrbgCallback;
4598    CpaFlatBuffer* pOut = NULL;
4599    word32 idx = 0, gen = 0;
4600
4601    if (dev == NULL || rngBuf == NULL) {
4602        return BAD_FUNC_ARG;
4603    }
4604
4605    /* This function can be called with rngSz == 0 */
4606    if (rngSz == 0) {
4607        return 0; /* no data to get */
4608    }
4609
4610#ifdef QAT_DEBUG
4611    printf("IntelQaDrbg: dev %p, buf %p, sz %d\n", dev, rngBuf, rngSz);
4612#endif
4613
4614    /* setup operation */
4615    opData = &dev->qat.op.drbg.opData;
4616    pOut = &dev->qat.op.drbg.pOut;
4617
4618    /* init buffers */
4619    XMEMSET(opData, 0, sizeof(CpaCyDrbgGenOpData));
4620    XMEMSET(pOut, 0, sizeof(CpaFlatBuffer));
4621
4622    if (dev->qat.op.drbg.handle == NULL) {
4623        CpaCyDrbgSessionSetupData setup;
4624        Cpa32U seedLen = 0;
4625        Cpa32U handleSize;
4626
4627    #ifdef QAT_DEBUG
4628        printf("cpaCyDrbgInitSession dev %p\n", dev);
4629    #endif
4630
4631        /* register required DRBG callback functions */
4632        icp_sal_drbgIsDFReqFuncRegister(IntelQaNotDFRequired);
4633        icp_sal_drbgGetEntropyInputFuncRegister(IntelQaGetEntropyInputFunc);
4634        icp_sal_drbgGetNonceFuncRegister(IntelQaGetNonceFunc);
4635
4636        setup.predictionResistanceRequired = CPA_FALSE;
4637        setup.secStrength = CPA_CY_RBG_SEC_STRENGTH_128;
4638        setup.personalizationString.dataLenInBytes = 0;
4639        setup.personalizationString.pData = NULL;
4640
4641        status = cpaCyDrbgSessionGetSize(dev->qat.handle, &setup, &handleSize);
4642        if (status != CPA_STATUS_SUCCESS) {
4643            ret = ASYNC_INIT_E; goto exit;
4644        }
4645
4646        dev->qat.op.drbg.handle = (CpaCyDrbgSessionHandle)XMALLOC(
4647            handleSize, dev->heap, DYNAMIC_TYPE_ASYNC_NUMA64);
4648        if (dev->qat.op.drbg.handle == NULL) {
4649            ret = MEMORY_E; goto exit;
4650        }
4651
4652        status = cpaCyDrbgInitSession(dev->qat.handle,
4653                    callback,    /* callback function for generate */
4654                    NULL,        /* callback function for reseed */
4655                    &setup,      /* session setup data */
4656                    dev->qat.op.drbg.handle,
4657                    &seedLen);
4658    }
4659
4660    /* chunk into LAC_DRBG_MAX_NUM_OF_BYTES (0xFFFF) */
4661    while (ret == 0 && idx < rngSz) {
4662        /* setup operation data */
4663        gen = rngSz - gen;
4664        if (gen > 0xFFFF)
4665            gen = 0xFFFF;
4666
4667        pOut->dataLenInBytes = gen;
4668        if (idx == 0 && pOut->pData == NULL) {
4669            pOut->pData = XREALLOC(rngBuf, gen, dev->heap,
4670                DYNAMIC_TYPE_ASYNC_NUMA);
4671            if (pOut->pData == NULL) {
4672                ret = MEMORY_E; goto exit;
4673            }
4674        }
4675        else {
4676            XMEMCPY(pOut->pData, &rngBuf[idx], gen);
4677        }
4678
4679        opData->sessionHandle = dev->qat.op.drbg.handle;
4680        opData->lengthInBytes = gen;
4681        opData->secStrength = CPA_CY_RBG_SEC_STRENGTH_128;
4682        opData->predictionResistanceRequired = CPA_FALSE;
4683        opData->additionalInput.dataLenInBytes = 0;
4684        opData->additionalInput.pData = NULL;
4685
4686        /* store info needed for output */
4687        dev->qat.out = &rngBuf[idx];
4688        IntelQaOpInit(dev, IntelQaDrbgFree);
4689
4690        /* Perform DRBG generation */
4691        do {
4692            status = cpaCyDrbgGen(dev->qat.handle,
4693                dev,
4694                opData,
4695                pOut);
4696        } while (IntelQaHandleCpaStatus(dev, status, &ret, QAT_DRBG_ASYNC,
4697            callback, &retryCount));
4698
4699        idx += gen;
4700    };
4701
4702exit:
4703
4704    if (ret != 0) {
4705        printf("cpaCyDrbgGen failed! dev %p, status %d, ret %d\n",
4706            dev, status, ret);
4707    }
4708
4709    /* handle cleanup */
4710    IntelQaDrbgFree(dev);
4711
4712    return ret;
4713}
4714#endif /* QAT_ENABLE_RNG */
4715
4716#ifdef QAT_DEMO_MAIN
4717
4718 /* RSA */
4719static const byte rsa_in[256] = {
4720    0x7e, 0xf5, 0x69, 0x11, 0x6f, 0x67, 0x81, 0x71, 0xa2, 0x3e, 0xe7, 0x0e,
4721    0xad, 0xb9, 0x5f, 0x20, 0xc8, 0x2d, 0x8b, 0xd3, 0xb1, 0x65, 0x27, 0x34,
4722    0x7a, 0x10, 0x2e, 0xf4, 0xe9, 0x6a, 0x69, 0x93, 0xc0, 0x3e, 0xad, 0xbe,
4723    0x2e, 0x35, 0x34, 0xeb, 0x64, 0x45, 0x09, 0xf4, 0x07, 0x33, 0x6f, 0xac,
4724    0x2f, 0xc8, 0x59, 0xca, 0x72, 0x99, 0x0b, 0x99, 0xb1, 0xf3, 0xda, 0x42,
4725    0xdb, 0x7b, 0xed, 0x4c, 0x22, 0x48, 0x08, 0x8a, 0x30, 0xd7, 0xdc, 0x99,
4726    0x0b, 0xb9, 0x1a, 0xc5, 0x40, 0xe5, 0x7d, 0xe9, 0xbf, 0x0a, 0x05, 0xea,
4727    0x07, 0x24, 0x7a, 0x1f, 0x54, 0xbf, 0x77, 0x71, 0x09, 0xec, 0x6d, 0xdf,
4728    0x87, 0xc2, 0x11, 0xda, 0x8c, 0x66, 0x46, 0x1d, 0x5a, 0x45, 0x23, 0x35,
4729    0x96, 0x48, 0xa7, 0x0e, 0x03, 0xe1, 0x02, 0x43, 0x76, 0x56, 0xae, 0xc3,
4730    0x6e, 0x61, 0x73, 0xba, 0x48, 0x6e, 0x8a, 0x58, 0x60, 0xdd, 0x0a, 0x81,
4731    0x46, 0xe4, 0xb4, 0x03, 0xf1, 0x63, 0xf4, 0xc1, 0xad, 0xd5, 0x4a, 0xda,
4732    0x25, 0xd9, 0x9d, 0x56, 0x1f, 0xb4, 0x7b, 0x2b, 0xdd, 0x90, 0x4e, 0xfd,
4733    0xa1, 0xd4, 0x5b, 0xd9, 0x17, 0x1a, 0x68, 0xd0, 0x3c, 0x95, 0x94, 0x64,
4734    0x6a, 0x4a, 0xad, 0x39, 0xe5, 0x5f, 0xd1, 0xe2, 0xb1, 0x1b, 0xad, 0x1d,
4735    0x2a, 0xc2, 0x12, 0xed, 0x47, 0xa1, 0xac, 0x0f, 0x3e, 0x3b, 0x44, 0x2f,
4736    0x61, 0xa5, 0xab, 0xa1, 0x03, 0xe9, 0x40, 0x62, 0x82, 0xc6, 0x33, 0xcf,
4737    0x12, 0xeb, 0x76, 0x73, 0x13, 0x61, 0xe5, 0x3b, 0xf9, 0x38, 0x24, 0xc0,
4738    0x24, 0xc7, 0x88, 0x2b, 0x4a, 0x3c, 0x42, 0x26, 0xd0, 0xe6, 0x4d, 0xc8,
4739    0x41, 0x58, 0x94, 0x77, 0x91, 0x1d, 0xfa, 0xbb, 0x9f, 0xa8, 0x43, 0xe0,
4740    0x33, 0x46, 0x7e, 0x8e, 0xcf, 0xfc, 0x3e, 0xd4, 0x72, 0x7b, 0xf9, 0xee,
4741    0xca, 0xfd, 0x96, 0xd4,
4742};
4743static const byte rsa_d[256] = {
4744    0xa2, 0xe6, 0xd8, 0x5f, 0x10, 0x71, 0x64, 0x08, 0x9e, 0x2e, 0x6d, 0xd1,
4745    0x6d, 0x1e, 0x85, 0xd2, 0x0a, 0xb1, 0x8c, 0x47, 0xce, 0x2c, 0x51, 0x6a,
4746    0xa0, 0x12, 0x9e, 0x53, 0xde, 0x91, 0x4c, 0x1d, 0x6d, 0xea, 0x59, 0x7b,
4747    0xf2, 0x77, 0xaa, 0xd9, 0xc6, 0xd9, 0x8a, 0xab, 0xd8, 0xe1, 0x16, 0xe4,
4748    0x63, 0x26, 0xff, 0xb5, 0x6c, 0x13, 0x59, 0xb8, 0xe3, 0xa5, 0xc8, 0x72,
4749    0x17, 0x2e, 0x0c, 0x9f, 0x6f, 0xe5, 0x59, 0x3f, 0x76, 0x6f, 0x49, 0xb1,
4750    0x11, 0xc2, 0x5a, 0x2e, 0x16, 0x29, 0x0d, 0xde, 0xb7, 0x8e, 0xdc, 0x40,
4751    0xd5, 0xa2, 0xee, 0xe0, 0x1e, 0xa1, 0xf4, 0xbe, 0x97, 0xdb, 0x86, 0x63,
4752    0x96, 0x14, 0xcd, 0x98, 0x09, 0x60, 0x2d, 0x30, 0x76, 0x9c, 0x3c, 0xcd,
4753    0xe6, 0x88, 0xee, 0x47, 0x92, 0x79, 0x0b, 0x5a, 0x00, 0xe2, 0x5e, 0x5f,
4754    0x11, 0x7c, 0x7d, 0xf9, 0x08, 0xb7, 0x20, 0x06, 0x89, 0x2a, 0x5d, 0xfd,
4755    0x00, 0xab, 0x22, 0xe1, 0xf0, 0xb3, 0xbc, 0x24, 0xa9, 0x5e, 0x26, 0x0e,
4756    0x1f, 0x00, 0x2d, 0xfe, 0x21, 0x9a, 0x53, 0x5b, 0x6d, 0xd3, 0x2b, 0xab,
4757    0x94, 0x82, 0x68, 0x43, 0x36, 0xd8, 0xf6, 0x2f, 0xc6, 0x22, 0xfc, 0xb5,
4758    0x41, 0x5d, 0x0d, 0x33, 0x60, 0xea, 0xa4, 0x7d, 0x7e, 0xe8, 0x4b, 0x55,
4759    0x91, 0x56, 0xd3, 0x5c, 0x57, 0x8f, 0x1f, 0x94, 0x17, 0x2f, 0xaa, 0xde,
4760    0xe9, 0x9e, 0xa8, 0xf4, 0xcf, 0x8a, 0x4c, 0x8e, 0xa0, 0xe4, 0x56, 0x73,
4761    0xb2, 0xcf, 0x4f, 0x86, 0xc5, 0x69, 0x3c, 0xf3, 0x24, 0x20, 0x8b, 0x5c,
4762    0x96, 0x0c, 0xfa, 0x6b, 0x12, 0x3b, 0x9a, 0x67, 0xc1, 0xdf, 0xc6, 0x96,
4763    0xb2, 0xa5, 0xd5, 0x92, 0x0d, 0x9b, 0x09, 0x42, 0x68, 0x24, 0x10, 0x45,
4764    0xd4, 0x50, 0xe4, 0x17, 0x39, 0x48, 0xd0, 0x35, 0x8b, 0x94, 0x6d, 0x11,
4765    0xde, 0x8f, 0xca, 0x59,
4766};
4767static const byte rsa_n[256] = {
4768    0xc3, 0x03, 0xd1, 0x2b, 0xfe, 0x39, 0xa4, 0x32, 0x45, 0x3b, 0x53, 0xc8,
4769    0x84, 0x2b, 0x2a, 0x7c, 0x74, 0x9a, 0xbd, 0xaa, 0x2a, 0x52, 0x07, 0x47,
4770    0xd6, 0xa6, 0x36, 0xb2, 0x07, 0x32, 0x8e, 0xd0, 0xba, 0x69, 0x7b, 0xc6,
4771    0xc3, 0x44, 0x9e, 0xd4, 0x81, 0x48, 0xfd, 0x2d, 0x68, 0xa2, 0x8b, 0x67,
4772    0xbb, 0xa1, 0x75, 0xc8, 0x36, 0x2c, 0x4a, 0xd2, 0x1b, 0xf7, 0x8b, 0xba,
4773    0xcf, 0x0d, 0xf9, 0xef, 0xec, 0xf1, 0x81, 0x1e, 0x7b, 0x9b, 0x03, 0x47,
4774    0x9a, 0xbf, 0x65, 0xcc, 0x7f, 0x65, 0x24, 0x69, 0xa6, 0xe8, 0x14, 0x89,
4775    0x5b, 0xe4, 0x34, 0xf7, 0xc5, 0xb0, 0x14, 0x93, 0xf5, 0x67, 0x7b, 0x3a,
4776    0x7a, 0x78, 0xe1, 0x01, 0x56, 0x56, 0x91, 0xa6, 0x13, 0x42, 0x8d, 0xd2,
4777    0x3c, 0x40, 0x9c, 0x4c, 0xef, 0xd1, 0x86, 0xdf, 0x37, 0x51, 0x1b, 0x0c,
4778    0xa1, 0x3b, 0xf5, 0xf1, 0xa3, 0x4a, 0x35, 0xe4, 0xe1, 0xce, 0x96, 0xdf,
4779    0x1b, 0x7e, 0xbf, 0x4e, 0x97, 0xd0, 0x10, 0xe8, 0xa8, 0x08, 0x30, 0x81,
4780    0xaf, 0x20, 0x0b, 0x43, 0x14, 0xc5, 0x74, 0x67, 0xb4, 0x32, 0x82, 0x6f,
4781    0x8d, 0x86, 0xc2, 0x88, 0x40, 0x99, 0x36, 0x83, 0xba, 0x1e, 0x40, 0x72,
4782    0x22, 0x17, 0xd7, 0x52, 0x65, 0x24, 0x73, 0xb0, 0xce, 0xef, 0x19, 0xcd,
4783    0xae, 0xff, 0x78, 0x6c, 0x7b, 0xc0, 0x12, 0x03, 0xd4, 0x4e, 0x72, 0x0d,
4784    0x50, 0x6d, 0x3b, 0xa3, 0x3b, 0xa3, 0x99, 0x5e, 0x9d, 0xc8, 0xd9, 0x0c,
4785    0x85, 0xb3, 0xd9, 0x8a, 0xd9, 0x54, 0x26, 0xdb, 0x6d, 0xfa, 0xac, 0xbb,
4786    0xff, 0x25, 0x4c, 0xc4, 0xd1, 0x79, 0xf4, 0x71, 0xd3, 0x86, 0x40, 0x18,
4787    0x13, 0xb0, 0x63, 0xb5, 0x72, 0x4e, 0x30, 0xc4, 0x97, 0x84, 0x86, 0x2d,
4788    0x56, 0x2f, 0xd7, 0x15, 0xf7, 0x7f, 0xc0, 0xae, 0xf5, 0xfc, 0x5b, 0xe5,
4789    0xfb, 0xa1, 0xba, 0xd3,
4790};
4791
4792
4793/* AES GCM */
4794static const byte aesgcm_k[] = {
4795    0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88,
4796    0x99, 0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66,
4797    0x77, 0x88, 0x99, 0x00, 0x11, 0x22, 0x33, 0x44,
4798    0x55, 0x66, 0x77, 0x88, 0x99, 0x00, 0x11, 0x22
4799};
4800
4801static const byte aesgcm_iv[] = {
4802    0xca, 0xfe, 0xca, 0xfe, 0xca, 0xfe, 0xca, 0xfe,
4803    0xca, 0xfe, 0xca, 0xfe
4804};
4805
4806static const byte aesgcm_a[] = {
4807    0xde, 0xad, 0xde, 0xad, 0xde, 0xad, 0xde, 0xad,
4808    0xde, 0xad, 0xde, 0xad, 0xde, 0xad, 0xde, 0xad,
4809    0xde, 0xad, 0xde, 0xad
4810};
4811
4812static const byte aesgcm_p[] = {
4813    0x79, 0x84, 0x86, 0x44, 0x68, 0x45, 0x15, 0x61,
4814    0x86, 0x54, 0x66, 0x56, 0x54, 0x54, 0x31, 0x54,
4815    0x64, 0x64, 0x68, 0x45, 0x15, 0x15, 0x61, 0x61,
4816    0x51, 0x51, 0x51, 0x51, 0x51, 0x56, 0x14, 0x11,
4817    0x72, 0x13, 0x51, 0x82, 0x84, 0x56, 0x74, 0x53,
4818    0x45, 0x34, 0x65, 0x15, 0x46, 0x14, 0x67, 0x55,
4819    0x16, 0x14, 0x67, 0x54, 0x65, 0x47, 0x14, 0x67,
4820    0x46, 0x74, 0x65, 0x46
4821};
4822
4823static const byte aesgcm_c[] = {
4824    0x59, 0x85, 0x02, 0x97, 0xE0, 0x4D, 0xFC, 0x5C,
4825    0x03, 0xCC, 0x83, 0x64, 0xCE, 0x28, 0x0B, 0x95,
4826    0x78, 0xEC, 0x93, 0x40, 0xA1, 0x8D, 0x21, 0xC5,
4827    0x48, 0x6A, 0x39, 0xBA, 0x4F, 0x4B, 0x8C, 0x95,
4828    0x6F, 0x8C, 0xF6, 0x9C, 0xD0, 0xA5, 0x8D, 0x67,
4829    0xA1, 0x32, 0x11, 0xE7, 0x2E, 0xF6, 0x63, 0xAF,
4830    0xDE, 0xD4, 0x7D, 0xEC, 0x15, 0x01, 0x58, 0xCB,
4831    0xE3, 0x7B, 0xC6, 0x94,
4832};
4833
4834static byte aesgcm_t[] = {
4835    0x5D, 0x10, 0x3F, 0xC7, 0x22, 0xC7, 0x21, 0x29
4836};
4837
4838
4839/* ecc curve */
4840static byte ecc_a[] = {
4841    0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x01,
4842    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
4843    0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff,
4844    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc
4845};
4846static byte ecc_b[] = {
4847    0x5a, 0xc6, 0x35, 0xd8, 0xaa, 0x3a, 0x93, 0xe7,
4848    0xb3, 0xeb, 0xbd, 0x55, 0x76, 0x98, 0x86, 0xbc,
4849    0x65, 0x1d, 0x06, 0xb0, 0xcc, 0x53, 0xb0, 0xf6,
4850    0x3b, 0xce, 0x3c, 0x3e, 0x27, 0xd2, 0x60, 0x4b
4851};
4852static byte ecc_q[] = {
4853    0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x01,
4854    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
4855    0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff,
4856    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff
4857};
4858/* private key */
4859static byte ecc_k[] = {
4860    0x52, 0x2f, 0x27, 0xe3, 0x44, 0x3c, 0xa7, 0x92,
4861    0x9b, 0xdc, 0xe3, 0x00, 0x8a, 0x47, 0x0f, 0x28,
4862    0x5c, 0x0e, 0x2d, 0x87, 0xfd, 0x89, 0x56, 0xdd,
4863    0x83, 0x94, 0x6c, 0x48, 0x6c, 0x15, 0x59, 0xb7,
4864    0xf1, 0xc8, 0x13, 0x27, 0xe5, 0x80, 0xbd, 0x9c
4865};
4866/* public key */
4867static byte ecc_xg[] = {
4868    0x6b, 0x17, 0xd1, 0xf2, 0xe1, 0x2c, 0x42, 0x47,
4869    0xf8, 0xbc, 0xe6, 0xe5, 0x63, 0xa4, 0x40, 0xf2,
4870    0x77, 0x03, 0x7d, 0x81, 0x2d, 0xeb, 0x33, 0xa0,
4871    0xf4, 0xa1, 0x39, 0x45, 0xd8, 0x98, 0xc2, 0x96
4872};
4873static byte ecc_yg[] = {
4874    0x4f, 0xe3, 0x42, 0xe2, 0xfe, 0x1a, 0x7f, 0x9b,
4875    0x8e, 0xe7, 0xeb, 0x4a, 0x7c, 0x0f, 0x9e, 0x16,
4876    0x2b, 0xce, 0x33, 0x57, 0x6b, 0x31, 0x5e, 0xce,
4877    0xcb, 0xb6, 0x40, 0x68, 0x37, 0xbf, 0x51, 0xf5
4878};
4879
4880
4881/* DH */
4882static byte dh_priv1[] = {
4883    0xbd, 0x64, 0xf6, 0xd2, 0xe9, 0xca, 0xd0, 0xda,
4884    0x41, 0x48, 0x95, 0x5d, 0xd3, 0xa7, 0x36, 0x47,
4885    0xb6, 0x28, 0xdf, 0x05, 0x7b, 0x9c, 0xcd, 0x34,
4886    0x79, 0x09, 0x7a, 0x06, 0x43,
4887};
4888
4889static byte dh_pub1[] = {
4890    0xaa, 0x43, 0x2e, 0xfd, 0xc6, 0xbe, 0x40, 0xdc, 0xac, 0x64, 0xf2, 0x65,
4891    0x91, 0xae, 0x88, 0xa0, 0x7b, 0x71, 0x3d, 0x9f, 0xa7, 0x00, 0xbe, 0x82,
4892    0xbb, 0xb5, 0x27, 0x2a, 0x58, 0xce, 0xb5, 0xf9, 0x18, 0x6e, 0x0b, 0xaa,
4893    0x75, 0x91, 0x59, 0x30, 0x2b, 0x1e, 0xf3, 0x26, 0xa5, 0x6a, 0x22, 0x91,
4894    0x65, 0xad, 0x5f, 0xef, 0x53, 0x57, 0x76, 0x53, 0xe8, 0xc2, 0x93, 0x9d,
4895    0x21, 0x7e, 0x91, 0x27, 0x79, 0xe4, 0xa5, 0xa1, 0x8b, 0x20, 0x52, 0xa2,
4896    0xd6, 0x22, 0xef, 0x15, 0x2c, 0xa7, 0xf3, 0xfc, 0xce, 0xc7, 0x1b, 0x90,
4897    0xaa, 0x9b, 0xb3, 0x83, 0xff, 0x21, 0xa0, 0x20, 0xc7, 0x21, 0x93, 0xbd,
4898    0x1a, 0xf3, 0xae, 0xd9, 0x16, 0x02, 0xf0, 0x62, 0x07, 0x68, 0xea, 0x1a,
4899    0xe7, 0xa6, 0xb9, 0xa6, 0x3b, 0x9a, 0x23, 0x4c, 0x21, 0xec, 0xa1, 0xe0,
4900    0x8f, 0x16, 0x2a, 0x99, 0x36, 0xbf, 0x57, 0x89, 0xf0, 0x3d, 0x84, 0xca,
4901    0x99, 0xe8, 0xea, 0x79, 0x24, 0xc0, 0x93, 0x96, 0x70, 0x9a, 0xbb, 0x16,
4902    0xa3, 0xe9, 0x06, 0x59, 0xb4, 0x6c, 0xe7, 0x48, 0x59, 0xde, 0x75, 0x83,
4903    0xbb, 0xc2, 0xa7, 0xd7, 0x84, 0x1d, 0xf4, 0x27, 0xf1, 0x72, 0x04, 0x64,
4904    0x01, 0x6b, 0x7b, 0xac, 0xf2, 0xaf, 0x12, 0x4c, 0x22, 0x83, 0xae, 0x8f,
4905    0x6d, 0x50, 0xe8, 0x16, 0xdc, 0x4c, 0x25, 0xe4, 0x54, 0x5a, 0xf0, 0xb7,
4906    0x82, 0x4f, 0xdc, 0x2e, 0xb5, 0xfd, 0x24, 0x26, 0x22, 0x26, 0x4f, 0x20,
4907    0x76, 0xb4, 0x36, 0x9e, 0x62, 0xb8, 0xb9, 0x2c, 0x52, 0xaf, 0x58, 0xa8,
4908    0x90, 0xcd, 0x62, 0x06, 0x30, 0xcc, 0x93, 0x8b, 0x3d, 0xd4, 0xd1, 0x5f,
4909    0x60, 0x3b, 0x28, 0x15, 0xcc, 0x92, 0xc1, 0x70, 0xb7, 0x39, 0x8c, 0x73,
4910    0x01, 0x65, 0x2f, 0x19, 0xeb, 0xd0, 0xce, 0x3f, 0x84, 0x36, 0xea, 0x11,
4911    0x34, 0x0e, 0xce, 0x0b,
4912};
4913
4914static byte dh_priv2[] = {
4915    0x5e, 0x49, 0x52, 0xb3, 0xc4, 0x8f, 0x3f, 0xde, 0x55, 0x9d, 0x87, 0xb3,
4916    0x21, 0xb8, 0x24, 0xb1, 0xb0, 0x35, 0x5e, 0xc7, 0xbb, 0x5a, 0x86, 0x9e,
4917    0xfb, 0xd3, 0x8f, 0x5b, 0x7e,
4918};
4919
4920static byte dh_pub2[] = {
4921    0x9b, 0xc4, 0xdb, 0x33, 0xc4, 0x96, 0xf4, 0x43, 0xa0, 0x3b, 0x9d, 0x7c,
4922    0x7d, 0x81, 0x97, 0xf6, 0xb9, 0x94, 0x0f, 0x0f, 0x2e, 0xc1, 0x16, 0xdc,
4923    0xf6, 0xe3, 0xaf, 0xa1, 0xcd, 0x32, 0xdf, 0xd5, 0xdc, 0x12, 0x93, 0x99,
4924    0x1d, 0xfb, 0xff, 0x54, 0xdf, 0xf6, 0x24, 0x6a, 0xc2, 0x9e, 0xd0, 0x41,
4925    0xed, 0x28, 0x23, 0x8d, 0x68, 0x06, 0x57, 0xd6, 0xb6, 0xf1, 0x9a, 0x5d,
4926    0x41, 0xc7, 0x96, 0xf8, 0xc4, 0x7f, 0xd6, 0x92, 0x97, 0x56, 0x05, 0xd9,
4927    0x17, 0x46, 0x07, 0x19, 0x0b, 0x08, 0xd5, 0xba, 0x90, 0xd8, 0x40, 0x94,
4928    0x2d, 0x90, 0x75, 0x01, 0x77, 0xa7, 0x12, 0x82, 0x5b, 0x82, 0x9e, 0x7b,
4929    0x75, 0x46, 0xce, 0x07, 0x40, 0x9b, 0xbb, 0x10, 0x3d, 0xf7, 0x80, 0xaa,
4930    0x39, 0xa3, 0x67, 0xfa, 0xd8, 0x07, 0xda, 0x09, 0x92, 0x68, 0x6d, 0xa4,
4931    0xe2, 0xda, 0xde, 0x6e, 0x98, 0xcd, 0x1e, 0x6d, 0x68, 0x72, 0x0e, 0x68,
4932    0x1e, 0xaa, 0x72, 0x12, 0x92, 0xe6, 0x96, 0x3d, 0x6c, 0x57, 0xb8, 0x77,
4933    0x61, 0x6d, 0xb8, 0x6f, 0x1e, 0xbe, 0xd8, 0x2c, 0xdd, 0xc4, 0xe9, 0x38,
4934    0x77, 0xde, 0x5f, 0x2f, 0xb6, 0x40, 0xf0, 0x30, 0x5b, 0x33, 0x16, 0xd4,
4935    0xef, 0x74, 0x9f, 0x38, 0xbc, 0x4d, 0x2d, 0xf3, 0x14, 0x8f, 0x38, 0xcc,
4936    0x6c, 0x8b, 0xad, 0xef, 0x30, 0xee, 0xc0, 0x36, 0x31, 0x6b, 0xc8, 0xb0,
4937    0x55, 0x44, 0x62, 0xb0, 0x24, 0x70, 0x9f, 0x64, 0x5c, 0xb1, 0x70, 0x19,
4938    0xfa, 0xd4, 0x8d, 0x23, 0xa8, 0x24, 0x72, 0x49, 0xfd, 0x23, 0x90, 0x18,
4939    0x99, 0xc1, 0xd0, 0x96, 0x91, 0x5f, 0x62, 0xf9, 0xd7, 0x14, 0xfa, 0x8b,
4940    0xeb, 0x05, 0x97, 0x03, 0xe1, 0x51, 0xc9, 0x3b, 0x8d, 0x41, 0x86, 0x53,
4941    0x45, 0xdc, 0x6d, 0xe1, 0xc7, 0x94, 0xfd, 0xdd, 0x57, 0xed, 0xc6, 0xe7,
4942    0x38, 0x84, 0xf7, 0xeb,
4943};
4944
4945/* dh1024 p */
4946static const byte dh_p[] = {
4947    0xb0, 0xa1, 0x08, 0x06, 0x9c, 0x08, 0x13, 0xba, 0x59, 0x06, 0x3c, 0xbc,
4948    0x30, 0xd5, 0xf5, 0x00, 0xc1, 0x4f, 0x44, 0xa7, 0xd6, 0xef, 0x4a, 0xc6,
4949    0x25, 0x27, 0x1c, 0xe8, 0xd2, 0x96, 0x53, 0x0a, 0x5c, 0x91, 0xdd, 0xa2,
4950    0xc2, 0x94, 0x84, 0xbf, 0x7d, 0xb2, 0x44, 0x9f, 0x9b, 0xd2, 0xc1, 0x8a,
4951    0xc5, 0xbe, 0x72, 0x5c, 0xa7, 0xe7, 0x91, 0xe6, 0xd4, 0x9f, 0x73, 0x07,
4952    0x85, 0x5b, 0x66, 0x48, 0xc7, 0x70, 0xfa, 0xb4, 0xee, 0x02, 0xc9, 0x3d,
4953    0x9a, 0x4a, 0xda, 0x3d, 0xc1, 0x46, 0x3e, 0x19, 0x69, 0xd1, 0x17, 0x46,
4954    0x07, 0xa3, 0x4d, 0x9f, 0x2b, 0x96, 0x17, 0x39, 0x6d, 0x30, 0x8d, 0x2a,
4955    0xf3, 0x94, 0xd3, 0x75, 0xcf, 0xa0, 0x75, 0xe6, 0xf2, 0x92, 0x1f, 0x1a,
4956    0x70, 0x05, 0xaa, 0x04, 0x83, 0x57, 0x30, 0xfb, 0xda, 0x76, 0x93, 0x38,
4957    0x50, 0xe8, 0x27, 0xfd, 0x63, 0xee, 0x3c, 0xe5, 0xb7, 0xc8, 0x09, 0xae,
4958    0x6f, 0x50, 0x35, 0x8e, 0x84, 0xce, 0x4a, 0x00, 0xe9, 0x12, 0x7e, 0x5a,
4959    0x31, 0xd7, 0x33, 0xfc, 0x21, 0x13, 0x76, 0xcc, 0x16, 0x30, 0xdb, 0x0c,
4960    0xfc, 0xc5, 0x62, 0xa7, 0x35, 0xb8, 0xef, 0xb7, 0xb0, 0xac, 0xc0, 0x36,
4961    0xf6, 0xd9, 0xc9, 0x46, 0x48, 0xf9, 0x40, 0x90, 0x00, 0x2b, 0x1b, 0xaa,
4962    0x6c, 0xe3, 0x1a, 0xc3, 0x0b, 0x03, 0x9e, 0x1b, 0xc2, 0x46, 0xe4, 0x48,
4963    0x4e, 0x22, 0x73, 0x6f, 0xc3, 0x5f, 0xd4, 0x9a, 0xd6, 0x30, 0x07, 0x48,
4964    0xd6, 0x8c, 0x90, 0xab, 0xd4, 0xf6, 0xf1, 0xe3, 0x48, 0xd3, 0x58, 0x4b,
4965    0xa6, 0xb9, 0xcd, 0x29, 0xbf, 0x68, 0x1f, 0x08, 0x4b, 0x63, 0x86, 0x2f,
4966    0x5c, 0x6b, 0xd6, 0xb6, 0x06, 0x65, 0xf7, 0xa6, 0xdc, 0x00, 0x67, 0x6b,
4967    0xbb, 0xc3, 0xa9, 0x41, 0x83, 0xfb, 0xc7, 0xfa, 0xc8, 0xe2, 0x1e, 0x7e,
4968    0xaf, 0x00, 0x3f, 0x93,
4969};
4970
4971
4972/* simple example of using RSA encrypt with Intel QA */
4973int main(int argc, char** argv)
4974{
4975    int ret;
4976    WC_ASYNC_DEV dev;
4977    byte out[256];
4978    word32 outLen = sizeof(out);
4979    byte tmp[256];
4980    word32 tmpLen = sizeof(tmp);
4981#ifndef NO_RSA
4982    WC_BIGINT d, n;
4983#endif
4984#if defined(HAVE_ECC) && defined(HAVE_ECC_DHE)
4985    WC_BIGINT k, xG, yG, xR, yR, a, b, q;
4986#endif
4987#ifndef NO_DH
4988    WC_BIGINT p;
4989#endif
4990
4991#ifdef QAT_DEBUG
4992    wolfSSL_Debugging_ON();
4993#endif
4994
4995    IntelQaInit(NULL);
4996
4997#ifdef QAT_ENABLE_RNG
4998    /* DRBG Test */
4999    IntelQaOpen(&dev, 0);
5000    ret = IntelQaDrbg(&dev, out, sizeof(out));
5001    printf("RNG1: Ret=%d\n", ret);
5002
5003    /* call again using same session */
5004    ret = IntelQaDrbg(&dev, out, sizeof(out));
5005    printf("RNG2: Ret=%d\n", ret);
5006    IntelQaClose(&dev);
5007#endif
5008
5009#ifndef NO_RSA
5010    IntelQaOpen(&dev, 0);
5011    /* RSA Test */
5012    dev.event.ret = WC_PENDING_E;
5013    XMEMSET(out, 0, sizeof(out));
5014    wc_bigint_init(&d);
5015    wc_bigint_init(&n);
5016    wc_bigint_from_unsigned_bin(&d, rsa_d, sizeof(rsa_d));
5017    wc_bigint_from_unsigned_bin(&n, rsa_n, sizeof(rsa_n));
5018    ret = IntelQaRsaPrivate(&dev, (byte*)rsa_in, sizeof(rsa_in), &d, &n, out,
5019        &outLen);
5020    if (ret == 0 || ret == WC_PENDING_E) {
5021        ret = IntelQaPollBlockRet(&dev, WC_PENDING_E);
5022    }
5023    printf("RSA Private: Ret=%d, Out Len=%d\n", ret, outLen);
5024    IntelQaClose(&dev);
5025#endif /* !NO_RSA */
5026
5027#ifndef NO_AES
5028#ifdef HAVE_AESGCM
5029    /* AES Test */
5030    IntelQaOpen(&dev, 0);
5031    dev.event.ret = WC_PENDING_E;
5032    tmpLen = sizeof(aesgcm_t);
5033    XMEMSET(out, 0, sizeof(out));
5034    XMEMSET(tmp, 0, sizeof(tmp));
5035
5036    ret = IntelQaSymAesGcmEncrypt(&dev, out, aesgcm_p, sizeof(aesgcm_p),
5037        aesgcm_k, sizeof(aesgcm_k), aesgcm_iv, sizeof(aesgcm_iv),
5038        tmp, tmpLen, aesgcm_a, sizeof(aesgcm_a));
5039    if (ret == 0 || ret == WC_PENDING_E) {
5040        ret = IntelQaPollBlockRet(&dev, WC_PENDING_E);
5041    }
5042    printf("AES GCM Encrypt: Ret=%d, Tag Len=%d\n", ret, tmpLen);
5043    IntelQaClose(&dev);
5044#endif /* HAVE_AESGCM */
5045#endif /* NO_AES */
5046
5047#ifdef HAVE_ECC
5048#ifdef HAVE_ECC_DHE
5049    /* ECDHE Test */
5050    IntelQaOpen(&dev, 0);
5051    dev.event.ret = WC_PENDING_E;
5052    XMEMSET(out, 0, sizeof(out));
5053    XMEMSET(tmp, 0, sizeof(tmp));
5054    wc_bigint_init(&xG);
5055    wc_bigint_init(&yG);
5056    wc_bigint_init(&k);
5057    wc_bigint_init(&a);
5058    wc_bigint_init(&b);
5059    wc_bigint_init(&q);
5060    wc_bigint_from_unsigned_bin(&xG, ecc_xg, sizeof(ecc_xg));
5061    wc_bigint_from_unsigned_bin(&yG, ecc_yg, sizeof(ecc_yg));
5062    wc_bigint_from_unsigned_bin(&k, ecc_k, sizeof(ecc_k));
5063    wc_bigint_from_unsigned_bin(&a, ecc_a, sizeof(ecc_a));
5064    wc_bigint_from_unsigned_bin(&b, ecc_b, sizeof(ecc_b));
5065    wc_bigint_from_unsigned_bin(&q, ecc_q, sizeof(ecc_q));
5066
5067    ret = IntelQaEcdh(&dev, &k, &xG, &yG, out, &outLen, &a, &b, &q, 1);
5068    if (ret == 0 || ret == WC_PENDING_E) {
5069        ret = IntelQaPollBlockRet(&dev, WC_PENDING_E);
5070    }
5071    printf("ECDH: Ret=%d, Result: X Len=%d, Y Len=%d\n", ret, xR.len, yR.len);
5072    IntelQaClose(&dev);
5073#endif /* HAVE_ECC_DHE */
5074#endif /* HAVE_ECC */
5075
5076#ifndef NO_DH
5077    /* DH Test */
5078    IntelQaOpen(&dev, 0);
5079    dev.event.ret = WC_PENDING_E;
5080    XMEMSET(out, 0, sizeof(out));
5081    XMEMSET(tmp, 0, sizeof(tmp));
5082    wc_bigint_init(&p);
5083    wc_bigint_from_unsigned_bin(&p, dh_p, sizeof(dh_p));
5084
5085    outLen = 0;
5086    ret = IntelQaDhAgree(&dev, &p, out, &outLen, dh_priv1, sizeof(dh_priv1),
5087        dh_pub2, sizeof(dh_pub2));
5088    if (ret == 0 || ret == WC_PENDING_E) {
5089        ret = IntelQaPollBlockRet(&dev, WC_PENDING_E);
5090    }
5091    printf("DH Agree1: Ret=%d, Out Len=%d\n", ret, outLen);
5092
5093    tmpLen = 0;
5094    ret = IntelQaDhAgree(&dev, &p, tmp, &tmpLen, dh_priv2, sizeof(dh_priv2),
5095        dh_pub1, sizeof(dh_pub1));
5096    if (ret == 0 || ret == WC_PENDING_E) {
5097        ret = IntelQaPollBlockRet(&dev, WC_PENDING_E);
5098    }
5099    printf("DH Agree2: Ret=%d, Out Len=%d\n", ret, tmpLen);
5100
5101    /* compare results */
5102    if (ret != 0 || outLen != tmpLen || memcmp(out, tmp, outLen) != 0) {
5103        printf("DH Agree Failed!\n");
5104    }
5105    else {
5106        printf("DH Agree Match\n");
5107    }
5108    IntelQaClose(&dev);
5109#endif /* !NO_DH */
5110
5111    (void)tmp;
5112    (void)tmpLen;
5113
5114    IntelQaDeInit(0);
5115
5116    return 0;
5117}
5118
5119#endif
5120
5121#endif /* HAVE_INTEL_QA */