luna - wolfssl/wolfcrypt/src/port/nxp/se050

   1/* se050_port.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 <stdint.h>
  27
  28#include <wolfssl/wolfcrypt/settings.h>
  29
  30#ifdef WOLFSSL_SE050
  31
  32#include <wolfssl/wolfcrypt/types.h> /* for MATH_INT_T */
  33#include <wolfssl/wolfcrypt/wc_port.h>
  34#include <wolfssl/wolfcrypt/aes.h>
  35#include <wolfssl/wolfcrypt/error-crypt.h>
  36#include <wolfssl/wolfcrypt/ed25519.h>
  37#include <wolfssl/wolfcrypt/logging.h>
  38#include <wolfssl/wolfcrypt/curve25519.h>
  39
  40#include <wolfssl/wolfcrypt/port/nxp/se050_port.h>
  41
  42#ifdef WOLFSSL_SE050_INIT
  43    #ifndef SE050_DEFAULT_PORT
  44    #define SE050_DEFAULT_PORT "/dev/i2c-1"
  45    #endif
  46
  47    #include "ex_sss_boot.h"
  48#endif
  49
  50#ifdef HAVE_ECC
  51    #include <wolfssl/wolfcrypt/ecc.h>
  52    struct ecc_key;
  53    #ifndef SE050_ECC_DER_MAX
  54    #define SE050_ECC_DER_MAX 256
  55    #endif
  56#endif
  57#if !defined(NO_RSA) && !defined(WOLFSSL_SE050_NO_RSA)
  58    #include <wolfssl/wolfcrypt/rsa.h>
  59    struct RsaKey;
  60#endif
  61#include <wolfssl/wolfcrypt/asn.h>
  62
  63#ifndef SE050_KEYID_START
  64#define SE050_KEYID_START 100
  65#endif
  66
  67/* enable for debugging */
  68/* #define SE050_DEBUG*/
  69/* enable to factory erase chip */
  70/* #define WOLFSSL_SE050_FACTORY_RESET */
  71
  72/* Global variables */
  73static sss_session_t *cfg_se050_i2c_pi;
  74static sss_key_store_t *gHostKeyStore;
  75static sss_key_store_t *gKeyStore;
  76
  77int wc_se050_set_config(sss_session_t *pSession, sss_key_store_t *pHostKeyStore,
  78    sss_key_store_t *pKeyStore)
  79{
  80    WOLFSSL_MSG("Setting SE050 session configuration");
  81
  82    cfg_se050_i2c_pi = pSession;
  83    gHostKeyStore = pHostKeyStore;
  84    gKeyStore = pKeyStore;
  85
  86    return 0;
  87}
  88
  89#ifdef WOLFSSL_SE050_INIT
  90int wc_se050_init(const char* portName)
  91{
  92    int ret;
  93    sss_status_t status;
  94    static ex_sss_boot_ctx_t pCtx;
  95
  96    if (portName == NULL) {
  97        portName = SE050_DEFAULT_PORT;
  98    }
  99
 100    status = ex_sss_boot_open(&pCtx, portName);
 101    if (status == kStatus_SSS_Success) {
 102        ret = wc_se050_set_config(&pCtx.session,
 103        #if SSS_HAVE_HOSTCRYPTO_ANY
 104            &pCtx.host_ks,
 105        #else
 106            NULL,
 107        #endif
 108            &pCtx.ks);
 109
 110    #ifdef WOLFSSL_SE050_FACTORY_RESET
 111        ex_sss_boot_factory_reset(&pCtx);
 112    #endif
 113    }
 114    else {
 115        WOLFSSL_MSG("Failed to open SE050 context");
 116        ret = WC_HW_E;
 117    }
 118    return ret;
 119}
 120#endif
 121
 122/**
 123 * Erase and free an object stored in SE050.
 124 *
 125 * keyId  ID of object to erase
 126 *
 127 * Returns 0 on success, negative on error.
 128 */
 129int wc_se050_erase_object(word32 id)
 130{
 131    int ret = 0;
 132    sss_object_t    object;
 133    sss_key_store_t host_keystore;
 134    sss_status_t    status = kStatus_SSS_Success;
 135
 136#ifdef SE050_DEBUG
 137    printf("wc_se050_erase_object: id %d\n", id);
 138#endif
 139
 140    if (cfg_se050_i2c_pi == NULL) {
 141        return BAD_FUNC_ARG;
 142    }
 143
 144    if (wolfSSL_CryptHwMutexLock() != 0) {
 145        return BAD_MUTEX_E;
 146    }
 147
 148    status = sss_key_store_context_init(&host_keystore, cfg_se050_i2c_pi);
 149    if (status == kStatus_SSS_Success) {
 150        status = sss_key_store_allocate(&host_keystore,
 151                                        SE050_KEYSTOREID_GENERIC);
 152    }
 153    if (status == kStatus_SSS_Success) {
 154        status = sss_key_object_init(&object, &host_keystore);
 155    }
 156    if (status == kStatus_SSS_Success) {
 157        status = sss_key_object_get_handle(&object, id);
 158    }
 159    if (status == kStatus_SSS_Success) {
 160        sss_key_store_erase_key(&host_keystore, &object);
 161        sss_key_object_free(&object);
 162    }
 163    wolfSSL_CryptHwMutexUnLock();
 164
 165    if (status != kStatus_SSS_Success) {
 166        ret = WC_HW_E;
 167    }
 168
 169    return ret;
 170}
 171
 172word32 se050_allocate_key(int keyType)
 173{
 174    word32 keyId = 0;
 175    static word32 keyId_allocator = SE050_KEYID_START;
 176    switch (keyType) {
 177        case SE050_AES_KEY:
 178        case SE050_ECC_KEY:
 179        case SE050_RSA_KEY:
 180        case SE050_ED25519_KEY:
 181        case SE050_CURVE25519_KEY:
 182        case SE050_ANY_KEY:
 183            keyId = keyId_allocator++;
 184            break;
 185    }
 186#ifdef SE050_DEBUG
 187    printf("se050_allocate_key: keyId %d\n", keyId);
 188#endif
 189    return keyId;
 190}
 191
 192#if !defined(WC_NO_RNG) && !defined(WOLFSSL_SE050_NO_TRNG)
 193int se050_get_random_number(uint32_t count, uint8_t* rand_out)
 194{
 195    int ret = 0;
 196    sss_status_t status;
 197    sss_rng_context_t rng;
 198
 199#ifdef SE050_DEBUG
 200    printf("se050_get_random_number: %p (%d)\n", rand_out, count);
 201#endif
 202
 203    if (cfg_se050_i2c_pi == NULL) {
 204        return WC_HW_E;
 205    }
 206
 207    if (wolfSSL_CryptHwMutexLock() != 0) {
 208        return BAD_MUTEX_E;
 209    }
 210    status = sss_rng_context_init(&rng, cfg_se050_i2c_pi);
 211    if (status == kStatus_SSS_Success) {
 212        status = sss_rng_get_random(&rng, rand_out, count);
 213    }
 214    if (status == kStatus_SSS_Success) {
 215        status = sss_rng_context_free(&rng);
 216    }
 217    if (status != kStatus_SSS_Success) {
 218        ret = RNG_FAILURE_E;
 219    }
 220
 221    wolfSSL_CryptHwMutexUnLock();
 222
 223    return ret;
 224}
 225#endif /* !WC_NO_RNG && !WOLFSSL_SE050_NO_TRNG */
 226
 227#ifdef WOLFSSL_SE050_HASH
 228
 229/* Used for sha/sha224/sha384/sha512 */
 230int se050_hash_init(SE050_HASH_Context* se050Ctx, void* heap)
 231{
 232    se050Ctx->heap = heap;
 233    se050Ctx->len  = 0;
 234    se050Ctx->used = 0;
 235    se050Ctx->msg  = NULL;
 236    return 0;
 237}
 238
 239int se050_hash_copy(SE050_HASH_Context* src, SE050_HASH_Context* dst)
 240{
 241    if (src == NULL || dst == NULL || (src->used != dst->used)) {
 242        return BAD_FUNC_ARG;
 243    }
 244
 245    if (src->used > 0) {
 246        /* dst->msg points to same buffer as src->msg, needs to be allocated
 247         * and dep copied over instead of plain pointer copy */
 248        dst->msg = (byte*)XMALLOC(src->used, dst->heap,
 249                                  DYNAMIC_TYPE_TMP_BUFFER);
 250        if (dst->msg == NULL) {
 251            PRINTF("Tried to allocate %d bytes\n", dst->used);
 252            return MEMORY_E;
 253        }
 254        XMEMSET(dst->msg, 0, dst->used);
 255        XMEMCPY(dst->msg, src->msg, src->used);
 256        dst->used = src->used;
 257        dst->len = src->used;
 258    } else {
 259        dst->msg = NULL;
 260        dst->len = 0;
 261        dst->used = 0;
 262    }
 263
 264    return 0;
 265}
 266
 267int se050_hash_update(SE050_HASH_Context* se050Ctx, const byte* data, word32 len)
 268{
 269    byte* tmp = NULL;
 270    word32 usedSz = 0;
 271
 272    if (se050Ctx == NULL || (len > 0 && data == NULL) || (len == 0) ||
 273        !WC_SAFE_SUM_WORD32(se050Ctx->used, len, usedSz)) {
 274        return BAD_FUNC_ARG;
 275    }
 276
 277    if (se050Ctx->len < usedSz) {
 278        if (se050Ctx->msg == NULL) {
 279            se050Ctx->msg = (byte*)XMALLOC(usedSz,
 280                se050Ctx->heap, DYNAMIC_TYPE_TMP_BUFFER);
 281            if (se050Ctx->msg == NULL) {
 282                return MEMORY_E;
 283            }
 284            XMEMSET(se050Ctx->msg, 0, usedSz);
 285        }
 286        else {
 287            tmp = (byte*)XMALLOC(usedSz, se050Ctx->heap,
 288                                 DYNAMIC_TYPE_TMP_BUFFER);
 289            if (tmp == NULL) {
 290                return MEMORY_E;
 291            }
 292            XMEMSET(tmp, 0, usedSz);
 293            XMEMCPY(tmp, se050Ctx->msg, se050Ctx->used);
 294            XFREE(se050Ctx->msg, se050Ctx->heap, DYNAMIC_TYPE_TMP_BUFFER);
 295            se050Ctx->msg = tmp;
 296        }
 297        se050Ctx->len = usedSz;
 298    }
 299
 300    XMEMCPY(se050Ctx->msg + se050Ctx->used, data, len);
 301    se050Ctx->used += len;
 302
 303    return 0;
 304}
 305
 306int se050_hash_final(SE050_HASH_Context* se050Ctx, byte* hash, size_t digestLen,
 307    sss_algorithm_t algo)
 308{
 309    int          ret;
 310    sss_status_t status;
 311    sss_digest_t digest_ctx;
 312    const byte*  data = se050Ctx->msg;
 313    int          size = (se050Ctx->used) / SSS_BLOCK_SIZE;
 314    int          leftover = (se050Ctx->used) % SSS_BLOCK_SIZE;
 315    const byte*  blocks = data;
 316
 317    if (cfg_se050_i2c_pi == NULL) {
 318        return WC_HW_E;
 319    }
 320
 321    if (wolfSSL_CryptHwMutexLock() != 0) {
 322        return BAD_MUTEX_E;
 323    }
 324
 325    status = sss_digest_context_init(&digest_ctx, cfg_se050_i2c_pi, algo,
 326        kMode_SSS_Digest);
 327    if (status == kStatus_SSS_Success) {
 328        status = sss_digest_init(&digest_ctx);
 329    }
 330    if (status == kStatus_SSS_Success) {
 331        /* used to send chunks of size 512 */
 332        while (status == kStatus_SSS_Success && size--) {
 333            status = sss_digest_update(&digest_ctx, blocks, SSS_BLOCK_SIZE);
 334            blocks += SSS_BLOCK_SIZE;
 335        }
 336        if (status == kStatus_SSS_Success && leftover) {
 337            status = sss_digest_update(&digest_ctx, blocks, leftover);
 338        }
 339        if (status == kStatus_SSS_Success) {
 340            status = sss_digest_finish(&digest_ctx, hash, &digestLen);
 341        }
 342        sss_digest_context_free(&digest_ctx);
 343    }
 344
 345    if (status == kStatus_SSS_Success) {
 346        /* reset state */
 347        XFREE(se050Ctx->msg, se050Ctx->heap, DYNAMIC_TYPE_TMP_BUFFER);
 348        ret = se050_hash_init(se050Ctx, se050Ctx->heap);
 349    } else {
 350        ret = WC_HW_E;
 351    }
 352
 353    wolfSSL_CryptHwMutexUnLock();
 354
 355    return ret;
 356}
 357
 358void se050_hash_free(SE050_HASH_Context* se050Ctx)
 359{
 360    XFREE(se050Ctx->msg, se050Ctx->heap, DYNAMIC_TYPE_TMP_BUFFER);
 361    se050Ctx->msg = NULL;
 362    se050Ctx->len  = 0;
 363    se050Ctx->used = 0;
 364}
 365
 366#endif /* WOLFSSL_SE050_HASH */
 367
 368#if defined(WOLFSSL_SE050_CRYPT) && !defined(NO_AES)
 369
 370int se050_aes_set_key(Aes* aes, const byte* key, word32 keylen,
 371                                        const byte* iv, int dir)
 372{
 373    int ret = 0;
 374    sss_status_t status;
 375    sss_object_t newKey;
 376    sss_key_store_t host_keystore;
 377    word32 keyId;
 378    int keyCreated = 0;
 379
 380    if (cfg_se050_i2c_pi == NULL) {
 381        return WC_HW_E;
 382    }
 383
 384    if (wolfSSL_CryptHwMutexLock() != 0) {
 385        return BAD_MUTEX_E;
 386    }
 387
 388    (void)dir;
 389    (void)iv;
 390
 391    aes->rounds = keylen/4 + 6;
 392
 393    /* free existing key in slot first before storing new one */
 394    ret = wc_se050_erase_object(aes->keyId);
 395    if (ret != 0) {
 396        wolfSSL_CryptHwMutexUnLock();
 397        return ret;
 398    }
 399    aes->keyIdSet = 0;
 400
 401    status = sss_key_store_context_init(&host_keystore, cfg_se050_i2c_pi);
 402    if (status == kStatus_SSS_Success) {
 403        status = sss_key_store_allocate(&host_keystore, SE050_KEYSTOREID_AES);
 404    }
 405    if (status == kStatus_SSS_Success) {
 406        status = sss_key_object_init(&newKey, &host_keystore);
 407    }
 408    if (status == kStatus_SSS_Success) {
 409        keyId = se050_allocate_key(SE050_AES_KEY);
 410        status = sss_key_object_allocate_handle(&newKey, keyId,
 411            kSSS_KeyPart_Default, kSSS_CipherType_AES, keylen,
 412            kKeyObject_Mode_Transient);
 413    }
 414    if (status == kStatus_SSS_Success) {
 415        status = sss_key_store_set_key(&host_keystore, &newKey, key, keylen,
 416                                    keylen * 8, NULL, 0);
 417    }
 418
 419    if (status == kStatus_SSS_Success) {
 420        keyCreated = 1;
 421        aes->keyId = keyId;
 422        aes->keyIdSet = 1;
 423        ret = 0;
 424    }
 425    else {
 426        if (keyCreated) {
 427            sss_key_store_erase_key(&host_keystore, &newKey);
 428            sss_key_object_free(&newKey);
 429        }
 430        ret = WC_HW_E;
 431    }
 432
 433    wolfSSL_CryptHwMutexUnLock();
 434
 435    return ret;
 436}
 437
 438int se050_aes_crypt(Aes* aes, const byte* in, byte* out, word32 sz, int dir,
 439    sss_algorithm_t algorithm)
 440{
 441    int             ret = 0;
 442    sss_status_t    status;
 443    sss_object_t    keyObject;
 444    sss_key_store_t host_keystore;
 445
 446    if (cfg_se050_i2c_pi == NULL) {
 447        return WC_HW_E;
 448    }
 449    if (aes->keyIdSet == 0) {
 450        return BAD_FUNC_ARG;
 451    }
 452
 453    if (wolfSSL_CryptHwMutexLock() != 0) {
 454        return BAD_MUTEX_E;
 455    }
 456
 457    status = sss_key_store_context_init(&host_keystore, cfg_se050_i2c_pi);
 458    if (status == kStatus_SSS_Success) {
 459        status = sss_key_store_allocate(&host_keystore, SE050_KEYSTOREID_AES);
 460    }
 461    if (status == kStatus_SSS_Success) {
 462        status = sss_key_object_init(&keyObject, &host_keystore);
 463    }
 464    if (status == kStatus_SSS_Success) {
 465        status = sss_key_object_get_handle(&keyObject, aes->keyId);
 466    }
 467
 468    /* The first call to this function needs an initialization call,
 469        * subsequent calls just need to call update */
 470    if (status == kStatus_SSS_Success && aes->ctxInitDone == 0) {
 471        sss_mode_t      mode;
 472
 473        XMEMSET(&mode, 0, sizeof(mode));
 474        if (dir == AES_DECRYPTION)
 475            mode = kMode_SSS_Decrypt;
 476        else if (dir == AES_ENCRYPTION)
 477            mode = kMode_SSS_Encrypt;
 478
 479        if (status == kStatus_SSS_Success) {
 480            status = sss_symmetric_context_init(&aes->aes_ctx,
 481                cfg_se050_i2c_pi, &keyObject, algorithm, mode);
 482        }
 483        if (status == kStatus_SSS_Success) {
 484            aes->ctxInitDone = 1;
 485            status = sss_cipher_init(&aes->aes_ctx, (uint8_t*)aes->reg,
 486                sizeof(aes->reg));
 487        }
 488    }
 489    if (status == kStatus_SSS_Success) {
 490        size_t outSz = (size_t)sz;
 491        status = sss_cipher_update(&aes->aes_ctx, in, sz, out, &outSz);
 492    }
 493
 494    ret = (status == kStatus_SSS_Success) ? 0 : WC_HW_E;
 495
 496    wolfSSL_CryptHwMutexUnLock();
 497
 498    return ret;
 499}
 500
 501void se050_aes_free(Aes* aes)
 502{
 503    if (aes == NULL) {
 504        return;
 505    }
 506
 507    if (aes->ctxInitDone) {
 508        sss_symmetric_context_free(&aes->aes_ctx);
 509
 510        /* sets back to zero to indicate that a free has been called */
 511        aes->ctxInitDone = 0;
 512    }
 513
 514    aes->keyId = 0;
 515    aes->keyIdSet = 0;
 516}
 517
 518#endif /* WOLFSSL_SE050_CRYPT && !NO_AES */
 519
 520/**
 521 * Get size of a SE05X secure object at specified object ID.
 522 *
 523 * keystore  SE050 keystore associated with object
 524 * keyId     SE050 key ID in which object is stored
 525 *
 526 * Size returned depends on object type:
 527 *   ECC key: curve size
 528 *   RSA/AES/DES/HMAC key: key size
 529 *   Binary file: file size
 530 *
 531 * Return size or negative on error
 532 */
 533static int se050_get_object_size(sss_key_store_t* keystore, word32 keyId)
 534{
 535    uint16_t size = 0;
 536    smStatus_t status = SM_NOT_OK;
 537    sss_se05x_key_store_t* se05x_keystore = NULL;
 538
 539    if (keystore == NULL) {
 540        return BAD_FUNC_ARG;
 541    }
 542
 543    se05x_keystore = (sss_se05x_key_store_t*)keystore;
 544    status = Se05x_API_ReadSize(&se05x_keystore->session->s_ctx,
 545                                keyId, &size);
 546    if (status != SM_OK) {
 547        return WC_HW_E;
 548    }
 549
 550    return (int)size;
 551}
 552
 553/**
 554 * Insert binary object into SE050 as persistent object.
 555 *
 556 * keyId       SE050 key ID to store object in
 557 * object      binary object data
 558 * objectSz    size of binary object, bytes
 559 *
 560 * Returns 0 on success, negative on error
 561 */
 562int wc_se050_insert_binary_object(word32 keyId, const byte* object,
 563                                  word32 objectSz)
 564{
 565    int             ret = 0;
 566    sss_object_t    newObj;
 567    sss_key_store_t host_keystore;
 568    sss_status_t    status = kStatus_SSS_Success;
 569
 570    if (wolfSSL_CryptHwMutexLock() != 0) {
 571        return BAD_MUTEX_E;
 572    }
 573
 574    /* Avoid key ID conflicts with temporary key storage */
 575    if (keyId >= SE050_KEYID_START) {
 576        wolfSSL_CryptHwMutexUnLock();
 577        return BAD_FUNC_ARG;
 578    }
 579
 580    status = sss_key_store_context_init(&host_keystore, cfg_se050_i2c_pi);
 581    if (status == kStatus_SSS_Success) {
 582        status = sss_key_object_init(&newObj, &host_keystore);
 583    }
 584    if (status == kStatus_SSS_Success) {
 585        status = sss_key_object_allocate_handle(&newObj, keyId,
 586            kSSS_KeyPart_Default, kSSS_CipherType_Binary, objectSz,
 587            kKeyObject_Mode_Persistent);
 588    }
 589    if (status == kStatus_SSS_Success) {
 590        status = sss_key_store_set_key(&host_keystore, &newObj, object,
 591                                       objectSz, (objectSz * 8), NULL, 0);
 592    }
 593    wolfSSL_CryptHwMutexUnLock();
 594
 595    if (status != kStatus_SSS_Success) {
 596        ret = WC_HW_E;
 597    }
 598
 599    return ret;
 600}
 601
 602/**
 603 * Get binary object from SE050 from specified key ID.
 604 *
 605 * keyId  SE050 key ID to get binary object from
 606 * out    output buffer to place binary object
 607 * outSz  size of output buffer on input, size of written object on output
 608 *
 609 * Returns 0 on success, LENGTH_ONLY_E if out is NULL with outSz set to
 610 * required buffer size, and other negative on error.
 611 */
 612int wc_se050_get_binary_object(word32 keyId, byte* out, word32* outSz)
 613{
 614    int             ret = 0;
 615    sss_object_t    object;
 616    sss_key_store_t host_keystore;
 617    sss_status_t    status = kStatus_SSS_Success;
 618    size_t outBitSz = 0;
 619
 620    /* If out is NULL, outSz set to required size and LENGTH_ONLY_E returned */
 621    if (outSz == NULL) {
 622        return BAD_FUNC_ARG;
 623    }
 624
 625    if (wolfSSL_CryptHwMutexLock() != 0) {
 626        return BAD_MUTEX_E;
 627    }
 628
 629    status = sss_key_store_context_init(&host_keystore, cfg_se050_i2c_pi);
 630    if (status == kStatus_SSS_Success) {
 631        status = sss_key_object_init(&object, &host_keystore);
 632    }
 633    if (status == kStatus_SSS_Success) {
 634        ret = se050_get_object_size(&host_keystore, keyId);
 635        if (ret < 0) {
 636            status = kStatus_SSS_Fail;
 637        }
 638        else {
 639            if (out == NULL) {
 640                *outSz = ret;
 641                wolfSSL_CryptHwMutexUnLock();
 642                return WC_NO_ERR_TRACE(LENGTH_ONLY_E);
 643            }
 644            if ((word32)ret > *outSz) {
 645                WOLFSSL_MSG("Output buffer not large enough for object");
 646                wolfSSL_CryptHwMutexUnLock();
 647                return BAD_LENGTH_E;
 648            }
 649            ret = 0;
 650        }
 651    }
 652    if (status == kStatus_SSS_Success) {
 653        status = sss_key_object_get_handle(&object, keyId);
 654    }
 655    if (status == kStatus_SSS_Success) {
 656        outBitSz = (*outSz) * 8;
 657        status = sss_key_store_get_key(&host_keystore, &object, out,
 658                                       (size_t*)outSz, &outBitSz);
 659    }
 660    wolfSSL_CryptHwMutexUnLock();
 661
 662    if (status != kStatus_SSS_Success) {
 663        ret = WC_HW_E;
 664    }
 665
 666    return ret;
 667}
 668
 669#if !defined(NO_RSA) && !defined(WOLFSSL_SE050_NO_RSA)
 670
 671/**
 672 * Use specified SE050 key ID with this RsaKey struct.
 673 * Should be called by wc_RsaUseKeyId() for using pre-populated
 674 * SE050 keys.
 675 *
 676 * key   Pointer to initialized RsaKey structure
 677 * keyId SE050 key ID containing RSA key object
 678 *
 679 * Return 0 on success, negative on error.
 680 */
 681int se050_rsa_use_key_id(struct RsaKey* key, word32 keyId)
 682{
 683    int ret = 0;
 684    sss_object_t    keyObject;
 685    sss_key_store_t host_keystore;
 686    sss_status_t    status = kStatus_SSS_Success;
 687    uint8_t*        derBuf = NULL;
 688    size_t          derSz = 0;
 689    size_t          derSzBits = 0;
 690    word32          idx = 0;
 691
 692#ifdef SE050_DEBUG
 693    printf("se050_rsa_use_key_id: key %p, keyId %d\n", key, keyId);
 694#endif
 695    if (key == NULL) {
 696        return BAD_FUNC_ARG;
 697    }
 698
 699    if (cfg_se050_i2c_pi == NULL) {
 700        return WC_HW_E;
 701    }
 702
 703    if (wolfSSL_CryptHwMutexLock() != 0) {
 704        return BAD_MUTEX_E;
 705    }
 706
 707    status = sss_key_store_context_init(&host_keystore, cfg_se050_i2c_pi);
 708    if (status == kStatus_SSS_Success) {
 709        status = sss_key_store_allocate(&host_keystore, SE050_KEYSTOREID_RSA);
 710    }
 711    if (status == kStatus_SSS_Success) {
 712        status = sss_key_object_init(&keyObject, &host_keystore);
 713    }
 714    if (status == kStatus_SSS_Success) {
 715        status = sss_key_object_get_handle(&keyObject, keyId);
 716    }
 717    if (status == kStatus_SSS_Success) {
 718        ret = se050_get_object_size(&host_keystore, keyObject.keyId);
 719        if (ret <= 0) {
 720            status = kStatus_SSS_Fail;
 721        }
 722        else {
 723            /* double derSz to allow for ASN.1 encoding space */
 724            derSz = ((size_t)ret) * 2;
 725            ret = 0;
 726            derBuf = (uint8_t*)XMALLOC(derSz, key->heap,
 727                                       DYNAMIC_TYPE_TMP_BUFFER);
 728            if (derBuf == NULL) {
 729                WOLFSSL_MSG("Error calling malloc for RSA DER buffer");
 730                status = kStatus_SSS_Fail;
 731            }
 732        }
 733    }
 734    if (status == kStatus_SSS_Success) {
 735        derSzBits = derSz * 8;
 736        XMEMSET(derBuf, 0, derSz);
 737        status = sss_key_store_get_key(&host_keystore, &keyObject,
 738            derBuf, &derSz, &derSzBits);
 739        (void)derSzBits; /* not used */
 740    }
 741    if (status == kStatus_SSS_Success) {
 742        /* Populate RsaKey with general key info, for wolfCrypt to use */
 743        ret = wc_RsaPublicKeyDecode(derBuf, &idx, key, (word32)derSz);
 744        if (ret != 0) {
 745            status = kStatus_SSS_Fail;
 746        }
 747    }
 748    XFREE(derBuf, key->heap, DYNAMIC_TYPE_TMP_BUFFER);
 749
 750    if (status == kStatus_SSS_Success) {
 751        key->keyId = keyId;
 752        key->keyIdSet = 1;
 753        key->type = RSA_PRIVATE;
 754        ret = 0;
 755    }
 756    else if (ret == 0) {
 757        ret = WC_HW_E;
 758    }
 759
 760    sss_key_object_free(&keyObject);
 761
 762    wolfSSL_CryptHwMutexUnLock();
 763
 764#ifdef SE050_DEBUG
 765    printf("se050_rsa_use_key_id: ret %d\n", ret);
 766#endif
 767
 768    return ret;
 769}
 770
 771/**
 772 * Get SE050 key ID associated with this RsaKey struct.
 773 * Should be called by wc_RsaGetKeyId() for the application to get
 774 * what key ID wolfCrypt picked for this RsaKey struct when generating
 775 * a key inside the SE050.
 776 *
 777 * key   Pointer to initialized RsaKey structure
 778 * keyId [OUT] SE050 key ID associated with this key structure
 779 *
 780 * Return 0 on success, negative on error.
 781 */
 782int se050_rsa_get_key_id(struct RsaKey* key, word32* keyId)
 783{
 784    int ret = 0;
 785
 786    if (key == NULL || keyId == NULL) {
 787        return BAD_FUNC_ARG;
 788    }
 789
 790    if (key->keyIdSet == 1) {
 791        *keyId = key->keyId;
 792
 793    } else {
 794        WOLFSSL_MSG("SE050 key ID not set for RsaKey struct");
 795        ret = WC_HW_E;
 796    }
 797
 798    return ret;
 799}
 800
 801/**
 802 * Create RSA key pair inside SE050.
 803 *
 804 * key   RsaKey structure to store generated key information in
 805 * size  RSA key size to generate in bytes
 806 * e     RSA exponent, must be 65537 for SE050 compatibility
 807 *
 808 * Returns 0 on success, negative on error.
 809 */
 810int se050_rsa_create_key(struct RsaKey* key, int size, long e)
 811{
 812    int             ret = 0;
 813    word32          keyId = 0;
 814    int             keyCreated = 0;
 815    sss_status_t    status = kStatus_SSS_Success;
 816    sss_object_t    keyPair;
 817    sss_key_store_t host_keystore;
 818    uint8_t*        derBuf = NULL;
 819    size_t          derSz = 0;
 820    size_t          derSzBits = 0;
 821    word32          idx = 0;
 822
 823#ifdef SE050_DEBUG
 824    printf("se050_rsa_create_key: key %p, size %d, e %ld\n", key, size, e);
 825#endif
 826
 827    if (cfg_se050_i2c_pi == NULL) {
 828        return WC_HW_E;
 829    }
 830
 831    if (e != 65537) {
 832        WOLFSSL_MSG("SE050 RSA key create only supports exponent of 65537");
 833        return WC_HW_E;
 834    }
 835
 836    if (wolfSSL_CryptHwMutexLock() != 0) {
 837        return BAD_MUTEX_E;
 838    }
 839
 840    status = sss_key_store_context_init(&host_keystore, cfg_se050_i2c_pi);
 841    if (status == kStatus_SSS_Success) {
 842        status = sss_key_store_allocate(&host_keystore, SE050_KEYSTOREID_RSA);
 843    }
 844    if (status == kStatus_SSS_Success) {
 845        status = sss_key_object_init(&keyPair, &host_keystore);
 846    }
 847    if (status == kStatus_SSS_Success) {
 848        keyId = se050_allocate_key(SE050_RSA_KEY);
 849        status = sss_key_object_allocate_handle(&keyPair, keyId,
 850            kSSS_KeyPart_Pair, kSSS_CipherType_RSA, (size / 8),
 851            kKeyObject_Mode_Persistent);
 852    }
 853    if (status == kStatus_SSS_Success) {
 854        /* Try to delete existing key first. Ignore return since will fail
 855         * if no key exists */
 856        sss_key_store_erase_key(&host_keystore, &keyPair);
 857
 858        keyCreated = 1;
 859        status = sss_key_store_generate_key(&host_keystore, &keyPair,
 860            size, NULL);
 861    }
 862    if (status == kStatus_SSS_Success) {
 863        ret = se050_get_object_size(&host_keystore, keyPair.keyId);
 864        if (ret <= 0) {
 865            status = kStatus_SSS_Fail;
 866        }
 867        else {
 868            /* double derSz to allow for ASN.1 encoding space */
 869            derSz = ((size_t)ret) * 2;
 870            ret = 0;
 871            derBuf = (uint8_t*)XMALLOC(derSz, key->heap,
 872                                       DYNAMIC_TYPE_TMP_BUFFER);
 873            if (derBuf == NULL) {
 874                WOLFSSL_MSG("Error calling malloc for RSA DER buffer");
 875                status = kStatus_SSS_Fail;
 876            }
 877        }
 878    }
 879    if (status == kStatus_SSS_Success) {
 880        derSzBits = derSz * 8;
 881        XMEMSET(derBuf, 0, derSz);
 882        status = sss_key_store_get_key(&host_keystore, &keyPair,
 883            derBuf, &derSz, &derSzBits);
 884        (void)derSzBits; /* not used */
 885    }
 886    if (status == kStatus_SSS_Success) {
 887        ret = wc_RsaPublicKeyDecode(derBuf, &idx, key, (word32)derSz);
 888        if (ret != 0) {
 889            status = kStatus_SSS_Fail;
 890        }
 891    }
 892    XFREE(derBuf, key->heap, DYNAMIC_TYPE_TMP_BUFFER);
 893
 894    if (status == kStatus_SSS_Success) {
 895        key->keyId = keyId;
 896        key->keyIdSet = 1;
 897        key->type = RSA_PRIVATE;
 898        ret = 0;
 899    }
 900    else {
 901        if (keyCreated) {
 902            sss_key_store_erase_key(&host_keystore, &keyPair);
 903            sss_key_object_free(&keyPair);
 904        }
 905        if (ret == 0) {
 906            ret = WC_HW_E;
 907        }
 908    }
 909
 910    wolfSSL_CryptHwMutexUnLock();
 911
 912#ifdef SE050_DEBUG
 913    printf("se050_rsa_create_key: key %p, ret %d, keyId %d\n",
 914           key, ret, key->keyId);
 915#endif
 916
 917    return ret;
 918}
 919
 920static int se050_rsa_insert_key(word32 keyId, const byte* rsaDer,
 921                                word32 rsaDerSize, int keyType)
 922{
 923    int             ret = 0;
 924    int             keySize;
 925    word32          idx = 0;
 926    sss_object_t    newKey;
 927    sss_key_store_t host_keystore;
 928    sss_status_t    status = kStatus_SSS_Success;
 929    struct RsaKey   key;
 930    sss_key_part_t  keyPart = kSSS_KeyPart_Pair;
 931
 932    if (wolfSSL_CryptHwMutexLock() != 0) {
 933        return BAD_MUTEX_E;
 934    }
 935
 936    /* Avoid key ID conflicts with temporary key storage */
 937    if (keyId >= SE050_KEYID_START) {
 938        wolfSSL_CryptHwMutexUnLock();
 939        return BAD_FUNC_ARG;
 940    }
 941
 942    ret = wc_InitRsaKey(&key, NULL);
 943    if (ret != 0) {
 944        status = kStatus_SSS_Fail;
 945    }
 946    else {
 947        if (keyType == RSA_PUBLIC) {
 948            keyPart = kSSS_KeyPart_Public;
 949            ret = wc_RsaPublicKeyDecode(rsaDer, &idx, &key, rsaDerSize);
 950        }
 951        else if (keyType == RSA_PRIVATE) {
 952            keyPart = kSSS_KeyPart_Pair;
 953            ret = wc_RsaPrivateKeyDecode(rsaDer, &idx, &key, rsaDerSize);
 954        }
 955        else {
 956            ret = BAD_FUNC_ARG;
 957        }
 958
 959        if (ret != 0) {
 960            status = kStatus_SSS_Fail;
 961        }
 962    }
 963
 964    if (status == kStatus_SSS_Success) {
 965        keySize = wc_RsaEncryptSize(&key);
 966        if (keySize < 0) {
 967            status = kStatus_SSS_Fail;
 968        }
 969    }
 970    if (status == kStatus_SSS_Success) {
 971        status = sss_key_store_context_init(&host_keystore, cfg_se050_i2c_pi);
 972    }
 973    if (status == kStatus_SSS_Success) {
 974        status = sss_key_object_init(&newKey, &host_keystore);
 975    }
 976    if (status == kStatus_SSS_Success) {
 977        status = sss_key_object_allocate_handle(&newKey, keyId,
 978            keyPart, kSSS_CipherType_RSA, keySize,
 979            kKeyObject_Mode_Persistent);
 980    }
 981    if (status == kStatus_SSS_Success) {
 982        status = sss_key_store_set_key(&host_keystore, &newKey, rsaDer,
 983                                       rsaDerSize, (keySize * 8), NULL, 0);
 984    }
 985    wolfSSL_CryptHwMutexUnLock();
 986
 987    wc_FreeRsaKey(&key);
 988    if (status != kStatus_SSS_Success) {
 989        if (ret == 0) {
 990            ret = WC_HW_E;
 991        }
 992    }
 993
 994    return ret;
 995}
 996
 997/**
 998 * Insert DER encoded RSA private key into SE050 as a persistent key.
 999 *
1000 * keyId       SE050 key ID to store key into
1001 * rsaDer      DER encoded RSA private key
1002 * rsaDerSize  size of DER buffer, bytes
1003 *
1004 * Returns 0 on success, negative on error
1005 */
1006int wc_se050_rsa_insert_private_key(word32 keyId, const byte* rsaDer,
1007                                    word32 rsaDerSize)
1008{
1009    return se050_rsa_insert_key(keyId, rsaDer, rsaDerSize, RSA_PRIVATE);
1010}
1011
1012/**
1013 * Insert DER encoded RSA public key into SE050 as a persistent key.
1014 *
1015 * keyId       SE050 key ID to store key into
1016 * rsaDer      DER encoded RSA public key
1017 * rsaDerSize  size of DER buffer, bytes
1018 *
1019 * Returns 0 on success, negative on error
1020 */
1021int wc_se050_rsa_insert_public_key(word32 keyId, const byte* rsaDer,
1022                                   word32 rsaDerSize)
1023{
1024    return se050_rsa_insert_key(keyId, rsaDer, rsaDerSize, RSA_PUBLIC);
1025}
1026
1027/**
1028 * Free an RSA key object from the SE050. Erases key from persistent storage
1029 * if it was allocated by wolfSSL (not pre-provisioned).
1030 *
1031 * key  Pointer to initialized RsaKey structure
1032 */
1033void se050_rsa_free_key(struct RsaKey* key)
1034{
1035    sss_status_t    status = kStatus_SSS_Success;
1036    sss_object_t    keyObject;
1037    sss_key_store_t host_keystore;
1038
1039#ifdef SE050_DEBUG
1040    printf("se050_rsa_free_key: key %p, keyId %d\n", key, key->keyId);
1041#endif
1042
1043    if (cfg_se050_i2c_pi == NULL) {
1044        return;
1045    }
1046    if (key->keyIdSet == 0) {
1047        return;
1048    }
1049
1050    if (wolfSSL_CryptHwMutexLock() != 0) {
1051        return;
1052    }
1053
1054    status = sss_key_store_context_init(&host_keystore, cfg_se050_i2c_pi);
1055    if (status == kStatus_SSS_Success) {
1056        status = sss_key_store_allocate(&host_keystore, SE050_KEYSTOREID_RSA);
1057    }
1058    if (status == kStatus_SSS_Success) {
1059        status = sss_key_object_init(&keyObject, &host_keystore);
1060    }
1061    if (status == kStatus_SSS_Success) {
1062        status = sss_key_object_get_handle(&keyObject, key->keyId);
1063    }
1064
1065    if (status == kStatus_SSS_Success) {
1066        /* Erase key from SE050 persistent storage if it was allocated
1067         * by wolfSSL (not a pre-provisioned key). Without this, persistent
1068         * key objects leak on the SE050 and can exhaust secure storage. */
1069        if (key->keyId >= SE050_KEYID_START) {
1070            sss_key_store_erase_key(&host_keystore, &keyObject);
1071        }
1072        sss_key_object_free(&keyObject);
1073        key->keyId = 0;
1074        key->keyIdSet = 0;
1075    }
1076    wolfSSL_CryptHwMutexUnLock();
1077}
1078
1079/**
1080 * Get SSS algorithm type for RSA signature operations.
1081 *
1082 * padType  padding type
1083 * hash     hash function
1084 * mgf      mask generation function (for PSS)
1085 *
1086 * Returns algorithm type or kAlgorithm_None if none supported found
1087 */
1088static sss_algorithm_t se050_get_rsa_signature_type(int padType,
1089        enum wc_HashType hash, int mgf)
1090{
1091    sss_algorithm_t alg = kAlgorithm_None;
1092
1093    switch (padType) {
1094        case WC_RSA_PKCSV15_PAD:
1095            if (hash == WC_HASH_TYPE_NONE) {
1096                alg = kAlgorithm_SSS_RSASSA_PKCS1_V1_5_NO_HASH;
1097            } else if (hash == WC_HASH_TYPE_SHA) {
1098                alg = kAlgorithm_SSS_RSASSA_PKCS1_V1_5_SHA1;
1099            } else if (hash == WC_HASH_TYPE_SHA224) {
1100                alg = kAlgorithm_SSS_RSASSA_PKCS1_V1_5_SHA224;
1101            } else if (hash == WC_HASH_TYPE_SHA256) {
1102                alg = kAlgorithm_SSS_RSASSA_PKCS1_V1_5_SHA256;
1103            } else if (hash == WC_HASH_TYPE_SHA384) {
1104                alg = kAlgorithm_SSS_RSASSA_PKCS1_V1_5_SHA384;
1105            } else if (hash == WC_HASH_TYPE_SHA512) {
1106                alg = kAlgorithm_SSS_RSASSA_PKCS1_V1_5_SHA512;
1107            }
1108            break;
1109        case WC_RSA_OAEP_PAD:
1110            if (hash == WC_HASH_TYPE_SHA) {
1111                alg = kAlgorithm_SSS_RSAES_PKCS1_OAEP_SHA1;
1112            } else if (hash == WC_HASH_TYPE_SHA224) {
1113                alg = kAlgorithm_SSS_RSAES_PKCS1_OAEP_SHA224;
1114            } else if (hash == WC_HASH_TYPE_SHA256) {
1115                alg = kAlgorithm_SSS_RSAES_PKCS1_OAEP_SHA256;
1116            } else if (hash == WC_HASH_TYPE_SHA384) {
1117                alg = kAlgorithm_SSS_RSAES_PKCS1_OAEP_SHA384;
1118            } else if (hash == WC_HASH_TYPE_SHA512) {
1119                alg = kAlgorithm_SSS_RSAES_PKCS1_OAEP_SHA512;
1120            }
1121            break;
1122        case WC_RSA_PSS_PAD:
1123            if (mgf == WC_MGF1SHA1) {
1124                alg = kAlgorithm_SSS_RSASSA_PKCS1_PSS_MGF1_SHA1;
1125            } else if (mgf == WC_MGF1SHA224) {
1126                alg = kAlgorithm_SSS_RSASSA_PKCS1_PSS_MGF1_SHA224;
1127            } else if (mgf == WC_MGF1SHA256) {
1128                alg = kAlgorithm_SSS_RSASSA_PKCS1_PSS_MGF1_SHA256;
1129            } else if (mgf == WC_MGF1SHA384) {
1130                alg = kAlgorithm_SSS_RSASSA_PKCS1_PSS_MGF1_SHA384;
1131            } else if (mgf == WC_MGF1SHA512) {
1132                alg = kAlgorithm_SSS_RSASSA_PKCS1_PSS_MGF1_SHA512;
1133            }
1134            break;
1135        case WC_RSA_NO_PAD:
1136            alg = kAlgorithm_SSS_RSASSA_NO_PADDING;
1137            break;
1138        default:
1139            break;
1140    }
1141
1142    return alg;
1143}
1144
1145static sss_algorithm_t se050_get_rsa_encrypt_type(int padType,
1146        enum wc_HashType hash)
1147{
1148    sss_algorithm_t alg = kAlgorithm_None;
1149    (void)hash;
1150
1151    switch (padType) {
1152        case WC_RSA_PKCSV15_PAD:
1153            alg = kAlgorithm_SSS_RSAES_PKCS1_V1_5;
1154            break;
1155        case WC_RSA_OAEP_PAD:
1156            /* lower level Se05x API translation maps OAEP-SHA1 alg type to
1157             * kSE05x_RSAEncryptionAlgo_PKCS1_OAEP (generic) */
1158            alg = kAlgorithm_SSS_RSAES_PKCS1_OAEP_SHA1;
1159            break;
1160        case WC_RSA_NO_PAD:
1161            alg = kAlgorithm_SSS_RSASSA_NO_PADDING;
1162            break;
1163        default:
1164            break;
1165    }
1166
1167    return alg;
1168}
1169
1170/**
1171 * RSA sign operation.
1172 *
1173 * in        input data to be signed
1174 * inLen     length of input data, bytes
1175 * out       output buffer containing signature
1176 * outLen    length of output buffer, bytes
1177 * key       pointer to initialized/populated RsaKey structure
1178 * rsa_type  type of RSA: must be RSA_PRIVATE_ENCRYPT
1179 * pad_value should be RSA_BLOCK_TYPE_1 for signing
1180 * pad_type  type of padding: WC_RSA_PKCSV15_PAD, WC_RSA_OAEP_PAD,
1181 *           WC_RSA_NO_PAD, WC_RSA_PSS_PAD
1182 * hash      type of hash algorithm, found in wolfssl/wolfcrypt/hash.h
1183 * mgf       type of mask generation function to use
1184 * label     optional label, not supported by SE050, must be NULL
1185 * labelSz   size of label, not supported by SE050, must be 0
1186 * keySz     size of RSA key, bytes
1187 *
1188 * Return size of signature on success, negative on error.
1189 */
1190int se050_rsa_sign(const byte* in, word32 inLen, byte* out,
1191                   word32 outLen, struct RsaKey* key, int rsa_type,
1192                   byte pad_value, int pad_type, enum wc_HashType hash,
1193                   int mgf, byte* label, word32 labelSz, int keySz)
1194{
1195    int ret = 0;
1196    int keyCreated = 0;
1197    word32 keyId;
1198    size_t sigSz;
1199    sss_object_t     newKey;
1200    sss_status_t     status;
1201    sss_key_store_t  host_keystore;
1202    sss_algorithm_t  algorithm = kAlgorithm_None;
1203    sss_asymmetric_t ctx_asymm;
1204    byte* derBuf = NULL;
1205    int derSz = 0;
1206
1207    /* SE050 does not support optional label */
1208    (void)label;
1209    (void)labelSz;
1210
1211#ifdef SE050_DEBUG
1212    printf("se050_rsa_sign: key %p, in %p (%d), out %p (%d), "
1213            "key %p, type %d, pad_value = %d, pad_type = %d, mgf = %d\n",
1214            key, in, inLen, out, outLen, key, rsa_type, pad_value,
1215            pad_type, mgf);
1216#endif
1217
1218    if (in == NULL || out == NULL || key == NULL ||
1219        rsa_type != RSA_PRIVATE_ENCRYPT || pad_value != RSA_BLOCK_TYPE_1) {
1220        return BAD_FUNC_ARG;
1221    }
1222
1223    if (cfg_se050_i2c_pi == NULL) {
1224        return WC_HW_E;
1225    }
1226
1227    if (wolfSSL_CryptHwMutexLock() != 0) {
1228        return BAD_MUTEX_E;
1229    }
1230
1231    algorithm = se050_get_rsa_signature_type(pad_type, hash, mgf);
1232    if (algorithm == kAlgorithm_None) {
1233        WOLFSSL_MSG("Unsupported padding/hash/mgf combination for SE050");
1234        wolfSSL_CryptHwMutexUnLock();
1235        return BAD_FUNC_ARG;
1236    }
1237#ifdef SE050_DEBUG
1238    printf("se050_rsa_sign: algorithm = %d, keySz = %d, keyIdSet = %d\n",
1239            algorithm, keySz, key->keyIdSet);
1240#endif
1241
1242    status = sss_key_store_context_init(&host_keystore, cfg_se050_i2c_pi);
1243#ifdef SE050_DEBUG
1244    printf("se050_rsa_sign: sss_key_store_context_init status = %d\n", status);
1245#endif
1246    if (status == kStatus_SSS_Success) {
1247        status = sss_key_store_allocate(&host_keystore, SE050_KEYSTOREID_RSA);
1248#ifdef SE050_DEBUG
1249        printf("se050_rsa_sign: sss_key_store_allocate status = %d\n", status);
1250#endif
1251    }
1252    if (status == kStatus_SSS_Success) {
1253        status = sss_key_object_init(&newKey, &host_keystore);
1254#ifdef SE050_DEBUG
1255        printf("se050_rsa_sign: sss_key_object_init status = %d\n", status);
1256#endif
1257    }
1258    if (status == kStatus_SSS_Success) {
1259        keyId = key->keyId;
1260        if (key->keyIdSet == 0) {
1261            /* key was not generated in SE050, export RsaKey to DER
1262             * and use that to store into SE050 keystore */
1263            derSz = wc_RsaKeyToDer(key, NULL, 0);
1264#ifdef SE050_DEBUG
1265            printf("se050_rsa_sign: wc_RsaKeyToDer size query = %d\n", derSz);
1266#endif
1267            if (derSz < 0) {
1268                status = kStatus_SSS_Fail;
1269                ret = derSz;
1270            }
1271            else {
1272                derBuf = (byte*)XMALLOC(derSz, key->heap,
1273                                        DYNAMIC_TYPE_TMP_BUFFER);
1274                if (derBuf == NULL) {
1275                    WOLFSSL_MSG("malloc failed when converting RsaKey to DER");
1276                    status = kStatus_SSS_Fail;
1277                    ret = MEMORY_E;
1278                }
1279            }
1280            if (status == kStatus_SSS_Success) {
1281                derSz = wc_RsaKeyToDer(key, derBuf, derSz);
1282#ifdef SE050_DEBUG
1283                printf("se050_rsa_sign: wc_RsaKeyToDer export = %d\n", derSz);
1284#endif
1285                if (derSz < 0) {
1286                    status = kStatus_SSS_Fail;
1287                    ret = derSz;
1288                }
1289            }
1290            if (status == kStatus_SSS_Success) {
1291                keyId = se050_allocate_key(SE050_RSA_KEY);
1292                status = sss_key_object_allocate_handle(&newKey, keyId,
1293                    kSSS_KeyPart_Pair, kSSS_CipherType_RSA, keySz,
1294                    kKeyObject_Mode_Persistent);
1295#ifdef SE050_DEBUG
1296                printf("se050_rsa_sign: sss_key_object_allocate_handle "
1297                        "status = %d, keyId = %d\n", status, keyId);
1298#endif
1299            }
1300            if (status == kStatus_SSS_Success) {
1301                /* Try to delete existing key first, ignore return since will
1302                 * fail if no key exists yet */
1303                status = sss_key_store_erase_key(&host_keystore, &newKey);
1304#ifdef SE050_DEBUG
1305                printf("se050_rsa_sign: sss_key_store_erase_key "
1306                        "status = %d\n", status);
1307#endif
1308                /* Reset status - erase failing is expected if key doesn't
1309                 * exist yet */
1310                status = kStatus_SSS_Success;
1311
1312                keyCreated = 1;
1313                status = sss_key_store_set_key(&host_keystore, &newKey, derBuf,
1314                                               derSz, (keySz * 8), NULL, 0);
1315#ifdef SE050_DEBUG
1316                printf("se050_rsa_sign: sss_key_store_set_key "
1317                        "status = %d, derSz = %d, keyBits = %d\n",
1318                        status, derSz, (keySz * 8));
1319#endif
1320            }
1321
1322            XFREE(derBuf, key->heap, DYNAMIC_TYPE_TMP_BUFFER);
1323        }
1324        else {
1325            status = sss_key_object_get_handle(&newKey, keyId);
1326#ifdef SE050_DEBUG
1327            printf("se050_rsa_sign: sss_key_object_get_handle "
1328                    "status = %d, keyId = %d\n", status, keyId);
1329#endif
1330        }
1331    }
1332
1333    if (status == kStatus_SSS_Success) {
1334        status = sss_asymmetric_context_init(&ctx_asymm, cfg_se050_i2c_pi,
1335                                            &newKey, algorithm, kMode_SSS_Sign);
1336#ifdef SE050_DEBUG
1337        printf("se050_rsa_sign: sss_asymmetric_context_init "
1338                "status = %d, algorithm = %d\n", status, algorithm);
1339#endif
1340        if (status == kStatus_SSS_Success) {
1341            sigSz = outLen;
1342            status = sss_asymmetric_sign_digest(&ctx_asymm, (uint8_t*)in,
1343                                                inLen, out, &sigSz);
1344#ifdef SE050_DEBUG
1345            printf("se050_rsa_sign: sss_asymmetric_sign_digest "
1346                    "status = %d, inLen = %d, sigSz = %d\n",
1347                    status, inLen, (int)sigSz);
1348#endif
1349        }
1350        sss_asymmetric_context_free(&ctx_asymm);
1351    }
1352
1353    if (status == kStatus_SSS_Success) {
1354        key->keyId = keyId;
1355        key->keyIdSet = 1;
1356        ret = sigSz;
1357    }
1358    else {
1359        if (keyCreated) {
1360            sss_key_store_erase_key(&host_keystore, &newKey);
1361            sss_key_object_free(&newKey);
1362        }
1363        if (ret == 0) {
1364            ret = WC_HW_E;
1365        }
1366    }
1367
1368    wolfSSL_CryptHwMutexUnLock();
1369
1370#ifdef SE050_DEBUG
1371    printf("se050_rsa_sign: ret %d, outLen %d\n", ret, outLen);
1372#endif
1373
1374    return ret;
1375}
1376
1377/**
1378 * RSA verify operation.
1379 *
1380 * in        input signature to be verified
1381 * inLen     length of sig, bytes
1382 * out       output buffer containing decoded data
1383 * outLen    length of output buffer, bytes
1384 * key       pointer to initialized/populated RsaKey structure
1385 * rsa_type  type of RSA: must be RSA_PUBLIC_DECRYPT
1386 * pad_value should be RSA_BLOCK_TYPE_1 for sign/verify
1387 * pad_type  type of padding: WC_RSA_PKCSV15_PAD, WC_RSA_OAEP_PAD,
1388 *           WC_RSA_NO_PAD, WC_RSA_PSS_PAD
1389 * hash      type of hash algorithm, found in wolfssl/wolfcrypt/hash.h
1390 * mgf       type of mask generation function to use
1391 * label     optional label, not supported by SE050, must be NULL
1392 * labelSz   size of label, not supported by SE050, must be 0
1393 *
1394 * Returns size of decoded data on success, negative on error.
1395 */
1396int se050_rsa_verify(const byte* in, word32 inLen, byte* out, word32 outLen,
1397                     struct RsaKey* key, int rsa_type, byte pad_value,
1398                     int pad_type, enum wc_HashType hash, int mgf, byte* label,
1399                     word32 labelSz)
1400{
1401    int ret = 0;
1402    word32 keyId;
1403    int keySz;
1404    int keyCreated = 0;
1405    size_t decLen  = 0;
1406    sss_status_t     status;
1407    sss_object_t     newKey;
1408    sss_key_store_t  host_keystore;
1409    sss_asymmetric_t ctx_asymm = {0};
1410    sss_se05x_asymmetric_t* se050_ctx_asymm = NULL;
1411    sss_algorithm_t  algorithm = kAlgorithm_None;
1412    smStatus_t       smStatus = SM_NOT_OK;
1413    byte* pad    = NULL;
1414    byte* derBuf = NULL;
1415    int derSz = 0;
1416
1417#ifdef SE050_DEBUG
1418    printf("se050_rsa_pkcs1v15_verify: key %p, in %p (%d), out %p (%d)\n",
1419            key, in, inLen, out, outLen);
1420#endif
1421
1422    if (in == NULL || out == NULL || key == NULL ||
1423        rsa_type != RSA_PUBLIC_DECRYPT || pad_value != RSA_BLOCK_TYPE_1) {
1424        return BAD_FUNC_ARG;
1425    }
1426
1427    if (cfg_se050_i2c_pi == NULL) {
1428        return WC_HW_E;
1429    }
1430
1431    if (wolfSSL_CryptHwMutexLock() != 0) {
1432        return BAD_MUTEX_E;
1433    }
1434
1435    algorithm = se050_get_rsa_signature_type(pad_type, hash, mgf);
1436    if (algorithm == kAlgorithm_None) {
1437        WOLFSSL_MSG("Unsupported padding/hash/mgf combination for SE050");
1438        wolfSSL_CryptHwMutexUnLock();
1439        return BAD_FUNC_ARG;
1440    }
1441
1442    status = sss_key_store_context_init(&host_keystore, cfg_se050_i2c_pi);
1443    if (status == kStatus_SSS_Success) {
1444        status = sss_key_store_allocate(&host_keystore, SE050_KEYSTOREID_RSA);
1445    }
1446    if (status == kStatus_SSS_Success) {
1447        status = sss_key_object_init(&newKey, &host_keystore);
1448    }
1449    if (status == kStatus_SSS_Success) {
1450        keySz = wc_RsaEncryptSize(key);
1451        if (keySz < 0) {
1452            WOLFSSL_MSG("Failed to get RSA key size from struct");
1453            status = kStatus_SSS_Fail;
1454        }
1455    }
1456    if (status == kStatus_SSS_Success) {
1457        keyId = key->keyId;
1458        if (key->keyIdSet == 0) {
1459            /* key was not generated in SE050, export RsaKey to DER
1460             * and use that to store into SE050 keystore */
1461            derSz = wc_RsaKeyToPublicDer(key, NULL, 0);
1462            if (derSz < 0) {
1463                status = kStatus_SSS_Fail;
1464                ret = derSz;
1465            }
1466            else {
1467                derBuf = (byte*)XMALLOC(derSz, key->heap,
1468                                        DYNAMIC_TYPE_TMP_BUFFER);
1469                if (derBuf == NULL) {
1470                    WOLFSSL_MSG("malloc failed when converting RsaKey to DER");
1471                    status = kStatus_SSS_Fail;
1472                    ret = MEMORY_E;
1473                }
1474            }
1475            if (status == kStatus_SSS_Success) {
1476                derSz = wc_RsaKeyToPublicDer(key, derBuf, derSz);
1477                if (derSz < 0) {
1478                    status = kStatus_SSS_Fail;
1479                    ret = derSz;
1480                }
1481            }
1482            if (status == kStatus_SSS_Success) {
1483                keyId = se050_allocate_key(SE050_RSA_KEY);
1484                status = sss_key_object_allocate_handle(&newKey, keyId,
1485                    kSSS_KeyPart_Public, kSSS_CipherType_RSA, keySz,
1486                    kKeyObject_Mode_Transient);
1487            }
1488            if (status == kStatus_SSS_Success) {
1489                /* Try to delete existing key first, ignore return since will
1490                 * fail if no key exists yet */
1491                sss_key_store_erase_key(&host_keystore, &newKey);
1492
1493                keyCreated = 1;
1494                status = sss_key_store_set_key(&host_keystore, &newKey, derBuf,
1495                                               derSz, (keySz * 8), NULL, 0);
1496            }
1497
1498            XFREE(derBuf, key->heap, DYNAMIC_TYPE_TMP_BUFFER);
1499        }
1500        else {
1501            status = sss_key_object_get_handle(&newKey, keyId);
1502        }
1503    }
1504
1505    if (status == kStatus_SSS_Success) {
1506        status = sss_asymmetric_context_init(&ctx_asymm, cfg_se050_i2c_pi,
1507                                    &newKey, algorithm, kMode_SSS_Verify);
1508        if (status == kStatus_SSS_Success) {
1509            /* Use lower Se05x API instead of sss_asymmetric_verify_digest()
1510             * since we need to return decoded data not just verify result */
1511            decLen = outLen;
1512            se050_ctx_asymm = (sss_se05x_asymmetric_t*)&ctx_asymm;
1513            smStatus = Se05x_API_RSAEncrypt(&se050_ctx_asymm->session->s_ctx,
1514                                            se050_ctx_asymm->keyObject->keyId,
1515                                            kSE05x_RSAEncryptionAlgo_NO_PAD,
1516                                            in, inLen, out, &decLen);
1517            if (smStatus == SM_OK) {
1518                /* find end of padding, pad points to start of actual data */
1519                ret = wc_RsaUnPad_ex(out, decLen, &pad, pad_value,
1520                        pad_type, hash, mgf,
1521                        label, labelSz, RSA_PSS_SALT_LEN_DEFAULT, (keySz * 8),
1522                        key->heap);
1523                if (ret >= 0) {
1524                    XMEMCPY(out, pad, ret);
1525                }
1526                else {
1527                    WOLFSSL_MSG("Error in wc_RsaUnPad_ex for RSA verify");
1528                    status = kStatus_SSS_Fail;
1529                }
1530            }
1531            else {
1532                WOLFSSL_MSG("Se05x_API_RSAEncrypt failed");
1533                status = kStatus_SSS_Fail;
1534            }
1535        }
1536
1537        sss_asymmetric_context_free(&ctx_asymm);
1538    }
1539
1540    if (status == kStatus_SSS_Success) {
1541        if (keyCreated) {
1542            /* We uploaded only the public part of the key for this verify.
1543             * Don't persist keyIdSet=1 -- a later sign on the same RsaKey
1544             * would reuse this binding and fail because the SE050 object has
1545             * no private material. Erase the transient object so the next
1546             * SE050 op (sign or verify) re-uploads from whatever the host
1547             * RsaKey currently holds. */
1548            sss_key_store_erase_key(&host_keystore, &newKey);
1549            sss_key_object_free(&newKey);
1550        }
1551        else {
1552            /* Pre-existing keyIdSet=1 binding (e.g. wc_RsaUseKeyId or prior
1553             * sign that uploaded a keypair). Preserve it. */
1554            key->keyId = keyId;
1555            key->keyIdSet = 1;
1556        }
1557    }
1558    else {
1559        if (keyCreated) {
1560            sss_key_store_erase_key(&host_keystore, &newKey);
1561            sss_key_object_free(&newKey);
1562        }
1563        if (ret == 0) {
1564            ret = WC_HW_E;
1565        }
1566    }
1567
1568    wolfSSL_CryptHwMutexUnLock();
1569
1570#ifdef SE050_DEBUG
1571    printf("se050_rsa_verify: key %p, ret %d\n", key, ret);
1572#endif
1573
1574    return ret;
1575}
1576
1577/**
1578 * RSA public encrypt operation.
1579 *
1580 * in        input data to be encrypted
1581 * inLen     length of input data, bytes
1582 * out       output buffer containing encrypted data
1583 * outLen    length of output buffer, bytes
1584 * key       pointer to initialized/populated RsaKey structure
1585 * rsa_type  type of RSA: must be RSA_PUBLIC_ENCRYPT
1586 * pad_value should be RSA_BLOCK_TYPE_2 for encrypting
1587 * pad_type  type of padding: WC_RSA_PKCSV15_PAD, WC_RSA_OAEP_PAD,
1588 *           WC_RSA_NO_PAD, WC_RSA_PSS_PAD
1589 * hash      type of hash algorithm, found in wolfssl/wolfcrypt/hash.h
1590 * mgf       type of mask generation function to use
1591 * label     optional label, not supported by SE050, must be NULL
1592 * labelSz   size of label, not supported by SE050, must be 0
1593 * keySz     size of RSA key, bytes
1594 *
1595 * Returns size of encrypted data on success, negative on error.
1596 */
1597int se050_rsa_public_encrypt(const byte* in, word32 inLen, byte* out,
1598                             word32 outLen, struct RsaKey* key, int rsa_type,
1599                             byte pad_value, int pad_type,
1600                             enum wc_HashType hash, int mgf, byte* label,
1601                             word32 labelSz, int keySz)
1602{
1603    int ret = 0;
1604    int keyCreated = 0;
1605    word32 keyId;
1606    size_t encSz;
1607    sss_object_t     newKey;
1608    sss_status_t     status;
1609    sss_key_store_t  host_keystore;
1610    sss_algorithm_t  algorithm = kAlgorithm_None;
1611    sss_asymmetric_t ctx_asymm;
1612    byte* derBuf = NULL;
1613    int derSz = 0;
1614
1615    /* SE050 does not support optional label */
1616    (void)label;
1617    (void)labelSz;
1618    (void)mgf;
1619
1620#ifdef SE050_DEBUG
1621    printf("se050_rsa_public_encrypt: key %p, in %p (%d), out %p (%d), "
1622            "key %p\n", key, in, inLen, out, outLen, key);
1623#endif
1624
1625    if (in == NULL || out == NULL || key == NULL ||
1626        rsa_type != RSA_PUBLIC_ENCRYPT || pad_value != RSA_BLOCK_TYPE_2) {
1627        return BAD_FUNC_ARG;
1628    }
1629
1630    if (cfg_se050_i2c_pi == NULL) {
1631        return WC_HW_E;
1632    }
1633
1634    if (wolfSSL_CryptHwMutexLock() != 0) {
1635        return BAD_MUTEX_E;
1636    }
1637
1638    algorithm = se050_get_rsa_encrypt_type(pad_type, hash);
1639    if (algorithm == kAlgorithm_None) {
1640        WOLFSSL_MSG("Unsupported padding/hash/mgf combination for SE050");
1641        wolfSSL_CryptHwMutexUnLock();
1642        return BAD_FUNC_ARG;
1643    }
1644
1645    status = sss_key_store_context_init(&host_keystore, cfg_se050_i2c_pi);
1646    if (status == kStatus_SSS_Success) {
1647        status = sss_key_store_allocate(&host_keystore, SE050_KEYSTOREID_RSA);
1648    }
1649    if (status == kStatus_SSS_Success) {
1650        status = sss_key_object_init(&newKey, &host_keystore);
1651    }
1652    if (status == kStatus_SSS_Success) {
1653        keyId = key->keyId;
1654        if (key->keyIdSet == 0) {
1655            /* key was not generated in SE050, export RsaKey to DER
1656             * and use that to store into SE050 keystore */
1657            derSz = wc_RsaKeyToPublicDer(key, NULL, 0);
1658            if (derSz < 0) {
1659                status = kStatus_SSS_Fail;
1660                ret = derSz;
1661            }
1662            else {
1663                derBuf = (byte*)XMALLOC(derSz, key->heap,
1664                                        DYNAMIC_TYPE_TMP_BUFFER);
1665                if (derBuf == NULL) {
1666                    WOLFSSL_MSG("malloc failed when converting RsaKey to DER");
1667                    status = kStatus_SSS_Fail;
1668                    ret = MEMORY_E;
1669                }
1670            }
1671            if (status == kStatus_SSS_Success) {
1672                derSz = wc_RsaKeyToPublicDer(key, derBuf, derSz);
1673                if (derSz < 0) {
1674                    status = kStatus_SSS_Fail;
1675                    ret = derSz;
1676                }
1677            }
1678            if (status == kStatus_SSS_Success) {
1679                keyId = se050_allocate_key(SE050_RSA_KEY);
1680                status = sss_key_object_allocate_handle(&newKey, keyId,
1681                    kSSS_KeyPart_Public, kSSS_CipherType_RSA, keySz,
1682                    kKeyObject_Mode_Persistent);
1683            }
1684            if (status == kStatus_SSS_Success) {
1685                /* Try to delete existing key first, ignore return since will
1686                 * fail if no key exists yet */
1687                sss_key_store_erase_key(&host_keystore, &newKey);
1688
1689                keyCreated = 1;
1690                status = sss_key_store_set_key(&host_keystore, &newKey, derBuf,
1691                                               derSz, (keySz * 8), NULL, 0);
1692            }
1693        }
1694        else {
1695            status = sss_key_object_get_handle(&newKey, keyId);
1696        }
1697
1698        XFREE(derBuf, key->heap, DYNAMIC_TYPE_TMP_BUFFER);
1699    }
1700
1701    if (status == kStatus_SSS_Success) {
1702        status = sss_asymmetric_context_init(&ctx_asymm, cfg_se050_i2c_pi,
1703                    &newKey, algorithm, kMode_SSS_Encrypt);
1704        if (status == kStatus_SSS_Success) {
1705            encSz = outLen;
1706            status = sss_asymmetric_encrypt(&ctx_asymm, (uint8_t*)in, inLen,
1707                                            out, &encSz);
1708        }
1709        sss_asymmetric_context_free(&ctx_asymm);
1710    }
1711
1712    if (status == kStatus_SSS_Success) {
1713        if (keyCreated) {
1714            /* Public-key encrypt imported a temporary public object only.
1715             * Do not bind that SE050 object to the caller's RsaKey or later
1716             * private-key operations will try to reuse a public handle. */
1717            sss_key_store_erase_key(&host_keystore, &newKey);
1718            sss_key_object_free(&newKey);
1719        }
1720        else {
1721            key->keyId = keyId;
1722            key->keyIdSet = 1;
1723        }
1724        ret = encSz;
1725    }
1726    else {
1727        if (keyCreated) {
1728            sss_key_store_erase_key(&host_keystore, &newKey);
1729            sss_key_object_free(&newKey);
1730        }
1731        if (ret == 0) {
1732            ret = WC_HW_E;
1733        }
1734    }
1735
1736    wolfSSL_CryptHwMutexUnLock();
1737
1738#ifdef SE050_DEBUG
1739    printf("se050_rsa_public_encrypt: ret %d, outLen %d\n", ret, outLen);
1740#endif
1741
1742    return ret;
1743}
1744
1745/**
1746 * RSA public decrypt operation.
1747 *
1748 * in        input data to be decrypted
1749 * inLen     length of input data, bytes
1750 * out       output buffer containing decrypted data
1751 * outLen    length of output buffer, bytes
1752 * key       pointer to initialized/populated RsaKey structure
1753 * rsa_type  type of RSA: must be RSA_PRIVATE_DECRYPT
1754 * pad_value should be RSA_BLOCK_TYPE_2 for encrypting
1755 * pad_type  type of padding: WC_RSA_PKCSV15_PAD, WC_RSA_OAEP_PAD,
1756 *           WC_RSA_NO_PAD, WC_RSA_PSS_PAD
1757 * hash      type of hash algorithm, found in wolfssl/wolfcrypt/hash.h
1758 * mgf       type of mask generation function to use
1759 * label     optional label, not supported by SE050, must be NULL
1760 * labelSz   size of label, not supported by SE050, must be 0
1761 *
1762 * Returns size of decrypted data on success, negative on error.
1763 */
1764int se050_rsa_private_decrypt(const byte* in, word32 inLen, byte* out,
1765                             word32 outLen, struct RsaKey* key, int rsa_type,
1766                             byte pad_value, int pad_type,
1767                             enum wc_HashType hash, int mgf, byte* label,
1768                             word32 labelSz)
1769{
1770    int ret = 0;
1771    int keyCreated = 0;
1772    word32 keyId;
1773    int keySz;
1774    size_t decSz;
1775    sss_object_t     newKey;
1776    sss_status_t     status;
1777    sss_key_store_t  host_keystore;
1778    sss_algorithm_t  algorithm = kAlgorithm_None;
1779    sss_asymmetric_t ctx_asymm;
1780    byte* derBuf = NULL;
1781    int derSz = 0;
1782
1783    /* SE050 does not support optional label */
1784    (void)label;
1785    (void)labelSz;
1786    (void)mgf;
1787
1788#ifdef SE050_DEBUG
1789    printf("se050_rsa_public_decrypt: key %p, in %p (%d), out %p (%d), "
1790            "key %p\n", key, in, inLen, out, outLen, key);
1791#endif
1792
1793    if (in == NULL || out == NULL || key == NULL ||
1794        rsa_type != RSA_PRIVATE_DECRYPT || pad_value != RSA_BLOCK_TYPE_2) {
1795        return BAD_FUNC_ARG;
1796    }
1797
1798    if (cfg_se050_i2c_pi == NULL) {
1799        return WC_HW_E;
1800    }
1801
1802    if (wolfSSL_CryptHwMutexLock() != 0) {
1803        return BAD_MUTEX_E;
1804    }
1805
1806    algorithm = se050_get_rsa_encrypt_type(pad_type, hash);
1807    if (algorithm == kAlgorithm_None) {
1808        WOLFSSL_MSG("Unsupported padding/hash/mgf combination for SE050");
1809        wolfSSL_CryptHwMutexUnLock();
1810        return BAD_FUNC_ARG;
1811    }
1812
1813    status = sss_key_store_context_init(&host_keystore, cfg_se050_i2c_pi);
1814    if (status == kStatus_SSS_Success) {
1815        status = sss_key_store_allocate(&host_keystore, SE050_KEYSTOREID_RSA);
1816    }
1817    if (status == kStatus_SSS_Success) {
1818        status = sss_key_object_init(&newKey, &host_keystore);
1819    }
1820    if (status == kStatus_SSS_Success) {
1821        keySz = wc_RsaEncryptSize(key);
1822        if (keySz < 0) {
1823            WOLFSSL_MSG("Failed to get RSA key size from struct");
1824            status = kStatus_SSS_Fail;
1825        }
1826    }
1827    if (status == kStatus_SSS_Success) {
1828        keyId = key->keyId;
1829        if (key->keyIdSet == 0) {
1830            /* key was not generated in SE050, export RsaKey to DER
1831             * and use that to store into SE050 keystore */
1832            derSz = wc_RsaKeyToDer(key, NULL, 0);
1833            if (derSz < 0) {
1834                status = kStatus_SSS_Fail;
1835                ret = derSz;
1836            }
1837            else {
1838                derBuf = (byte*)XMALLOC(derSz, key->heap,
1839                                        DYNAMIC_TYPE_TMP_BUFFER);
1840                if (derBuf == NULL) {
1841                    WOLFSSL_MSG("malloc failed when converting RsaKey to DER");
1842                    status = kStatus_SSS_Fail;
1843                    ret = MEMORY_E;
1844                }
1845            }
1846            if (status == kStatus_SSS_Success) {
1847                derSz = wc_RsaKeyToDer(key, derBuf, derSz);
1848                if (derSz < 0) {
1849                    status = kStatus_SSS_Fail;
1850                    ret = derSz;
1851                }
1852            }
1853            if (status == kStatus_SSS_Success) {
1854                keyId = se050_allocate_key(SE050_RSA_KEY);
1855                status = sss_key_object_allocate_handle(&newKey, keyId,
1856                    kSSS_KeyPart_Pair, kSSS_CipherType_RSA, keySz,
1857                    kKeyObject_Mode_Persistent);
1858            }
1859            if (status == kStatus_SSS_Success) {
1860                /* Try to delete existing key first, ignore return since will
1861                 * fail if no key exists yet */
1862                sss_key_store_erase_key(&host_keystore, &newKey);
1863
1864                keyCreated = 1;
1865                status = sss_key_store_set_key(&host_keystore, &newKey, derBuf,
1866                                               derSz, (keySz * 8), NULL, 0);
1867            }
1868        }
1869        else {
1870            status = sss_key_object_get_handle(&newKey, keyId);
1871        }
1872
1873        XFREE(derBuf, key->heap, DYNAMIC_TYPE_TMP_BUFFER);
1874    }
1875
1876    if (status == kStatus_SSS_Success) {
1877        status = sss_asymmetric_context_init(&ctx_asymm, cfg_se050_i2c_pi,
1878                    &newKey, algorithm, kMode_SSS_Decrypt);
1879        if (status == kStatus_SSS_Success) {
1880            decSz = outLen;
1881            status = sss_asymmetric_decrypt(&ctx_asymm, (uint8_t*)in, inLen,
1882                                            out, &decSz);
1883        }
1884        sss_asymmetric_context_free(&ctx_asymm);
1885    }
1886
1887    if (status == kStatus_SSS_Success) {
1888        key->keyId = keyId;
1889        key->keyIdSet = 1;
1890        ret = decSz;
1891    }
1892    else {
1893        if (keyCreated) {
1894            sss_key_store_erase_key(&host_keystore, &newKey);
1895            sss_key_object_free(&newKey);
1896        }
1897        if (ret == 0) {
1898            ret = WC_HW_E;
1899        }
1900    }
1901
1902    wolfSSL_CryptHwMutexUnLock();
1903
1904#ifdef SE050_DEBUG
1905    printf("se050_rsa_public_decrypt: ret %d, outLen %d\n", ret, outLen);
1906#endif
1907
1908    return ret;
1909}
1910
1911#endif /* NO_RSA */
1912
1913#ifdef HAVE_ECC
1914
1915static int se050_map_curve(int curve_id, int keySize,
1916    int* keySizeBits, sss_cipher_type_t* pcurve_type)
1917{
1918    int ret = 0;
1919    sss_cipher_type_t curve_type = kSSS_CipherType_NONE;
1920
1921    *keySizeBits = keySize * 8; /* set default */
1922    switch (curve_id) {
1923        case ECC_SECP160K1:
1924        case ECC_SECP192K1:
1925        case ECC_SECP224K1:
1926        case ECC_SECP256K1:
1927        #ifdef HAVE_ECC_KOBLITZ
1928            curve_type = kSSS_CipherType_EC_NIST_K;
1929        #else
1930            ret = ECC_CURVE_OID_E;
1931        #endif
1932            break;
1933        case ECC_BRAINPOOLP160R1:
1934        case ECC_BRAINPOOLP192R1:
1935        case ECC_BRAINPOOLP224R1:
1936        case ECC_BRAINPOOLP256R1:
1937        case ECC_BRAINPOOLP320R1:
1938        case ECC_BRAINPOOLP384R1:
1939        case ECC_BRAINPOOLP512R1:
1940        #ifdef HAVE_ECC_BRAINPOOL
1941            curve_type = kSSS_CipherType_EC_BRAINPOOL;
1942        #else
1943            ret = ECC_CURVE_OID_E;
1944        #endif
1945            break;
1946        case ECC_CURVE_DEF:
1947        case ECC_SECP160R1:
1948        case ECC_SECP192R1:
1949        case ECC_SECP224R1:
1950        case ECC_SECP256R1:
1951        case ECC_SECP384R1:
1952            curve_type = kSSS_CipherType_EC_NIST_P;
1953            break;
1954        case ECC_SECP521R1:
1955            curve_type = kSSS_CipherType_EC_NIST_P;
1956            *keySizeBits = 521;
1957            break;
1958        case ECC_PRIME239V1:
1959        case ECC_PRIME192V2:
1960        case ECC_PRIME192V3:
1961        default:
1962            ret = ECC_CURVE_OID_E;
1963            break;
1964    }
1965    if (pcurve_type)
1966        *pcurve_type = curve_type;
1967    return ret;
1968}
1969
1970static sss_algorithm_t se050_map_hash_alg(int hashLen)
1971{
1972    sss_algorithm_t algorithm = kAlgorithm_None;
1973    if (hashLen == 20) {
1974        algorithm = kAlgorithm_SSS_SHA1;
1975    } else if (hashLen == 28) {
1976        algorithm = kAlgorithm_SSS_SHA224;
1977    } else if (hashLen == 32) {
1978        algorithm = kAlgorithm_SSS_SHA256;
1979    } else if (hashLen == 48) {
1980        algorithm = kAlgorithm_SSS_SHA384;
1981    } else if (hashLen == 64 || hashLen == 66) {
1982        /* ECC P-521 can pass key size 66, use SHA-512 */
1983        algorithm = kAlgorithm_SSS_SHA512;
1984    }
1985    return algorithm;
1986}
1987
1988static int se050_ecc_insert_key(word32 keyId, const byte* eccDer,
1989                                word32 eccDerSize, int keyType)
1990{
1991    int               ret = 0;
1992    struct ecc_key    key;
1993    sss_object_t      newKey;
1994    sss_key_store_t   host_keystore;
1995    sss_status_t      status = kStatus_SSS_Success;
1996    int               keySizeBits = 0;
1997    int               keySize = 0;
1998    word32            idx = 0;
1999    sss_cipher_type_t curveType = kSSS_CipherType_NONE;
2000    sss_key_part_t    keyPart = kSSS_KeyPart_Pair;
2001
2002    if (wolfSSL_CryptHwMutexLock() != 0) {
2003        return BAD_MUTEX_E;
2004    }
2005
2006    /* Avoid key ID conflicts with temporary key storage */
2007    if (keyId >= SE050_KEYID_START) {
2008        wolfSSL_CryptHwMutexUnLock();
2009        return BAD_FUNC_ARG;
2010    }
2011
2012    ret = wc_ecc_init(&key);
2013    if (ret != 0) {
2014        status = kStatus_SSS_Fail;
2015    } else {
2016        if (keyType == ECC_PUBLICKEY) {
2017            keyPart = kSSS_KeyPart_Public;
2018            ret = wc_EccPublicKeyDecode(eccDer, &idx, &key, eccDerSize);
2019        }
2020        else if (keyType == ECC_PRIVATEKEY) {
2021            keyPart = kSSS_KeyPart_Pair;
2022            ret = wc_EccPrivateKeyDecode(eccDer, &idx, &key, eccDerSize);
2023        }
2024        else {
2025            ret = BAD_FUNC_ARG;
2026        }
2027
2028        if (ret != 0) {
2029            status = kStatus_SSS_Fail;
2030        }
2031    }
2032
2033    if (status == kStatus_SSS_Success) {
2034        keySize = key.dp->size;
2035        ret = se050_map_curve(key.dp->id, keySize, &keySizeBits, &curveType);
2036        if (ret != 0) {
2037            status = kStatus_SSS_Fail;
2038        }
2039    }
2040    if (status == kStatus_SSS_Success) {
2041        status = sss_key_store_context_init(&host_keystore, cfg_se050_i2c_pi);
2042    }
2043    if (status == kStatus_SSS_Success) {
2044        status = sss_key_object_init(&newKey, &host_keystore);
2045    }
2046    if (status == kStatus_SSS_Success) {
2047        status = sss_key_object_allocate_handle(&newKey, keyId,
2048            keyPart, curveType, MAX_ECC_BYTES,
2049            kKeyObject_Mode_Persistent);
2050    }
2051    if (status == kStatus_SSS_Success) {
2052        status = sss_key_store_set_key(&host_keystore, &newKey, eccDer,
2053                                       eccDerSize, keySizeBits,
2054                                       NULL, 0);
2055    }
2056    wolfSSL_CryptHwMutexUnLock();
2057
2058    wc_ecc_free(&key);
2059    if (status != kStatus_SSS_Success) {
2060        if (ret == 0)
2061            ret = WC_HW_E;
2062    }
2063
2064    return ret;
2065}
2066
2067/**
2068 * Insert ECC public key into SE050 at specified key ID.
2069 *
2070 * keyId       SE050 key ID to place public key into
2071 * eccDer      DER encoded ECC public key
2072 * eccDerSize  Size of eccDer, bytes
2073 *
2074 * Return 0 on success, negative on error.
2075 */
2076int wc_se050_ecc_insert_public_key(word32 keyId, const byte* eccDer,
2077                                   word32 eccDerSize)
2078{
2079    return se050_ecc_insert_key(keyId, eccDer, eccDerSize, ECC_PUBLICKEY);
2080}
2081
2082/**
2083 * Insert ECC private key into SE050 at specified key ID.
2084 *
2085 * keyId       SE050 key ID to place private key into
2086 * eccDer      DER encoded ECC private key
2087 * eccDerSize  Size of eccDer, bytes
2088 *
2089 * Return 0 on success, negative on error.
2090 */
2091int wc_se050_ecc_insert_private_key(word32 keyId, const byte* eccDer,
2092                                    word32 eccDerSize)
2093{
2094    return se050_ecc_insert_key(keyId, eccDer, eccDerSize, ECC_PRIVATEKEY);
2095}
2096
2097int se050_ecc_sign_hash_ex(const byte* in, word32 inLen, MATH_INT_T* r, MATH_INT_T* s,
2098                           byte* out, word32 *outLen, struct ecc_key* key)
2099{
2100    int                 ret = 0;
2101    sss_status_t        status;
2102    sss_asymmetric_t    ctx_asymm;
2103    sss_key_store_t     host_keystore;
2104    sss_object_t        newKey;
2105    sss_algorithm_t     algorithm;
2106    int                 keySize;
2107    int                 keySizeBits;
2108    int                 keyCreated = 0;
2109    word32              keyId;
2110    sss_cipher_type_t   curveType;
2111
2112    byte sigBuf[ECC_MAX_SIG_SIZE];
2113    size_t sigSz = sizeof(sigBuf);
2114    word32 rLen = 0;
2115    word32 sLen = 0;
2116#ifndef WC_ALLOW_ECC_ZERO_HASH
2117    byte hashIsZero = 0;
2118    word32 zIdx;
2119#endif
2120
2121#ifdef SE050_DEBUG
2122    printf("se050_ecc_sign_hash_ex: key %p, in %p (%d), out %p (%d), "
2123            "keyId %d\n", key, in, inLen, out, *outLen, key->keyId);
2124#endif
2125
2126    if (in == NULL || r == NULL || s == NULL || out == NULL ||
2127        outLen == NULL || key == NULL) {
2128        return BAD_FUNC_ARG;
2129    }
2130
2131#ifndef WC_ALLOW_ECC_ZERO_HASH
2132    /* SE050 hardware does not reject all-zero digests; mirror the
2133     * software path's check so behavior is consistent. */
2134    for (zIdx = 0; zIdx < inLen; zIdx++)
2135        hashIsZero |= in[zIdx];
2136    if (hashIsZero == 0)
2137        return ECC_BAD_ARG_E;
2138#endif
2139
2140    if (cfg_se050_i2c_pi == NULL) {
2141        return WC_HW_E;
2142    }
2143
2144    keySize = key->dp->size;
2145    ret = se050_map_curve(key->dp->id, keySize, &keySizeBits, &curveType);
2146    if (ret != 0) {
2147        return ret;
2148    }
2149
2150    /* truncate if digest is larger than key size */
2151    if (inLen > (word32)keySize) {
2152        inLen = (word32)keySize;
2153    }
2154
2155    /* For P-521, if inLen is 66, truncate down to 64 for SHA-512 */
2156    if ((keySize == 66) && (inLen == 66)) {
2157        inLen = 64;
2158    }
2159
2160    algorithm = se050_map_hash_alg(inLen);
2161    if (algorithm == kAlgorithm_None) {
2162        WOLFSSL_MSG("SE050 ECDSA sign only supports SHA-1/224/256/384/512 digest sizes");
2163        return BAD_LENGTH_E;
2164    }
2165
2166    if (wolfSSL_CryptHwMutexLock() != 0) {
2167        return BAD_MUTEX_E;
2168    }
2169
2170    status = sss_key_store_context_init(&host_keystore, cfg_se050_i2c_pi);
2171    if (status == kStatus_SSS_Success) {
2172        status = sss_key_store_allocate(&host_keystore, SE050_KEYSTOREID_ECC);
2173    }
2174    if (status == kStatus_SSS_Success) {
2175        status = sss_key_object_init(&newKey, &host_keystore);
2176    }
2177    /* this is run when a key was not generated and was instead passed in */
2178    if (status == kStatus_SSS_Success) {
2179        keyId = key->keyId;
2180        if (key->keyIdSet == 0) {
2181            byte derBuf[SE050_ECC_DER_MAX];
2182            word32 derSz;
2183
2184            ret = wc_EccKeyToDer(key, derBuf, (word32)sizeof(derBuf));
2185            if (ret >= 0) {
2186                derSz = ret;
2187                ret = 0;
2188            }
2189            else {
2190                status = kStatus_SSS_Fail;
2191            }
2192            if (status == kStatus_SSS_Success) {
2193                keyId = se050_allocate_key(SE050_ECC_KEY);
2194                status = sss_key_object_allocate_handle(&newKey, keyId,
2195                    kSSS_KeyPart_Pair, curveType, keySize,
2196                    kKeyObject_Mode_Persistent);
2197            }
2198            if (status == kStatus_SSS_Success) {
2199                /* Try to delete existing key first, ignore return since will
2200                 * fail if no key exists yet */
2201                sss_key_store_erase_key(&host_keystore, &newKey);
2202
2203                keyCreated = 1;
2204                status = sss_key_store_set_key(&host_keystore, &newKey, derBuf,
2205                                                derSz, keySizeBits, NULL, 0);
2206            }
2207        }
2208        else {
2209            status = sss_key_object_get_handle(&newKey, keyId);
2210        }
2211    }
2212
2213    if (status == kStatus_SSS_Success) {
2214
2215        status = sss_asymmetric_context_init(&ctx_asymm, cfg_se050_i2c_pi,
2216            &newKey, algorithm, kMode_SSS_Sign);
2217        if (status == kStatus_SSS_Success) {
2218
2219            status = sss_asymmetric_sign_digest(&ctx_asymm, (uint8_t*)in, inLen,
2220                sigBuf, &sigSz);
2221            if (status == kStatus_SSS_Success) {
2222
2223                /* SE050 returns ASN.1 encoded signature */
2224                rLen = keySize;
2225                sLen = keySize;
2226
2227                ret = DecodeECC_DSA_Sig_Bin(sigBuf, (word32)sigSz,
2228                    out,         &rLen,
2229                    out+keySize, &sLen);
2230
2231                if (ret != 0) {
2232                    status = kStatus_SSS_Fail;
2233                } else {
2234                    /* In case rLen is smaller than keySize, move S up */
2235                    XMEMCPY(out + rLen, out + keySize, sLen);
2236                }
2237            }
2238        }
2239        sss_asymmetric_context_free(&ctx_asymm);
2240    }
2241
2242    if (status == kStatus_SSS_Success) {
2243        /* Load R and S into mp_int */
2244        ret = mp_read_unsigned_bin(r, out, rLen);
2245        if (ret == MP_OKAY) {
2246            ret = mp_read_unsigned_bin(s, out + rLen, sLen);
2247        }
2248        if (ret != MP_OKAY) {
2249            status = kStatus_SSS_Fail;
2250        }
2251        ret = 0;
2252    }
2253
2254    if (status == kStatus_SSS_Success) {
2255        key->keyId = keyId;
2256        key->keyIdSet = 1;
2257        ret = 0;
2258    }
2259    else {
2260        if (keyCreated) {
2261            sss_key_store_erase_key(&host_keystore, &newKey);
2262            sss_key_object_free(&newKey);
2263        }
2264        if (ret == 0)
2265            ret = WC_HW_E;
2266    }
2267
2268    wolfSSL_CryptHwMutexUnLock();
2269
2270#ifdef SE050_DEBUG
2271    printf("se050_ecc_sign_hash_ex: ret %d, outLen %d\n", ret, *outLen);
2272#endif
2273
2274    (void)outLen; /* caller sets outLen */
2275
2276    return ret;
2277}
2278
2279int se050_ecc_verify_hash_ex(const byte* hash, word32 hashLen, MATH_INT_T* r,
2280                             MATH_INT_T* s, struct ecc_key* key, int* res)
2281{
2282    int                 ret = 0;
2283    sss_status_t        status;
2284    sss_asymmetric_t    ctx_asymm;
2285    sss_object_t        newKey;
2286    sss_key_store_t     host_keystore;
2287    sss_algorithm_t     algorithm;
2288    int                 keyId;
2289    int                 keySize;
2290    int                 keySizeBits;
2291    sss_cipher_type_t   curveType;
2292    int                 keyCreated = 0;
2293
2294    byte rBuf[ECC_MAX_CRYPTO_HW_SIZE];
2295    byte sBuf[ECC_MAX_CRYPTO_HW_SIZE];
2296    byte sigBuf[ECC_MAX_SIG_SIZE];
2297    word32 rBufSz = (word32)sizeof(rBuf);
2298    word32 sBufSz = (word32)sizeof(sBuf);
2299    word32 sigSz  = (word32)sizeof(sigBuf);
2300
2301#ifdef SE050_DEBUG
2302    printf("se050_ecc_verify_hash_ex: key %p, hash %p (%d)\n",
2303        key, hash, hashLen);
2304#endif
2305
2306    *res = 0;
2307
2308    if (cfg_se050_i2c_pi == NULL) {
2309        return WC_HW_E;
2310    }
2311
2312    keySize = key->dp->size;
2313    ret = se050_map_curve(key->dp->id, keySize, &keySizeBits, &curveType);
2314    if (ret != 0) {
2315        return ret;
2316    }
2317
2318    /* truncate hash if larger than key size */
2319    if (hashLen > (word32)keySize) {
2320        hashLen = (word32)keySize;
2321    }
2322
2323    /* For P-521, if inLen is 66, truncate down to 64 for SHA-512 */
2324    if ((keySize == 66) && (hashLen == 66)) {
2325        hashLen = 64;
2326    }
2327
2328    algorithm = se050_map_hash_alg(hashLen);
2329    if (algorithm == kAlgorithm_None) {
2330        WOLFSSL_MSG("SE050 ECDSA verify only supports SHA-1/224/256/384/512 digest sizes");
2331        return BAD_LENGTH_E;
2332    }
2333
2334    if (wolfSSL_CryptHwMutexLock() != 0) {
2335        return BAD_MUTEX_E;
2336    }
2337
2338    status = sss_key_store_context_init(&host_keystore, cfg_se050_i2c_pi);
2339    if (status == kStatus_SSS_Success) {
2340        status = sss_key_store_allocate(&host_keystore, SE050_KEYSTOREID_ECC);
2341    }
2342    if (status == kStatus_SSS_Success) {
2343        status = sss_key_object_init(&newKey, &host_keystore);
2344    }
2345
2346    /* this is run when a key was not generated and was instead passed in */
2347    if (status == kStatus_SSS_Success) {
2348        keyId = key->keyId;
2349        if (key->keyIdSet == 0) {
2350            byte derBuf[SE050_ECC_DER_MAX];
2351            word32 derSz;
2352
2353            ret = wc_EccPublicKeyToDer(key, derBuf, (word32)sizeof(derBuf), 1);
2354            if (ret >= 0) {
2355                derSz = ret;
2356                ret = 0;
2357            }
2358            else {
2359                status = kStatus_SSS_Fail;
2360            }
2361            if (status == kStatus_SSS_Success) {
2362                keyId = se050_allocate_key(SE050_ECC_KEY);
2363                status = sss_key_object_allocate_handle(&newKey, keyId,
2364                    kSSS_KeyPart_Public, curveType, keySize,
2365                    kKeyObject_Mode_Persistent);
2366            }
2367            if (status == kStatus_SSS_Success) {
2368                /* Try to delete existing key first, ignore return since will
2369                 * fail if no key exists yet */
2370                sss_key_store_erase_key(&host_keystore, &newKey);
2371
2372                keyCreated = 1;
2373                status = sss_key_store_set_key(&host_keystore, &newKey, derBuf,
2374                                                derSz, keySizeBits, NULL, 0);
2375            }
2376        }
2377        else {
2378            status = sss_key_object_get_handle(&newKey, keyId);
2379        }
2380    }
2381
2382    if (status == kStatus_SSS_Success) {
2383        status = sss_asymmetric_context_init(&ctx_asymm, cfg_se050_i2c_pi,
2384                                    &newKey, algorithm, kMode_SSS_Verify);
2385
2386        if (status == kStatus_SSS_Success) {
2387            /* SE050 expects ASN.1 encoded signature */
2388            XMEMSET(rBuf, 0, sizeof(rBuf));
2389            XMEMSET(sBuf, 0, sizeof(sBuf));
2390
2391            rBufSz = mp_unsigned_bin_size(r);
2392            sBufSz = mp_unsigned_bin_size(s);
2393
2394            if (rBufSz > sizeof(rBuf) || sBufSz > sizeof(sBuf)) {
2395                WOLFSSL_MSG("Internal R/S buffers too small for signature");
2396                ret = BUFFER_E;
2397            }
2398
2399            if (ret == 0) {
2400                ret = mp_to_unsigned_bin(r, rBuf);
2401                if (ret == MP_OKAY) {
2402                    ret = mp_to_unsigned_bin(s, sBuf);
2403                }
2404            }
2405
2406            if (ret == 0) {
2407                ret = StoreECC_DSA_Sig_Bin(sigBuf, &sigSz, rBuf, rBufSz,
2408                                           sBuf, sBufSz);
2409            }
2410
2411            if (ret == 0) {
2412                status = sss_asymmetric_verify_digest(&ctx_asymm,
2413                    (uint8_t*)hash, hashLen, sigBuf, sigSz);
2414            }
2415            else {
2416                status = kStatus_SSS_Fail;
2417            }
2418        }
2419        sss_asymmetric_context_free(&ctx_asymm);
2420    }
2421
2422    if (status == kStatus_SSS_Success) {
2423        key->keyId = keyId;
2424        key->keyIdSet = 1;
2425        *res = 1;
2426        ret = 0;
2427    }
2428    else {
2429        if (keyCreated) {
2430            sss_key_store_erase_key(&host_keystore, &newKey);
2431            sss_key_object_free(&newKey);
2432        }
2433        if (ret == 0)
2434            ret = WC_HW_E;
2435    }
2436
2437    wolfSSL_CryptHwMutexUnLock();
2438
2439#ifdef SE050_DEBUG
2440    printf("se050_ecc_verify_hash_ex: key %p, ret %d, res %d\n",
2441        key, ret, *res);
2442#endif
2443
2444    return ret;
2445}
2446
2447
2448void se050_ecc_free_key(struct ecc_key* key)
2449{
2450    sss_status_t    status = kStatus_SSS_Success;
2451    sss_object_t    keyObject;
2452    sss_key_store_t host_keystore;
2453
2454#ifdef SE050_DEBUG
2455    printf("se050_ecc_free_key: key %p, keyId %d\n", key, key->keyId);
2456#endif
2457
2458    if (cfg_se050_i2c_pi == NULL) {
2459        return;
2460    }
2461    if (key->keyIdSet == 0) {
2462        return;
2463    }
2464
2465    if (wolfSSL_CryptHwMutexLock() != 0) {
2466        return;
2467    }
2468
2469    status = sss_key_store_context_init(&host_keystore, cfg_se050_i2c_pi);
2470    if (status == kStatus_SSS_Success) {
2471        status = sss_key_store_allocate(&host_keystore, SE050_KEYSTOREID_ECC);
2472    }
2473    if (status == kStatus_SSS_Success) {
2474        status = sss_key_object_init(&keyObject, &host_keystore);
2475    }
2476    if (status == kStatus_SSS_Success) {
2477        status = sss_key_object_get_handle(&keyObject, key->keyId);
2478    }
2479
2480    if (status == kStatus_SSS_Success) {
2481        /* Erase key from SE050 persistent storage if it was allocated
2482         * by wolfSSL (not a pre-provisioned key). Without this, persistent
2483         * key objects leak on the SE050 and can exhaust secure storage. */
2484        if (key->keyId >= SE050_KEYID_START) {
2485            sss_key_store_erase_key(&host_keystore, &keyObject);
2486        }
2487        sss_key_object_free(&keyObject);
2488        key->keyId = 0;
2489        key->keyIdSet = 0;
2490    }
2491    wolfSSL_CryptHwMutexUnLock();
2492}
2493
2494/**
2495 * Use specified SE050 key ID with this ecc_key struct.
2496 * Should be called by wc_ecc_use_key_id() for using pre-populated
2497 * SE050 keys.
2498 *
2499 * key   Pointer to initialized ecc_key structure
2500 * keyId SE050 key ID containing ECC key object
2501 *
2502 * Return 0 on success, negative on error.
2503 */
2504int se050_ecc_use_key_id(struct ecc_key* key, word32 keyId)
2505{
2506    int ret = 0;
2507    sss_object_t    keyObject;
2508    sss_key_store_t host_keystore;
2509    sss_status_t    status = kStatus_SSS_Success;
2510    uint8_t         derBuf[SE050_ECC_DER_MAX];
2511    size_t          derSz = sizeof(derBuf);
2512    size_t          derSzBits = 0;
2513    word32          idx = 0;
2514
2515#ifdef SE050_DEBUG
2516    printf("se050_ecc_use_key_id: key %p, keyId %d\n", key, keyId);
2517#endif
2518    if (key == NULL) {
2519        return BAD_FUNC_ARG;
2520    }
2521
2522    if (cfg_se050_i2c_pi == NULL) {
2523        return WC_HW_E;
2524    }
2525
2526    if (wolfSSL_CryptHwMutexLock() != 0) {
2527        return BAD_MUTEX_E;
2528    }
2529
2530    status = sss_key_store_context_init(&host_keystore, cfg_se050_i2c_pi);
2531    if (status == kStatus_SSS_Success) {
2532        status = sss_key_store_allocate(&host_keystore, SE050_KEYSTOREID_ECC);
2533    }
2534    if (status == kStatus_SSS_Success) {
2535        status = sss_key_object_init(&keyObject, &host_keystore);
2536    }
2537    if (status == kStatus_SSS_Success) {
2538        status = sss_key_object_get_handle(&keyObject, keyId);
2539    }
2540    if (status == kStatus_SSS_Success) {
2541        derSzBits = derSz * 8;
2542        status = sss_key_store_get_key(&host_keystore, &keyObject,
2543            derBuf, &derSz, &derSzBits);
2544        (void)derSzBits; /* not used */
2545    }
2546    if (status == kStatus_SSS_Success) {
2547        ret = wc_EccPublicKeyDecode(derBuf, &idx, key, (word32)derSz);
2548        if (ret != 0) {
2549            status = kStatus_SSS_Fail;
2550        }
2551    }
2552    if (status == kStatus_SSS_Success) {
2553        key->keyId = keyId;
2554        key->keyIdSet = 1;
2555        ret = 0;
2556    }
2557    else if (ret == 0) {
2558        ret = WC_HW_E;
2559    }
2560
2561    sss_key_object_free(&keyObject);
2562
2563    wolfSSL_CryptHwMutexUnLock();
2564
2565#ifdef SE050_DEBUG
2566    printf("se050_ecc_use_key_id: ret %d\n", ret);
2567#endif
2568
2569    return ret;
2570}
2571
2572/**
2573 * Get SE050 key ID associated with this ecc_key struct.
2574 * Should be called by wc_ecc_get_key_id() for the application to get
2575 * what key ID wolfCrypt picked for this ecc_key struct when generating
2576 * a key inside the SE050.
2577 *
2578 * key   Pointer to initialized ecc_key structure
2579 * keyId [OUT] SE050 key ID associated with this key structure
2580 *
2581 * Return 0 on success, negative on error.
2582 */
2583int se050_ecc_get_key_id(struct ecc_key* key, word32* keyId)
2584{
2585    int ret = 0;
2586
2587    if (key == NULL || keyId == NULL) {
2588        return BAD_FUNC_ARG;
2589    }
2590
2591    if (key->keyIdSet == 1) {
2592        *keyId = key->keyId;
2593
2594    } else {
2595        WOLFSSL_MSG("SE050 key ID not set for ecc_key struct");
2596        ret = WC_HW_E;
2597    }
2598
2599    return ret;
2600}
2601
2602int se050_ecc_create_key(struct ecc_key* key, int curve_id, int keySize)
2603{
2604    int               ret = 0;
2605    sss_status_t      status = kStatus_SSS_Success;
2606    sss_object_t      keyPair;
2607    sss_key_store_t   host_keystore;
2608    uint8_t           derBuf[SE050_ECC_DER_MAX];
2609    size_t            derSz = sizeof(derBuf);
2610    word32            keyId = 0;
2611    int               keySizeBits;
2612    sss_cipher_type_t curveType;
2613    int               keyCreated = 0;
2614
2615#ifdef SE050_DEBUG
2616    printf("se050_ecc_create_key: key %p, curve %d, keySize %d\n",
2617        key, curve_id, keySize);
2618#endif
2619
2620    if (cfg_se050_i2c_pi == NULL) {
2621        return WC_HW_E;
2622    }
2623
2624    ret = se050_map_curve(curve_id, keySize, &keySizeBits, &curveType);
2625    if (ret != 0) {
2626        return ret;
2627    }
2628
2629    if (wolfSSL_CryptHwMutexLock() != 0) {
2630        return BAD_MUTEX_E;
2631    }
2632
2633    status = sss_key_store_context_init(&host_keystore, cfg_se050_i2c_pi);
2634    if (status == kStatus_SSS_Success) {
2635        status = sss_key_store_allocate(&host_keystore, SE050_KEYSTOREID_ECC);
2636    }
2637    if (status == kStatus_SSS_Success) {
2638        status = sss_key_object_init(&keyPair, &host_keystore);
2639    }
2640    if (status == kStatus_SSS_Success) {
2641        keyId = se050_allocate_key(SE050_ECC_KEY);
2642        /* Using Transient key type here does not work with SE050 */
2643        status = sss_key_object_allocate_handle(&keyPair, keyId,
2644            kSSS_KeyPart_Pair, curveType, keySize,
2645            kKeyObject_Mode_Persistent);
2646    }
2647    if (status == kStatus_SSS_Success) {
2648        /* Try to delete existing key first. Ignore return since will fail
2649         * if no key exists */
2650        sss_key_store_erase_key(&host_keystore, &keyPair);
2651
2652        keyCreated = 1;
2653        status = sss_key_store_generate_key(&host_keystore, &keyPair,
2654            keySizeBits, NULL);
2655    }
2656    if (status == kStatus_SSS_Success) {
2657        size_t derSzBits = derSz * 8;
2658        status = sss_key_store_get_key(&host_keystore, &keyPair,
2659            derBuf, &derSz, &derSzBits);
2660        (void)derSzBits; /* not used */
2661    }
2662    if (status == kStatus_SSS_Success) {
2663        word32 idx = 0;
2664        ret = wc_EccPublicKeyDecode(derBuf, &idx, key, (word32)derSz);
2665        if (ret != 0) {
2666            status = kStatus_SSS_Fail;
2667        }
2668    }
2669    if (status == kStatus_SSS_Success) {
2670        key->keyId = keyId;
2671        key->keyIdSet = 1;
2672        ret = 0;
2673    }
2674    else {
2675        if (keyCreated) {
2676            sss_key_store_erase_key(&host_keystore, &keyPair);
2677            sss_key_object_free(&keyPair);
2678        }
2679        if (ret == 0)
2680            ret = WC_HW_E;
2681    }
2682
2683    wolfSSL_CryptHwMutexUnLock();
2684
2685#ifdef SE050_DEBUG
2686    printf("se050_ecc_create_key: key %p, ret %d, status %d, keyId %d\n",
2687        key, ret, status, key->keyId);
2688#endif
2689
2690    return ret;
2691}
2692
2693
2694int se050_ecc_shared_secret(ecc_key* private_key, ecc_key* public_key,
2695    byte* out, word32* outlen)
2696{
2697    int                 ret;
2698    sss_status_t        status = kStatus_SSS_Success;
2699    sss_key_store_t     host_keystore;
2700    sss_object_t        ref_private_key;
2701    sss_object_t        ref_public_key;
2702    sss_object_t        deriveKey;
2703    sss_derive_key_t    ctx_derive_key;
2704    word32              keyId = 0;
2705    int                 keySize;
2706    int                 keySizeBits;
2707    sss_cipher_type_t   curveType;
2708    int                 keyCreated = 0;
2709    int                 deriveKeyCreated = 0;
2710
2711#ifdef SE050_DEBUG
2712    printf("se050_ecc_shared_secret: priv %p, pub %p, out %p (%d)\n",
2713        private_key, public_key, out, *outlen);
2714#endif
2715
2716    if (cfg_se050_i2c_pi == NULL) {
2717        return WC_HW_E;
2718    }
2719    if (private_key == NULL || public_key == NULL ||
2720        private_key->keyIdSet == 0) {
2721        return BAD_FUNC_ARG;
2722    }
2723
2724    keySize = private_key->dp->size;
2725    ret = se050_map_curve(private_key->dp->id, keySize, &keySizeBits,
2726                          &curveType);
2727    if (ret != 0) {
2728        return ret;
2729    }
2730
2731    if (wolfSSL_CryptHwMutexLock() != 0) {
2732        return BAD_MUTEX_E;
2733    }
2734
2735    status = sss_key_store_context_init(&host_keystore, cfg_se050_i2c_pi);
2736    if (status == kStatus_SSS_Success) {
2737        status = sss_key_store_allocate(&host_keystore, SE050_KEYSTOREID_ECC);
2738    }
2739    if (status == kStatus_SSS_Success) {
2740        status = sss_key_object_init(&ref_private_key, &host_keystore);
2741    }
2742    if (status == kStatus_SSS_Success) {
2743        status = sss_key_object_get_handle(&ref_private_key,
2744                                           private_key->keyId);
2745    }
2746    if (status == kStatus_SSS_Success) {
2747        status = sss_key_object_init(&ref_public_key, &host_keystore);
2748    }
2749    if (status == kStatus_SSS_Success) {
2750        keyId = public_key->keyId;
2751        if (public_key->keyIdSet == 0) {
2752            byte derBuf[SE050_ECC_DER_MAX];
2753            word32 derSz;
2754
2755            ret = wc_EccPublicKeyToDer(public_key, derBuf,
2756                (word32)sizeof(derBuf), 1);
2757            if (ret >= 0) {
2758                derSz = ret;
2759                ret = 0;
2760            }
2761            else {
2762                status = kStatus_SSS_Fail;
2763            }
2764            if (status == kStatus_SSS_Success) {
2765                keyId = se050_allocate_key(SE050_ECC_KEY);
2766                status = sss_key_object_allocate_handle(&ref_public_key,
2767                    keyId, kSSS_KeyPart_Public, curveType, keySize,
2768                    kKeyObject_Mode_Persistent);
2769            }
2770            if (status == kStatus_SSS_Success) {
2771                /* Try to delete existing key first, ignore return since will
2772                 * fail if no key exists yet */
2773                sss_key_store_erase_key(&host_keystore, &ref_public_key);
2774                status = sss_key_store_set_key(&host_keystore, &ref_public_key,
2775                    derBuf, derSz, keySizeBits, NULL, 0);
2776                keyCreated = 1;
2777            }
2778        }
2779        else {
2780            status = sss_key_object_get_handle(&ref_public_key, keyId);
2781        }
2782    }
2783    if (status == kStatus_SSS_Success) {
2784        status = sss_key_object_init(&deriveKey, &host_keystore);
2785    }
2786    if (status == kStatus_SSS_Success) {
2787        word32 keyIdAes = se050_allocate_key(SE050_AES_KEY);
2788        status = sss_key_object_allocate_handle(&deriveKey,
2789            keyIdAes,
2790            kSSS_KeyPart_Default,
2791            kSSS_CipherType_Binary,
2792            keySize,
2793            kKeyObject_Mode_Transient);
2794    }
2795    if (status == kStatus_SSS_Success) {
2796        status = sss_derive_key_context_init(&ctx_derive_key, cfg_se050_i2c_pi,
2797                                    &ref_private_key, kAlgorithm_SSS_ECDH,
2798                                    kMode_SSS_ComputeSharedSecret);
2799        if (status == kStatus_SSS_Success) {
2800            /* Try to delete existing key first, ignore return since will
2801             * fail if no key exists yet */
2802            sss_key_store_erase_key(&host_keystore, &deriveKey);
2803            status = sss_derive_key_dh(&ctx_derive_key, &ref_public_key,
2804                &deriveKey);
2805        }
2806        if (status == kStatus_SSS_Success) {
2807            size_t outlenSz = (size_t)*outlen;
2808            size_t outlenSzBits = outlenSz * 8;
2809            deriveKeyCreated = 1;
2810            /* derived key export */
2811            status = sss_key_store_get_key(&host_keystore, &deriveKey,
2812                out, &outlenSz, &outlenSzBits);
2813            *outlen = (word32)outlenSz;
2814            (void)outlenSzBits; /* not used */
2815        }
2816
2817        sss_derive_key_context_free(&ctx_derive_key);
2818    }
2819    if (deriveKeyCreated) {
2820        sss_key_store_erase_key(&host_keystore, &deriveKey);
2821        sss_key_object_free(&deriveKey);
2822    }
2823
2824    if (status == kStatus_SSS_Success) {
2825        public_key->keyId = keyId;
2826        public_key->keyIdSet = 1;
2827        ret = 0;
2828    }
2829    else {
2830        if (keyCreated) {
2831            sss_key_store_erase_key(&host_keystore, &ref_public_key);
2832            sss_key_object_free(&ref_public_key);
2833        }
2834        if (ret == 0) {
2835            ret = WC_HW_E;
2836        }
2837    }
2838
2839    wolfSSL_CryptHwMutexUnLock();
2840
2841#ifdef SE050_DEBUG
2842    printf("se050_ecc_shared_secret: ret %d, status %d, outlen %d\n", ret,
2843            status, *outlen);
2844#endif
2845
2846    return ret;
2847}
2848#endif /* HAVE_ECC */
2849
2850#ifdef HAVE_ED25519
2851
2852int se050_ed25519_create_key(ed25519_key* key)
2853{
2854    int             ret = 0;
2855    sss_status_t    status;
2856    sss_key_store_t host_keystore;
2857    sss_object_t    newKey;
2858    word32          keyId;
2859    int             keySize = ED25519_KEY_SIZE;
2860    int             keyCreated = 0;
2861
2862#ifdef SE050_DEBUG
2863    printf("se050_ed25519_create_key: %p\n", key);
2864#endif
2865
2866    if (cfg_se050_i2c_pi == NULL) {
2867        return WC_HW_E;
2868    }
2869
2870    if (wolfSSL_CryptHwMutexLock() != 0) {
2871        return BAD_MUTEX_E;
2872    }
2873
2874    status = sss_key_store_context_init(&host_keystore, cfg_se050_i2c_pi);
2875    if (status == kStatus_SSS_Success) {
2876        status = sss_key_store_allocate(&host_keystore, SE050_KEYSTOREID_ED25519);
2877    }
2878    if (status == kStatus_SSS_Success) {
2879        status = sss_key_object_init(&newKey, &host_keystore);
2880    }
2881    if (status == kStatus_SSS_Success) {
2882        keyId = se050_allocate_key(SE050_ED25519_KEY);
2883        status = sss_key_object_allocate_handle(&newKey, keyId,
2884            kSSS_KeyPart_Pair, kSSS_CipherType_EC_TWISTED_ED, keySize,
2885            kKeyObject_Mode_Transient);
2886    }
2887    if (status == kStatus_SSS_Success) {
2888        keyCreated = 1;
2889        status = sss_key_store_generate_key(&host_keystore, &newKey,
2890            keySize * 8, NULL);
2891    }
2892
2893    if (status == kStatus_SSS_Success) {
2894        key->keyId = keyId;
2895        key->keyIdSet = 1;
2896        ret = 0;
2897    }
2898    else {
2899        if (keyCreated) {
2900            sss_key_store_erase_key(&host_keystore, &newKey);
2901            sss_key_object_free(&newKey);
2902        }
2903        ret = WC_HW_E;
2904    }
2905
2906    wolfSSL_CryptHwMutexUnLock();
2907
2908#ifdef SE050_DEBUG
2909    printf("se050_ed25519_create_key: ret %d, keyId %ld\n", ret, key->keyId);
2910#endif
2911
2912    return ret;
2913}
2914
2915void se050_ed25519_free_key(ed25519_key* key)
2916{
2917    sss_status_t status;
2918    sss_object_t newKey;
2919    sss_key_store_t host_keystore;
2920
2921#ifdef SE050_DEBUG
2922    printf("se050_ed25519_free_key: %p, id %ld\n", key, key->keyId);
2923#endif
2924
2925    if (cfg_se050_i2c_pi == NULL) {
2926        return;
2927    }
2928    if (key->keyIdSet == 0) {
2929        return;
2930    }
2931
2932    if (wolfSSL_CryptHwMutexLock() != 0) {
2933        return;
2934    }
2935
2936    status = sss_key_store_context_init(&host_keystore, cfg_se050_i2c_pi);
2937
2938    if (status == kStatus_SSS_Success) {
2939        status = sss_key_store_allocate(&host_keystore, SE050_KEYSTOREID_ED25519);
2940    }
2941    if (status == kStatus_SSS_Success) {
2942        status = sss_key_object_init(&newKey, &host_keystore);
2943    }
2944    if (status == kStatus_SSS_Success) {
2945        status = sss_key_object_get_handle(&newKey, key->keyId);
2946    }
2947    if (status == kStatus_SSS_Success) {
2948        if (key->keyId >= SE050_KEYID_START) {
2949            sss_key_store_erase_key(&host_keystore, &newKey);
2950        }
2951        sss_key_object_free(&newKey);
2952        key->keyId = 0;
2953        key->keyIdSet = 0;
2954    }
2955    wolfSSL_CryptHwMutexUnLock();
2956}
2957
2958int se050_ed25519_sign_msg(const byte* in, word32 inLen, byte* out,
2959                         word32 *outLen, ed25519_key* key)
2960{
2961    int                 ret = 0;
2962    sss_status_t        status = kStatus_SSS_Success;
2963    sss_asymmetric_t    ctx_asymm;
2964    sss_key_store_t     host_keystore;
2965    sss_object_t        newKey;
2966    int                 keySize = ED25519_KEY_SIZE;
2967    int                 keyCreated = 0;
2968    word32              keyId;
2969
2970#ifdef SE050_DEBUG
2971    printf("se050_ed25519_sign_msg: key %p, in %p (%d), out %p (%d), "
2972            "keyId %ld\n", key, in, inLen, out, *outLen, key->keyId);
2973#endif
2974
2975    if (cfg_se050_i2c_pi == NULL) {
2976        return WC_HW_E;
2977    }
2978
2979    if (wolfSSL_CryptHwMutexLock() != 0) {
2980        return BAD_MUTEX_E;
2981    }
2982
2983    status = sss_key_store_context_init(&host_keystore, cfg_se050_i2c_pi);
2984    if (status == kStatus_SSS_Success) {
2985        status = sss_key_store_allocate(&host_keystore, SE050_KEYSTOREID_ED25519);
2986    }
2987    if (status == kStatus_SSS_Success) {
2988        status = sss_key_object_init(&newKey, &host_keystore);
2989    }
2990    /* this is run when a key was not generated and was instead passed in */
2991    if (status == kStatus_SSS_Success) {
2992        keyId = key->keyId;
2993        if (key->keyIdSet == 0) {
2994            byte derBuf[SE050_ECC_DER_MAX];
2995            word32 derSz;
2996
2997            ret = wc_Ed25519KeyToDer(key, derBuf, (word32)sizeof(derBuf));
2998            if (ret >= 0) {
2999                derSz = ret;
3000                ret = 0;
3001            }
3002            else {
3003                status = kStatus_SSS_Fail;
3004            }
3005            if (status == kStatus_SSS_Success) {
3006                keyId = se050_allocate_key(SE050_ED25519_KEY);
3007                status = sss_key_object_allocate_handle(&newKey, keyId,
3008                    kSSS_KeyPart_Pair, kSSS_CipherType_EC_TWISTED_ED, keySize,
3009                    kKeyObject_Mode_Transient);
3010            }
3011            if (status == kStatus_SSS_Success) {
3012                keyCreated = 1;
3013                status = sss_key_store_set_key(&host_keystore, &newKey, derBuf,
3014                                                derSz, keySize * 8, NULL, 0);
3015            }
3016        }
3017        else {
3018            status = sss_key_object_get_handle(&newKey, keyId);
3019        }
3020    }
3021    if (status == kStatus_SSS_Success) {
3022        status = sss_asymmetric_context_init(&ctx_asymm, cfg_se050_i2c_pi,
3023                            &newKey, kAlgorithm_SSS_SHA512, kMode_SSS_Sign);
3024        if (status == kStatus_SSS_Success) {
3025            size_t outlenSz = (size_t)*outLen;
3026            status = sss_se05x_asymmetric_sign(
3027                    (sss_se05x_asymmetric_t *)&ctx_asymm,
3028                    (uint8_t *)in, inLen, out, &outlenSz);
3029            *outLen = (word32)outlenSz;
3030        }
3031
3032        sss_asymmetric_context_free(&ctx_asymm);
3033    }
3034
3035    if (status != kStatus_SSS_Success) {
3036        if (keyCreated) {
3037            sss_key_store_erase_key(&host_keystore, &newKey);
3038            sss_key_object_free(&newKey);
3039        }
3040        ret = WC_HW_E;
3041    } else {
3042        key->keyId = keyId;
3043        key->keyIdSet = 1;
3044    }
3045
3046    wolfSSL_CryptHwMutexUnLock();
3047
3048#ifdef SE050_DEBUG
3049    printf("se050_ed25519_sign_msg: ret %d, outLen %d\n", ret, *outLen);
3050#endif
3051
3052    return ret;
3053}
3054
3055int se050_ed25519_verify_msg(const byte* signature, word32 signatureLen,
3056    const byte* msg, word32 msgLen, struct ed25519_key* key, int* res)
3057{
3058    int                 ret = 0;
3059    sss_status_t        status = kStatus_SSS_Success;
3060    sss_asymmetric_t    ctx_asymm;
3061    sss_object_t        newKey;
3062    sss_key_store_t     host_keystore;
3063    word32              keyId;
3064    int                 keySize = ED25519_KEY_SIZE;
3065    int                 keyCreated = 0;
3066
3067#ifdef SE050_DEBUG
3068    printf("se050_ed25519_verify_msg: key %p, sig %p (%d), msg %p (%d)\n",
3069        key, signature, signatureLen, msg, msgLen);
3070#endif
3071
3072    if (signature == NULL || msg == NULL || key == NULL || res == NULL) {
3073        return BAD_FUNC_ARG;
3074    }
3075
3076    *res = 0;
3077
3078    if (cfg_se050_i2c_pi == NULL) {
3079        return WC_HW_E;
3080    }
3081
3082    if (wolfSSL_CryptHwMutexLock() != 0) {
3083        return BAD_MUTEX_E;
3084    }
3085
3086    status = sss_key_store_context_init(&host_keystore, cfg_se050_i2c_pi);
3087    if (status == kStatus_SSS_Success) {
3088        status = sss_key_store_allocate(&host_keystore,
3089                                        SE050_KEYSTOREID_ED25519);
3090    }
3091    if (status == kStatus_SSS_Success) {
3092        status = sss_key_object_init(&newKey, &host_keystore);
3093    }
3094    if (status == kStatus_SSS_Success) {
3095        keyId = key->keyId;
3096        if (key->keyIdSet == 0) {
3097            byte derBuf[ED25519_PUB_KEY_SIZE + 12]; /* seq + algo + bitstring */
3098            word32 derSz = 0;
3099
3100            ret = wc_Ed25519PublicKeyToDer(key, derBuf,
3101                                           (word32)sizeof(derBuf), 1);
3102            if (ret >= 0) {
3103                derSz = ret;
3104                ret = 0;
3105            }
3106            else {
3107                status = kStatus_SSS_Fail;
3108            }
3109            if (status == kStatus_SSS_Success) {
3110                keyId = se050_allocate_key(SE050_ED25519_KEY);
3111                status = sss_key_object_allocate_handle(&newKey, keyId,
3112                    kSSS_KeyPart_Public, kSSS_CipherType_EC_TWISTED_ED, keySize,
3113                    kKeyObject_Mode_Transient);
3114            }
3115            if (status == kStatus_SSS_Success) {
3116                keyCreated = 1;
3117                status = sss_key_store_set_key(&host_keystore, &newKey, derBuf,
3118                                                derSz, keySize * 8, NULL, 0);
3119            }
3120        }
3121        else {
3122            status = sss_key_object_get_handle(&newKey, keyId);
3123        }
3124    }
3125
3126    if (status == kStatus_SSS_Success) {
3127        status = sss_asymmetric_context_init(&ctx_asymm, cfg_se050_i2c_pi,
3128                    &newKey, kAlgorithm_SSS_SHA512, kMode_SSS_Verify);
3129        if (status == kStatus_SSS_Success) {
3130            status = sss_se05x_asymmetric_verify(
3131                    (sss_se05x_asymmetric_t*)&ctx_asymm, (uint8_t*)msg, msgLen,
3132                    (uint8_t*)signature, (size_t)signatureLen);
3133        }
3134        sss_asymmetric_context_free(&ctx_asymm);
3135    }
3136
3137    if (status == kStatus_SSS_Success) {
3138        if (keyCreated) {
3139            /* We uploaded only the public part of the key for this verify.
3140             * Don't persist keyIdSet=1 -- a later sign on the same ed25519_key
3141             * would reuse this binding and fail because the SE050 object has
3142             * no private material. Erase the transient object so the next
3143             * SE050 op re-uploads. Mirrors the fix in se050_rsa_verify. */
3144            sss_key_store_erase_key(&host_keystore, &newKey);
3145            sss_key_object_free(&newKey);
3146        }
3147        else {
3148            /* Pre-existing keyIdSet=1 binding (from prior sign that uploaded
3149             * a keypair, or explicit caller setup). Preserve it. */
3150            key->keyId = keyId;
3151            key->keyIdSet = 1;
3152        }
3153        *res = 1;
3154        ret = 0;
3155    }
3156    else {
3157        if (keyCreated) {
3158            sss_key_store_erase_key(&host_keystore, &newKey);
3159            sss_key_object_free(&newKey);
3160        }
3161        if (ret == 0)
3162            ret = WC_HW_E;
3163    }
3164
3165    wolfSSL_CryptHwMutexUnLock();
3166
3167#ifdef SE050_DEBUG
3168    printf("se050_ed25519_verify_msg: ret %d, res %d\n", ret, *res);
3169#endif
3170
3171    return ret;
3172}
3173
3174#endif /* HAVE_ED25519 */
3175
3176
3177#ifdef HAVE_CURVE25519
3178
3179int se050_curve25519_create_key(curve25519_key* key, int keySize)
3180{
3181    int             ret;
3182    sss_status_t    status = kStatus_SSS_Success;
3183    sss_object_t    keyPair;
3184    sss_key_store_t host_keystore;
3185    uint8_t         derBuf[SE050_ECC_DER_MAX];
3186    size_t          derSz = sizeof(derBuf);
3187    word32          keyId;
3188    int             keyCreated = 0;
3189
3190#ifdef SE050_DEBUG
3191    printf("se050_curve25519_create_key: key %p, keySize %d\n",
3192        key, keySize);
3193#endif
3194
3195    if (cfg_se050_i2c_pi == NULL) {
3196        return WC_HW_E;
3197    }
3198    if (wolfSSL_CryptHwMutexLock() != 0) {
3199        return BAD_MUTEX_E;
3200    }
3201
3202    status = sss_key_store_context_init(&host_keystore, cfg_se050_i2c_pi);
3203    if (status == kStatus_SSS_Success) {
3204        status = sss_key_store_allocate(&host_keystore,
3205            SE050_KEYSTOREID_CURVE25519);
3206    }
3207    if (status == kStatus_SSS_Success) {
3208        status = sss_key_object_init(&keyPair, &host_keystore);
3209    }
3210    if (status == kStatus_SSS_Success) {
3211        keyId = se050_allocate_key(SE050_CURVE25519_KEY);
3212        status = sss_key_object_allocate_handle(&keyPair, keyId,
3213            kSSS_KeyPart_Pair, kSSS_CipherType_EC_MONTGOMERY, keySize,
3214            kKeyObject_Mode_None);
3215    }
3216    if (status == kStatus_SSS_Success) {
3217        keyCreated = 1;
3218        status = sss_key_store_generate_key(&host_keystore, &keyPair,
3219            keySize * 8, NULL);
3220    }
3221    if (status == kStatus_SSS_Success) {
3222        size_t derSzBits = derSz * 8;
3223        status = sss_key_store_get_key(&host_keystore, &keyPair,
3224            derBuf, &derSz, &derSzBits);
3225        (void)derSzBits; /* not used */
3226    }
3227    if (status == kStatus_SSS_Success) {
3228        word32 idx = 0;
3229        byte   pubKey[CURVE25519_KEYSIZE];
3230        word32 pubKeyLen = (word32)sizeof(pubKey);
3231
3232        ret = DecodeAsymKeyPublic(derBuf, &idx, (word32)derSz,
3233            pubKey, &pubKeyLen, X25519k);
3234        if (ret == 0) {
3235            ret = wc_curve25519_import_public_ex(pubKey, pubKeyLen, key,
3236                EC25519_LITTLE_ENDIAN);
3237        }
3238        if (ret != 0) {
3239            status = kStatus_SSS_Fail;
3240        }
3241    }
3242
3243    if (status == kStatus_SSS_Success) {
3244        key->keyId = keyId;
3245        key->keyIdSet = 1;
3246        ret = 0;
3247    }
3248    else {
3249        if (keyCreated) {
3250            sss_key_store_erase_key(&host_keystore, &keyPair);
3251            sss_key_object_free(&keyPair);
3252        }
3253        ret = WC_HW_E;
3254    }
3255    wolfSSL_CryptHwMutexUnLock();
3256
3257#ifdef SE050_DEBUG
3258    printf("se050_curve25519_create_key: key %p, ret %d, keyId %ld\n",
3259        key, ret, key->keyId);
3260#endif
3261
3262    return ret;
3263}
3264
3265int se050_curve25519_shared_secret(curve25519_key* private_key,
3266    curve25519_key* public_key, ECPoint* out)
3267{
3268    int               ret = 0;
3269    sss_status_t      status = kStatus_SSS_Success;
3270    sss_key_store_t   host_keystore;
3271    sss_object_t      ref_private_key;
3272    sss_object_t      ref_public_key;
3273    sss_object_t      deriveKey;
3274    sss_derive_key_t  ctx_derive_key;
3275    word32            keyId;
3276    int               keySize = CURVE25519_KEYSIZE;
3277    int               keyCreated = 0;
3278    int               deriveKeyCreated = 0;
3279
3280#ifdef SE050_DEBUG
3281    printf("se050_curve25519_shared_secret: priv %p, pub %p, out %p (%d)\n",
3282        private_key, public_key, out, out->pointSz);
3283#endif
3284
3285    if (cfg_se050_i2c_pi == NULL) {
3286        return WC_HW_E;
3287    }
3288
3289    if (private_key == NULL || public_key == NULL ||
3290        private_key->keyIdSet == 0) {
3291        return BAD_FUNC_ARG;
3292    }
3293
3294    if (wolfSSL_CryptHwMutexLock() != 0) {
3295        return BAD_MUTEX_E;
3296    }
3297
3298    status = sss_key_store_context_init(&host_keystore, cfg_se050_i2c_pi);
3299    if (status == kStatus_SSS_Success) {
3300        status = sss_key_store_allocate(&host_keystore,
3301            SE050_KEYSTOREID_CURVE25519);
3302    }
3303    if (status == kStatus_SSS_Success) {
3304        status = sss_key_object_init(&ref_private_key, &host_keystore);
3305    }
3306    if (status == kStatus_SSS_Success) {
3307        status = sss_key_object_get_handle(&ref_private_key,
3308                                           private_key->keyId);
3309    }
3310    if (status == kStatus_SSS_Success) {
3311        status = sss_key_object_init(&ref_public_key, &host_keystore);
3312    }
3313    if (status == kStatus_SSS_Success) {
3314        keyId = public_key->keyId;
3315        if (public_key->keyIdSet == 0) {
3316            byte   derBuf[CURVE25519_PUB_KEY_SIZE + 12]; /* seq + algo + bitstring */
3317            word32 derSz;
3318            byte   pubKey[CURVE25519_PUB_KEY_SIZE];
3319            word32 pubKeyLen = (word32)sizeof(pubKey);
3320
3321            ret = wc_curve25519_export_public_ex(public_key, pubKey, &pubKeyLen,
3322                EC25519_LITTLE_ENDIAN);
3323            if (ret == 0) {
3324                ret = SetAsymKeyDerPublic(pubKey, pubKeyLen, derBuf,
3325                    (word32)sizeof(derBuf), X25519k, 1);
3326                if (ret >= 0) {
3327                    derSz = ret;
3328                    ret = 0;
3329                }
3330            }
3331            if (ret != 0) {
3332                status = kStatus_SSS_Fail;
3333            }
3334            if (status == kStatus_SSS_Success) {
3335                keyId = se050_allocate_key(SE050_CURVE25519_KEY);
3336                status = sss_key_object_allocate_handle(&ref_public_key,
3337                    keyId, kSSS_KeyPart_Public, kSSS_CipherType_EC_MONTGOMERY,
3338                    keySize, kKeyObject_Mode_Transient);
3339            }
3340            if (status == kStatus_SSS_Success) {
3341                keyCreated = 1;
3342                status = sss_key_store_set_key(&host_keystore, &ref_public_key,
3343                    derBuf, derSz, keySize * 8, NULL, 0);
3344            }
3345        }
3346        else {
3347            status = sss_key_object_get_handle(&ref_public_key, keyId);
3348        }
3349    }
3350    if (status == kStatus_SSS_Success) {
3351        status = sss_key_object_init(&deriveKey, &host_keystore);
3352    }
3353    if (status == kStatus_SSS_Success) {
3354        word32 keyIdAes = se050_allocate_key(SE050_AES_KEY);
3355        deriveKeyCreated = 1;
3356        status = sss_key_object_allocate_handle(&deriveKey,
3357            keyIdAes,
3358            kSSS_KeyPart_Default,
3359            kSSS_CipherType_Binary,
3360            keySize,
3361            kKeyObject_Mode_Transient);
3362    }
3363    if (status == kStatus_SSS_Success) {
3364        status = sss_derive_key_context_init(&ctx_derive_key, cfg_se050_i2c_pi,
3365                                    &ref_private_key, kAlgorithm_SSS_ECDH,
3366                                    kMode_SSS_ComputeSharedSecret);
3367        if (status == kStatus_SSS_Success) {
3368            status = sss_derive_key_dh(&ctx_derive_key, &ref_public_key,
3369                &deriveKey);
3370        }
3371        if (status == kStatus_SSS_Success) {
3372            size_t outlenSz = sizeof(out->point);
3373            size_t outlenSzBits = outlenSz * 8;
3374            /* derived key export */
3375            status = sss_key_store_get_key(&host_keystore, &deriveKey,
3376                out->point, &outlenSz, &outlenSzBits);
3377            out->pointSz = (word32)outlenSz;
3378            (void)outlenSzBits; /* not used */
3379        }
3380
3381        sss_derive_key_context_free(&ctx_derive_key);
3382    }
3383    if (deriveKeyCreated) {
3384        sss_key_store_erase_key(&host_keystore, &deriveKey);
3385        sss_key_object_free(&deriveKey);
3386    }
3387
3388    if (status == kStatus_SSS_Success) {
3389        public_key->keyId = keyId;
3390        public_key->keyIdSet = 1;
3391        ret = 0;
3392    }
3393    else {
3394        if (keyCreated) {
3395            sss_key_store_erase_key(&host_keystore, &ref_public_key);
3396            sss_key_object_free(&ref_public_key);
3397        }
3398        if (ret == 0)
3399            ret = WC_HW_E;
3400    }
3401
3402    wolfSSL_CryptHwMutexUnLock();
3403
3404#ifdef SE050_DEBUG
3405    printf("se050_curve25519_shared_secret: ret %d, outlen %d\n",
3406        ret, out->pointSz);
3407#endif
3408
3409    return ret;
3410}
3411
3412void se050_curve25519_free_key(struct curve25519_key* key)
3413{
3414    sss_status_t status;
3415    sss_object_t newKey;
3416    sss_key_store_t host_keystore;
3417
3418#ifdef SE050_DEBUG
3419    printf("se050_curve25519_free_key: %p, id %ld\n", key, key->keyId);
3420#endif
3421
3422    if (cfg_se050_i2c_pi == NULL || key->keyIdSet == 0) {
3423        return;
3424    }
3425
3426    if (wolfSSL_CryptHwMutexLock() != 0) {
3427        return;
3428    }
3429
3430    status = sss_key_store_context_init(&host_keystore, cfg_se050_i2c_pi);
3431
3432    if (status == kStatus_SSS_Success) {
3433        status = sss_key_store_allocate(&host_keystore,
3434            SE050_KEYSTOREID_CURVE25519);
3435    }
3436    if (status == kStatus_SSS_Success) {
3437        status = sss_key_object_init(&newKey, &host_keystore);
3438    }
3439    if (status == kStatus_SSS_Success) {
3440        status = sss_key_object_get_handle(&newKey, key->keyId);
3441    }
3442    if (status == kStatus_SSS_Success) {
3443        if (key->keyId >= SE050_KEYID_START) {
3444            sss_key_store_erase_key(&host_keystore, &newKey);
3445        }
3446        sss_key_object_free(&newKey);
3447        key->keyId = 0;
3448        key->keyIdSet = 0;
3449    }
3450    wolfSSL_CryptHwMutexUnLock();
3451}
3452#endif /* HAVE_CURVE25519 */
3453
3454#endif /* WOLFSSL_SE050 */