luna - wolfssl/wolfcrypt/src/port/atmel/atmel.c

   1/* atmel.c
   2 *
   3 * Copyright (C) 2006-2026 wolfSSL Inc.
   4 *
   5 * This file is part of wolfSSL.
   6 *
   7 * wolfSSL is free software; you can redistribute it and/or modify
   8 * it under the terms of the GNU General Public License as published by
   9 * the Free Software Foundation; either version 3 of the License, or
  10 * (at your option) any later version.
  11 *
  12 * wolfSSL is distributed in the hope that it will be useful,
  13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 * GNU General Public License for more details.
  16 *
  17 * You should have received a copy of the GNU General Public License
  18 * along with this program; if not, write to the Free Software
  19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335, USA
  20 */
  21
  22#ifdef HAVE_CONFIG_H
  23    #include <config.h>
  24#endif
  25
  26#include <wolfssl/wolfcrypt/settings.h>
  27
  28/*
  29 * WOLFSSL_MANUALLY_SELECT_DEVICE_CONFIG             default: off (not defined)
  30          You can define this in a user_settings.h file to specify your custom
  31          configuration of a device
  32 * WOLFSSL_ATCA_DEVICE_NO      use first device in the list     default: 0
  33 */
  34
  35#if defined(WOLFSSL_ATMEL) || defined(WOLFSSL_ATECC508A) || \
  36    defined(WOLFSSL_ATECC608A) || defined(WOLFSSL_ATECC_PKCB) || \
  37    defined(WOLFSSL_MICROCHIP_TA100)
  38
  39#include <wolfssl/wolfcrypt/memory.h>
  40#include <wolfssl/wolfcrypt/error-crypt.h>
  41#include <wolfssl/ssl.h>
  42#include <wolfssl/internal.h>
  43
  44#ifdef WOLFSSL_ATECC_TNGTLS
  45#include "tng/tng_atcacert_client.h"
  46#endif
  47
  48#ifdef WOLFSSL_ATECC_TFLXTLS
  49#include "atcacert/atcacert_client.h"
  50#include "tng/cust_def_device.h"
  51#include "tng/cust_def_signer.h"
  52#endif
  53
  54#ifdef NO_INLINE
  55    #include <wolfssl/wolfcrypt/misc.h>
  56#else
  57    #define WOLFSSL_MISC_INCLUDED
  58    #include <wolfcrypt/src/misc.c>
  59#endif
  60
  61#ifdef WOLFSSL_ATMEL
  62/* remap name conflicts */
  63#define Aes Aes_Remap
  64#define Gmac Gmac_Remap
  65#include "asf.h"
  66#undef Aes
  67#undef Gmac
  68#endif /* WOLFSSL_ATMEL */
  69
  70#include <wolfssl/wolfcrypt/port/atmel/atmel.h>
  71
  72#if defined(WOLFSSL_ATECC508A) || defined(WOLFSSL_ATECC608A) || \
  73    defined(WOLFSSL_MICROCHIP_TA100)
  74
  75#ifdef WOLFSSL_ATECC508A_TLS
  76    extern ATCA_STATUS device_init_default(void);
  77#endif
  78
  79static int mAtcaInitDone = 0;
  80
  81/* ATECC slotId handling */
  82static atmel_slot_alloc_cb mSlotAlloc;
  83static atmel_slot_dealloc_cb mSlotDealloc;
  84static byte mSlotList[ATECC_MAX_SLOT];
  85#ifndef SINGLE_THREADED
  86static wolfSSL_Mutex mSlotMutex;
  87#endif
  88
  89/* Raspberry Pi uses /dev/i2c-1 */
  90#ifndef ATECC_I2C_ADDR
  91    #ifdef WOLFSSL_ATECC_TNGTLS
  92        #define ATECC_I2C_ADDR 0x6A
  93    #else
  94        #define ATECC_I2C_ADDR 0xC0
  95    #endif
  96#endif
  97#ifndef ATECC_I2C_BUS
  98#define ATECC_I2C_BUS  1
  99#endif
 100#ifdef ATECC_DEV_TYPE /* for backward compatibility */
 101    #define MICROCHIP_DEV_TYPE ATECC_DEV_TYPE
 102#endif
 103#ifndef MICROCHIP_DEV_TYPE
 104    #ifdef WOLFSSL_ATECC508A
 105        #define MICROCHIP_DEV_TYPE ATECC508A
 106    #elif defined(WOLFSSL_ATECC608A)
 107        #define MICROCHIP_DEV_TYPE ATECC608A
 108    #elif defined(WOLFSSL_MICROCHIP_TA100)
 109        #define MICROCHIP_DEV_TYPE TA100
 110    #endif
 111#endif
 112static int ateccx08a_cfg_initialized = 0;
 113
 114#if defined(WOLFSSL_ATECC608A) && defined(MICROCHIP_MPLAB_HARMONY_3)
 115    /* Harmony3 will generate configuration based on user inputs */
 116    extern ATCAIfaceCfg atecc608_0_init_data;
 117#endif
 118
 119#ifndef WOLFSSL_ATCA_DEVICE_NO
 120    /* Default to first device in the list*/
 121    #define WOLFSSL_ATCA_DEVICE_NO 0
 122#endif
 123    static ATCAIfaceCfg config_atmel_device[]  = {
 124    /* Enable and Select user configuration of device and parameters. */
 125#if defined(WOLFSSL_MANUALLY_SELECT_DEVICE_CONFIG)
 126     WOLFSSL_MANUALLY_SELECT_DEVICE_CONFIG,
 127    /* Try detecting all available device configs */
 128#elif defined(WOLFSSL_ATECC608A) && defined(MICROCHIP_MPLAB_HARMONY_3)
 129    atecc608_0_init_data,
 130#endif
 131#ifdef ATCA_HAL_SPI
 132    {
 133        .iface_type = ATCA_SPI_IFACE,
 134        .devtype    = MICROCHIP_DEV_TYPE,
 135        .atcaspi = {
 136            .bus = 0,
 137            .select_pin = 0,
 138            .baud = 16000000,
 139        },
 140        .wake_delay = 1500,
 141        .rx_retries = 20,
 142    },
 143#endif
 144#ifdef ATCA_HAL_I2C
 145    {
 146        .iface_type = ATCA_I2C_IFACE,
 147        .devtype    = MICROCHIP_DEV_TYPE,
 148        .atcai2c = {
 149            #ifdef ATCA_ENABLE_DEPRECATED
 150                .slave_address = ATECC_I2C_ADDR,
 151            #else
 152                .address = ATECC_I2C_ADDR,
 153            #endif
 154            .baud = 400000,
 155        },
 156        .wake_delay = 1500,
 157        .rx_retries = 20,
 158    },
 159#endif
 160#if !defined(WOLFSSL_MANUALLY_SELECT_DEVICE_CONFIG) && \
 161    !(defined(WOLFSSL_ATECC608A) && defined(MICROCHIP_MPLAB_HARMONY_3)) && \
 162    !defined(ATCA_HAL_SPI) && !defined(ATCA_HAL_I2C)
 163    {
 164        /* Custom HAL users provide callbacks later through
 165         * wolfCrypt_ATECC_SetConfig(), but gCfg still needs a valid default
 166         * backing object so configure-time warning builds do not see an empty
 167         * config array. */
 168        .iface_type = ATCA_CUSTOM_IFACE,
 169        .devtype    = MICROCHIP_DEV_TYPE,
 170        .wake_delay = 1500,
 171        .rx_retries = 20,
 172    },
 173#endif
 174};
 175static ATCAIfaceCfg* gCfg = &config_atmel_device[WOLFSSL_ATCA_DEVICE_NO];
 176
 177#if defined(WOLFSSL_MICROCHIP_TA100)
 178
 179
 180    /* TA100 device expects little-endian data for the property field.
 181     * On big-endian hosts, we need to byte-swap the uint16_t property value.
 182     * Use ATCA_UINT16_HOST_TO_LE if available from cryptoauthlib, otherwise
 183     * define our own based on wolfSSL's endianness detection.
 184     */
 185    #ifndef ATCA_UINT16_HOST_TO_LE
 186        #ifdef BIG_ENDIAN_ORDER
 187            #define ATCA_UINT16_HOST_TO_LE(x) \
 188                ((uint16_t)(((x) >> 8) | (((x) & 0xFF) << 8)))
 189        #else
 190            #define ATCA_UINT16_HOST_TO_LE(x) (x)
 191        #endif
 192    #endif
 193
 194    /* Helper function to fix property field endianness after
 195     * talib_handle_init_* functions populate the
 196     * ta_element_attributes_t structure.
 197     * The talib functions build the property value in host byte order, but
 198     * the TA100 device expects little-endian format.
 199     */
 200    static WC_INLINE void ta100_fix_property_endian(
 201        ta_element_attributes_t* attr)
 202    {
 203    #ifdef BIG_ENDIAN_ORDER
 204        if (attr != NULL) {
 205            attr->property = ATCA_UINT16_HOST_TO_LE(attr->property);
 206        }
 207    #else
 208        (void)attr; /* Suppress unused warning on little-endian */
 209    #endif
 210    }
 211
 212    /* The sharedData_attr property values need to be in LE format.
 213     * On little-endian: 0x1600 stays as 0x1600 (bytes: 00 16)
 214     * On big-endian:    0x1600 becomes 0x0016 (bytes: 00 16)
 215     *
 216     * Since we cannot use function calls in static initializers,
 217     * we define the values directly for each endianness:
 218     */
 219    #ifdef BIG_ENDIAN_ORDER
 220        /* Big-endian: swap bytes so wire format is correct */
 221        #define TA100_PROP_SHARED_DATA  0x0016
 222    #else
 223        /* Little-endian: use value as-is */
 224        #define TA100_PROP_SHARED_DATA  0x1600
 225    #endif
 226    #ifndef SHARED_DATA_ADDR
 227        #define SHARED_DATA_ADDR 0x8006
 228    #endif
 229        #define MAP_TO_HANDLE(value) (SHARED_DATA_ADDR + (value))
 230    /* TA100 uses separate handle range for symmetric keys (AES/HMAC) */
 231    #ifndef TA100_AES_HANDLE
 232        #define TA100_AES_HANDLE 0x8106
 233    #endif
 234#else
 235    #define MAP_TO_HANDLE(value) value
 236#endif
 237
 238#if defined(WOLFSSL_MICROCHIP_TA100)
 239/* TA_ElementAttributes contains data element attributes of the handle
 240 * which is of 8 byte
 241 *
 242 * typedef struct
 243 * {
 244 *     uint8_t  element_CKA;     -- contains class, key_type & Algorithm mode
 245 *     uint16_t property;        -- properties of the element
 246 *     uint8_t  usage_key;       -- usage key
 247 *     uint8_t  write_key;       -- write key
 248 *     uint8_t  read_key;        -- read key
 249 *     uint8_t  permission;      -- permission of the element usage|write|read|
 250 *                                  delete perm
 251 *     uint8_t  byte7_settings;  -- Byte 7 attributes use_count|exportable|
 252 *                                  lockable|access_limit
 253 * } ATCA_PACKED ta_element_attributes_t;
 254 *
 255 * See Shared Data Element Attributes in the programming specifications
 256 */
 257static ta_element_attributes_t sharedData_attr[ATECC_MAX_SLOT] = {
 258    {0x81, TA100_PROP_SHARED_DATA, 0x00, 0x00, 0x00, 0x41, 0x10},
 259    {0x81, TA100_PROP_SHARED_DATA, 0x00, 0x00, 0x00, 0x41, 0x10},
 260    {0x81, TA100_PROP_SHARED_DATA, 0x00, 0x00, 0x00, 0x41, 0x10},
 261    {0x81, TA100_PROP_SHARED_DATA, 0x00, 0x00, 0x00, 0x41, 0x10},
 262    {0x81, TA100_PROP_SHARED_DATA, 0x00, 0x00, 0x00, 0x41, 0x10},
 263    {0x81, TA100_PROP_SHARED_DATA, 0x00, 0x00, 0x00, 0x41, 0x10},
 264    {0x81, TA100_PROP_SHARED_DATA, 0x00, 0x00, 0x00, 0x41, 0x10},
 265    {0x81, TA100_PROP_SHARED_DATA, 0x00, 0x00, 0x00, 0x41, 0x10},
 266};
 267static ta_element_attributes_t* gSharedDataAttr = sharedData_attr;
 268
 269#endif /* WOLFSSL_MICROCHIP_TA100 */
 270#endif /* WOLFSSL_ATECC508A */
 271
 272/**
 273 * \brief Generate random number to be used for hash.
 274 */
 275int atmel_get_random_number(uint32_t count, uint8_t* rand_out)
 276{
 277    int ret = 0;
 278#if defined(WOLFSSL_ATECC508A) || defined(WOLFSSL_ATECC608A) || \
 279    defined(WOLFSSL_MICROCHIP_TA100)
 280    uint32_t i = 0;
 281    uint32_t copy_count = 0;
 282    uint8_t rng_buffer[RANDOM_NUM_SIZE];
 283
 284    if (rand_out == NULL) {
 285        return -1;
 286    }
 287
 288    while (i < count) {
 289        ret = atcab_random(rng_buffer);
 290        if (ret != ATCA_SUCCESS) {
 291            WOLFSSL_MSG("Failed to create random number!");
 292            return -1;
 293        }
 294        copy_count =
 295                (count - i > RANDOM_NUM_SIZE) ? RANDOM_NUM_SIZE : count - i;
 296        XMEMCPY(&rand_out[i], rng_buffer, copy_count);
 297        i += copy_count;
 298    }
 299#ifdef ATCAPRINTF
 300    atcab_printbin_label((const char*)"\r\nRandom Number", rand_out, count);
 301#endif
 302#else
 303    /* TODO: Use on-board TRNG */
 304#endif
 305    return ret;
 306}
 307
 308int atmel_get_random_block(unsigned char* output, unsigned int sz)
 309{
 310        return atmel_get_random_number((uint32_t)sz, (uint8_t*)output);
 311}
 312
 313#if defined(WOLFSSL_ATMEL) && defined(WOLFSSL_ATMEL_TIME)
 314#include "asf.h"
 315#include "rtc_calendar.h"
 316extern struct rtc_module *_rtc_instance[RTC_INST_NUM];
 317
 318long atmel_get_curr_time_and_date(long* tm)
 319{
 320    long rt = 0;
 321
 322        /* Get current time */
 323    struct rtc_calendar_time rtcTime;
 324    const int monthDay[] = {0,31,59,90,120,151,181,212,243,273,304,334};
 325    int month, year, yearLeap;
 326
 327        rtc_calendar_get_time(_rtc_instance[0], &rtcTime);
 328
 329    /* Convert rtc_calendar_time to seconds since UTC */
 330    month = rtcTime.month % 12;
 331    year =  rtcTime.year + rtcTime.month / 12;
 332    if (month < 0) {
 333        month += 12;
 334        year--;
 335    }
 336    yearLeap = (month > 1) ? year + 1 : year;
 337    rt = rtcTime.second
 338        + 60 * (rtcTime.minute
 339            + 60 * (rtcTime.hour
 340            + 24 * (monthDay[month] + rtcTime.day - 1
 341                + 365 * (year - 70)
 342                + (yearLeap - 69) / 4
 343                - (yearLeap - 1) / 100
 344                + (yearLeap + 299) / 400
 345                )
 346            )
 347        );
 348
 349    (void)tm;
 350    return rt;
 351}
 352#endif
 353
 354#if defined(WOLFSSL_MICROCHIP_TA100)
 355/* Set the Shared Data configuration for wolfSSL to use.
 356 *
 357 * Return 0 on success, negative upon error */
 358int wc_Microchip_SetSharedDataConfig(ta_element_attributes_t* cfg)
 359{
 360    WOLFSSL_MSG("Setting Shared Data configuration");
 361    if (cfg == NULL) {
 362        return -1;
 363    }
 364    /* copy configuration into our local struct */
 365    (void)XMEMMOVE(gSharedDataAttr, cfg,
 366                   sizeof(ta_element_attributes_t)*ATECC_MAX_SLOT);
 367
 368    ateccx08a_cfg_initialized = 0;
 369
 370    return 0;
 371}
 372
 373#endif
 374#if defined(WOLFSSL_ATECC508A) || defined(WOLFSSL_ATECC608A) || \
 375    defined(WOLFSSL_MICROCHIP_TA100)
 376
 377/* Set the ATECC configuration for wolfSSL to use.
 378 *
 379 * Return 0 on success, negative upon error */
 380int wolfCrypt_ATECC_SetConfig(ATCAIfaceCfg* cfg)
 381{
 382    WOLFSSL_MSG("Setting ATECC ATCAIfaceCfg configuration");
 383    if (cfg == NULL) {
 384        return -1;
 385    }
 386    /* Copy the full configuration into the active local device slot so
 387     * non-I2C interface unions (for example ATCA_CUSTOM_IFACE callbacks)
 388     * remain intact. */
 389    XMEMCPY(gCfg, cfg, sizeof(*gCfg));
 390
 391    ateccx08a_cfg_initialized = 0;
 392
 393    return 0;
 394}
 395
 396int atmel_ecc_translate_err(int status)
 397{
 398    switch (status) {
 399        case ATCA_SUCCESS:
 400            return 0;
 401        case ATCA_BAD_PARAM:
 402            return BAD_FUNC_ARG;
 403        case ATCA_ALLOC_FAILURE:
 404            return MEMORY_E;
 405        default:
 406        #ifdef WOLFSSL_ATECC_DEBUG
 407            printf("ATECC Failure: %x\n", (word32)status);
 408        #endif
 409            break;
 410    }
 411    return WC_HW_E;
 412}
 413
 414/* Function to set the slotId allocator and deallocator */
 415WOLFSSL_API int atmel_set_slot_allocator(atmel_slot_alloc_cb alloc,
 416                             atmel_slot_dealloc_cb dealloc)
 417{
 418#ifndef SINGLE_THREADED
 419    wc_LockMutex(&mSlotMutex);
 420#endif
 421    mSlotAlloc = alloc;
 422    mSlotDealloc = dealloc;
 423#ifndef SINGLE_THREADED
 424    wc_UnLockMutex(&mSlotMutex);
 425#endif
 426    return 0;
 427}
 428
 429/* Function to allocate new slotId number */
 430int atmel_ecc_alloc(int slotType)
 431{
 432    int slotId = ATECC_INVALID_SLOT, i;
 433
 434#ifndef SINGLE_THREADED
 435    wc_LockMutex(&mSlotMutex);
 436#endif
 437
 438    if (mSlotAlloc) {
 439        slotId = mSlotAlloc(slotType);
 440    }
 441    else {
 442        switch (slotType) {
 443            case ATMEL_SLOT_ENCKEY:
 444                /* not reserved in mSlotList, so return */
 445                slotId = ATECC_SLOT_I2C_ENC;
 446                goto exit;
 447            case ATMEL_SLOT_DEVICE:
 448                /* not reserved in mSlotList, so return */
 449                slotId = ATECC_SLOT_AUTH_PRIV;
 450                goto exit;
 451            case ATMEL_SLOT_ECDHE:
 452                slotId = ATECC_SLOT_ECDHE_PRIV;
 453            #ifdef WOLFSSL_ATECC_TNGTLS
 454                /* not reserved in mSlotList, so return */
 455                goto exit;
 456            #else
 457                break;
 458            #endif
 459            case ATMEL_SLOT_ECDHE_ENC:
 460                slotId = ATECC_SLOT_ENC_PARENT;
 461            #ifdef WOLFSSL_ATECC_TNGTLS
 462                /* not reserved in mSlotList, so return */
 463                goto exit;
 464            #else
 465                break;
 466            #endif
 467            case ATMEL_SLOT_ECDHE_ALICE:
 468                /* reserve the fixed slot through the common allocation path */
 469                slotId = ATECC_SLOT_ECDHE_PRIV_ALICE;
 470                break;
 471            case ATMEL_SLOT_ECDHE_BOB:
 472                /* reserve the fixed slot through the common allocation path */
 473                slotId = ATECC_SLOT_ECDHE_PRIV_BOB;
 474                break;
 475            case ATMEL_SLOT_ANY:
 476                for (i=0; i < ATECC_MAX_SLOT; i++) {
 477                    /* Find free slotId */
 478                    if (mSlotList[i] == ATECC_INVALID_SLOT) {
 479                        slotId = i;
 480                        break;
 481                    }
 482                }
 483                if (slotId == ATECC_INVALID_SLOT) {
 484                    goto exit;
 485                }
 486                break;
 487            default:
 488                goto exit;
 489        }
 490
 491        /* is slot available */
 492        if (mSlotList[slotId] != ATECC_INVALID_SLOT) {
 493            slotId = ATECC_INVALID_SLOT;
 494        }
 495        else {
 496            mSlotList[slotId] = slotId;
 497        }
 498    }
 499
 500exit:
 501#ifndef SINGLE_THREADED
 502    wc_UnLockMutex(&mSlotMutex);
 503#endif
 504
 505    return slotId;
 506}
 507
 508
 509/* Function to return slotId number to available list */
 510void atmel_ecc_free(int slotId)
 511{
 512#ifndef SINGLE_THREADED
 513    wc_LockMutex(&mSlotMutex);
 514#endif
 515    if (mSlotDealloc) {
 516        mSlotDealloc(slotId);
 517    }
 518    else if (slotId >= 0 && slotId < ATECC_MAX_SLOT) {
 519        if (slotId != ATECC_SLOT_AUTH_PRIV && slotId != ATECC_SLOT_I2C_ENC
 520#ifdef WOLFSSL_ATECC_TNGTLS
 521            && slotId != ATMEL_SLOT_ECDHE_ENC
 522#endif
 523           ) {
 524            /* Mark slotId free */
 525            mSlotList[slotId] = ATECC_INVALID_SLOT;
 526        }
 527    }
 528#ifndef SINGLE_THREADED
 529    wc_UnLockMutex(&mSlotMutex);
 530#endif
 531}
 532
 533
 534/**
 535 * \brief Callback function for getting the current encryption key
 536 */
 537int atmel_get_enc_key_default(byte* enckey, word16 keysize)
 538{
 539    if (enckey == NULL || keysize != ATECC_KEY_SIZE) {
 540        return BAD_FUNC_ARG;
 541    }
 542
 543    XMEMSET(enckey, 0xFF, keysize); /* use default value */
 544
 545    return 0;
 546}
 547
 548/**
 549 * \brief Write enc key before.
 550 */
 551#if defined(WOLFSSL_ATECC_ECDH_ENC) || defined(WOLFSSL_ATECC_ECDH_IOENC)
 552static int atmel_init_enc_key(void)
 553{
 554    int ret;
 555        uint8_t read_key[ATECC_KEY_SIZE];
 556    uint8_t writeBlock = 0;
 557    uint8_t writeOffset = 0;
 558    int slotId;
 559    bool isLocked = false;
 560
 561    slotId = atmel_ecc_alloc(ATMEL_SLOT_ENCKEY);
 562
 563    /* check for encryption key slotId */
 564    if (slotId == ATECC_INVALID_SLOT)
 565        return BAD_FUNC_ARG;
 566
 567    /* skip if slot has already been locked */
 568    ret = atcab_is_slot_locked(slotId, &isLocked);
 569    if (ret != ATCA_SUCCESS) {
 570        return atmel_ecc_translate_err(ret);
 571
 572    } else if (isLocked) {
 573        return 0;
 574    }
 575
 576    /* get encryption key */
 577    ATECC_GET_ENC_KEY(read_key, sizeof(read_key));
 578
 579    ret = atcab_write_zone(ATCA_ZONE_DATA, slotId, writeBlock, writeOffset,
 580        read_key, ATCA_BLOCK_SIZE);
 581    ForceZero(read_key, sizeof(read_key));
 582    ret = atmel_ecc_translate_err(ret);
 583
 584        return ret;
 585}
 586#endif
 587
 588int atmel_get_rev_info(word32* revision)
 589{
 590    int ret;
 591#ifdef WOLFSSL_ATECC_DEBUG
 592    WOLFSSL_MSG("Waking device...");
 593#endif
 594    ret = atcab_wakeup();
 595    if (ret != ATCA_SUCCESS) {
 596#ifdef WOLFSSL_ATECC_DEBUG
 597        WOLFSSL_MSG("atcab_wakeup failed");
 598#endif
 599        return atmel_ecc_translate_err(ret);
 600    }
 601    ret = atcab_info((uint8_t*)revision);
 602    ret = atmel_ecc_translate_err(ret);
 603    return ret;
 604}
 605
 606void atmel_show_rev_info(void)
 607{
 608#ifdef WOLFSSL_ATECC_DEBUG
 609    word32 revision = 0;
 610    atmel_get_rev_info(&revision);
 611    printf("ATECC608 Revision: %x\n", (word32)revision);
 612#endif
 613}
 614
 615#ifdef HAVE_ECC
 616int atmel_ecc_create_pms(int slotId, const uint8_t* peerKey, uint8_t* pms)
 617{
 618    int ret;
 619    uint8_t read_key[ATECC_KEY_SIZE];
 620
 621#ifdef WOLFSSL_ATECC_ECDH_ENC
 622    int slotIdEnc;
 623
 624    slotIdEnc = atmel_ecc_alloc(ATMEL_SLOT_ECDHE_ENC);
 625    if (slotIdEnc == ATECC_INVALID_SLOT)
 626        return BAD_FUNC_ARG;
 627#endif
 628
 629    /* get encryption key */
 630    ATECC_GET_ENC_KEY(read_key, sizeof(read_key));
 631
 632#ifdef WOLFSSL_ATECC_ECDH_ENC
 633    #ifdef WOLFSSL_MICROCHIP_TA100
 634        /* TA100 ECDH uses the ephemeral private-key slot; the encryption
 635         * parent slot is allocated above only for parity with the
 636         * non-TA100 atcab_ecdh_enc path and is not consumed here. */
 637        (void)slotIdEnc;
 638        ret = talib_ecdh_compat(atcab_get_device(), MAP_TO_HANDLE(slotId),
 639                                peerKey, pms);
 640    #else
 641        /* send the encrypted version of the ECDH command */
 642        ret = atcab_ecdh_enc(MAP_TO_HANDLE(slotId), peerKey, pms, read_key,
 643                                           MAP_TO_HANDLE(slotIdEnc));
 644    #endif
 645#elif defined(WOLFSSL_ATECC_ECDH_IOENC)
 646    /* encrypted ECDH command, using I/O protection key */
 647    ret = atcab_ecdh_ioenc(MAP_TO_HANDLE(slotId), peerKey, pms, read_key);
 648#else
 649    ret = atcab_ecdh(MAP_TO_HANDLE(slotId), peerKey, pms);
 650#endif
 651
 652    ret = atmel_ecc_translate_err(ret);
 653    ForceZero(read_key, sizeof(read_key));
 654#ifdef WOLFSSL_ATECC_ECDH_ENC
 655    /* free the ECDHE slot */
 656    atmel_ecc_free(slotIdEnc);
 657#endif
 658    return ret;
 659}
 660#ifdef WOLFSSL_MICROCHIP_TA100
 661static uint8_t getCurveType(int curve_id)
 662{
 663    switch(curve_id)
 664    {
 665        case ECC_SECP256R1: return TA_KEY_TYPE_ECCP256;
 666        case ECC_SECP224R1: return TA_KEY_TYPE_ECCP224;
 667        case ECC_SECP384R1: return TA_KEY_TYPE_ECCP384;
 668        case ECC_SECP256K1: return TA_KEY_TYPE_SECP256K1;
 669        case ECC_BRAINPOOLP256R1: return TA_KEY_TYPE_ECCBP256R1;
 670        case ECC_CURVE_DEF: return TA_KEY_TYPE_ECCP256; /* default */
 671        default: WOLFSSL_MSG("Curve not identified");
 672            return MICROCHIP_INVALID_ECC;
 673    }
 674}
 675#endif /* WOLFSSL_MICROCHIP_TA100 */
 676
 677#ifdef WOLFSSL_MICROCHIP_TA100
 678static int getCurveSizeBytes(int curve_id)
 679{
 680    switch (curve_id) {
 681        case ECC_SECP224R1: return 28;
 682        case ECC_SECP256R1: return 32;
 683        case ECC_SECP384R1: return 48;
 684        case ECC_SECP256K1: return 32;
 685        case ECC_BRAINPOOLP256R1: return 32;
 686        case ECC_CURVE_DEF: return 32;
 687        default: return -1;
 688    }
 689}
 690#endif /* WOLFSSL_MICROCHIP_TA100 */
 691int atmel_ecc_create_key(int slotId, int curve_id, byte* peerKey)
 692{
 693    int ret;
 694#ifndef WOLFSSL_MICROCHIP_TA100
 695    (void)curve_id;
 696#endif
 697    /* verify provided slotId */
 698    if (slotId == ATECC_INVALID_SLOT) {
 699        return WC_HW_WAIT_E;
 700    }
 701#ifdef WOLFSSL_MICROCHIP_TA100
 702
 703    if (getCurveType(curve_id) == MICROCHIP_INVALID_ECC)
 704        return NOT_COMPILED_IN;
 705
 706#endif
 707    /* generate new ephemeral key on device */
 708#ifdef WOLFSSL_MICROCHIP_TA100
 709    #if defined(TA100_ECC_TRACE)
 710    printf("[TA100] atmel_ecc_create_key: slot=%d curve_id=%d "
 711        "curve_size=%d curve_type=%d\r\n",
 712        slotId, curve_id, getCurveSizeBytes(curve_id),
 713        getCurveType(curve_id));
 714#endif
 715    {
 716        ATCA_STATUS status;
 717        ta_element_attributes_t key_attr;
 718        uint8_t is_valid = 0;
 719        int curve_size = getCurveSizeBytes(curve_id);
 720        int curve_type = getCurveType(curve_id);
 721        size_t pubkey_len = (size_t)(curve_size * 2);
 722
 723        if (curve_size <= 0 || curve_type == MICROCHIP_INVALID_ECC)
 724            return NOT_COMPILED_IN;
 725
 726        status = talib_is_handle_valid(atcab_get_device(),
 727            (uint32_t)MAP_TO_HANDLE(slotId), &is_valid);
 728        if (status == ATCA_SUCCESS && is_valid == 0x01) {
 729            status = talib_delete_handle(atcab_get_device(),
 730                (uint32_t)MAP_TO_HANDLE(slotId));
 731        }
 732        if (status != ATCA_SUCCESS)
 733            return atmel_ecc_translate_err(status);
 734
 735        status = talib_handle_init_private_key(&key_attr,
 736            (uint8_t)curve_type, TA_ALG_MODE_ECC_ECDSA,
 737            TA_PROP_SIGN_INT_EXT_DIGEST, TA_PROP_KEY_AGREEMENT_OUT_BUFF);
 738        if (status != ATCA_SUCCESS)
 739            return atmel_ecc_translate_err(status);
 740
 741        ta100_fix_property_endian(&key_attr);
 742        status = talib_create_element_with_handle(atcab_get_device(),
 743            (uint32_t)MAP_TO_HANDLE(slotId), &key_attr);
 744        if (status != ATCA_SUCCESS)
 745            return atmel_ecc_translate_err(status);
 746
 747        status = talib_genkey_base(atcab_get_device(), TA_KEYGEN_MODE_NEWKEY,
 748            (uint32_t)MAP_TO_HANDLE(slotId), peerKey, &pubkey_len);
 749        #if defined(TA100_ECC_TRACE)
 750        printf("[TA100] atmel_ecc_create_key: "
 751            "genkey status=%d pubkey_len=%u\r\n",
 752            status, (unsigned)pubkey_len);
 753#endif
 754        return atmel_ecc_translate_err(status);
 755    }
 756#endif
 757
 758    ret = atcab_genkey(MAP_TO_HANDLE(slotId), peerKey);
 759    return atmel_ecc_translate_err(ret);
 760}
 761
 762int atmel_ecc_sign(int slotId, const byte* message, byte* signature)
 763{
 764    int ret;
 765#ifndef WC_ALLOW_ECC_ZERO_HASH
 766    byte hashIsZero = 0;
 767    word32 zIdx;
 768
 769    /* defensive sanity check on all 0's hash */
 770    for (zIdx = 0; zIdx < ATECC_KEY_SIZE; zIdx++)
 771        hashIsZero |= message[zIdx];
 772    if (hashIsZero == 0)
 773        return ECC_BAD_ARG_E;
 774#endif
 775
 776    ret = atcab_sign(MAP_TO_HANDLE(slotId), message, signature);
 777    ret = atmel_ecc_translate_err(ret);
 778    return ret;
 779}
 780
 781int atmel_ecc_verify(const byte* message, const byte* signature,
 782    const byte* pubkey, int* pVerified)
 783{
 784    int ret;
 785    bool verified = false;
 786
 787    ret = atcab_verify_extern(message, signature, pubkey, &verified);
 788    ret = atmel_ecc_translate_err(ret);
 789    if (pVerified)
 790        *pVerified = (int)verified;
 791    return ret;
 792}
 793
 794#ifdef WOLFSSL_MICROCHIP_TA100
 795int atmel_ecc_sign_ex(int slotId, int curve_id, const byte* message,
 796    word32 message_len, byte* signature)
 797{
 798    int ret;
 799    int curve_size = getCurveSizeBytes(curve_id);
 800    int curve_type = getCurveType(curve_id);
 801    uint16_t sign_size;
 802    const byte* msg = message;
 803    uint16_t msg_len;
 804    byte tmp_msg[TA_SIGN_P384_MSG_SIZE];
 805    byte tmp_sig[TA_SIGN_P384_SIG_SIZE];
 806
 807    if (curve_size <= 0 || curve_type == MICROCHIP_INVALID_ECC)
 808        return NOT_COMPILED_IN;
 809
 810    sign_size = (uint16_t)(curve_size * 2);
 811    if (sign_size > sizeof(tmp_sig))
 812        return BAD_FUNC_ARG;
 813    msg_len = (uint16_t)message_len;
 814    if (msg_len != (uint16_t)curve_size) {
 815        if (msg_len > (uint16_t)curve_size) {
 816            msg_len = (uint16_t)curve_size;
 817        } else {
 818            XMEMSET(tmp_msg, 0, (word32)curve_size);
 819            XMEMCPY(tmp_msg + (curve_size - msg_len), message, msg_len);
 820            msg = tmp_msg;
 821            msg_len = (uint16_t)curve_size;
 822        }
 823    }
 824    #if defined(TA100_ECC_TRACE)
 825    printf("[TA100] atmel_ecc_sign_ex: curve_size=%d msg_len=%u\r\n",
 826        curve_size, (unsigned)msg_len);
 827    #endif
 828    ret = talib_sign_external(atcab_get_device(), (uint8_t)curve_type,
 829        MAP_TO_HANDLE(slotId), TA_HANDLE_INPUT_BUFFER, msg,
 830        msg_len, tmp_sig, &sign_size);
 831
 832    if (ret != ATCA_SUCCESS)
 833        return atmel_ecc_translate_err(ret);
 834
 835    /* Always return raw R||S, each padded to curve size */
 836    XMEMSET(signature, 0, (word32)(curve_size * 2));
 837    if (sign_size == (uint16_t)(curve_size * 2)) {
 838        XMEMCPY(signature, tmp_sig, sign_size);
 839    }
 840    else if ((sign_size % 2) == 0 && sign_size < (uint16_t)(curve_size * 2)) {
 841        uint16_t half = (uint16_t)(sign_size / 2);
 842        if (half > (uint16_t)curve_size)
 843            return BAD_FUNC_ARG;
 844        XMEMCPY(signature + (curve_size - half), tmp_sig, half);
 845        XMEMCPY(signature + curve_size + (curve_size - half),
 846            tmp_sig + half, half);
 847    }
 848    else {
 849        return ASN_PARSE_E;
 850    }
 851
 852    return 0;
 853}
 854
 855int atmel_ecc_verify_ex(const byte* message, word32 message_len,
 856    const byte* signature, const byte* pubkey, word32 pubkey_len,
 857    int curve_id, int* pVerified)
 858{
 859    int ret;
 860    int curve_size = getCurveSizeBytes(curve_id);
 861    int curve_type = getCurveType(curve_id);
 862    uint16_t sig_len;
 863    const byte* msg = message;
 864    uint16_t msg_len;
 865    byte tmp_msg[TA_VERIFY_P384_MSG_SIZE];
 866    bool verified = false;
 867
 868    if (curve_size <= 0 || curve_type == MICROCHIP_INVALID_ECC)
 869        return NOT_COMPILED_IN;
 870
 871    sig_len = (uint16_t)(curve_size * 2);
 872    msg_len = (uint16_t)message_len;
 873    if (msg_len != (uint16_t)curve_size) {
 874        if (msg_len > (uint16_t)curve_size) {
 875            msg_len = (uint16_t)curve_size;
 876        } else {
 877            XMEMSET(tmp_msg, 0, (word32)curve_size);
 878            XMEMCPY(tmp_msg + (curve_size - msg_len), message, msg_len);
 879            msg = tmp_msg;
 880            msg_len = (uint16_t)curve_size;
 881        }
 882    }
 883    #if defined(TA100_ECC_TRACE)
 884    printf("[TA100] atmel_ecc_verify_ex: curve_size=%d msg_len=%u\r\n",
 885        curve_size, (unsigned)msg_len);
 886    #endif
 887    ret = talib_verify(atcab_get_device(), (uint8_t)curve_type,
 888        TA_HANDLE_INPUT_BUFFER, TA_HANDLE_INPUT_BUFFER, signature, sig_len,
 889        msg, msg_len, pubkey, (uint16_t)pubkey_len,
 890        &verified);
 891
 892    ret = atmel_ecc_translate_err(ret);
 893    if (pVerified)
 894        *pVerified = (int)verified;
 895    return ret;
 896}
 897#endif /* WOLFSSL_MICROCHIP_TA100 */
 898
 899#endif /* HAVE_ECC */
 900#endif /* WOLFSSL_ATECC508A || WOLFSSL_ATECC608A || WOLFSSL_MICROCHIP_TA100 */
 901
 902#ifdef WOLFSSL_MICROCHIP_TA100
 903
 904#ifndef NO_RSA
 905/*
 906 * TA100 RSA Support - Sign/Verify AND Encrypt/Decrypt
 907 *
 908*/
 909
 910int wc_Microchip_rsa_create_key(struct RsaKey* key, int size, long e)
 911{
 912    ATCA_STATUS ret;
 913    ta_element_attributes_t rKeyA, uKeyA;
 914    size_t uKey_len = WOLFSSL_TA_KEY_TYPE_RSA_SIZE;
 915
 916    if (key == NULL) {
 917        return BAD_FUNC_ARG;
 918    }
 919    if (size != (int)(WOLFSSL_TA_KEY_TYPE_RSA_SIZE * 8U)) {
 920        return BAD_FUNC_ARG;
 921    }
 922    if (e != 0 && e != WC_RSA_EXPONENT) {
 923        return BAD_FUNC_ARG;
 924    }
 925
 926    /* Private key for signing AND decryption */
 927    ret = talib_handle_init_private_key(&rKeyA, WOLFSSL_TA_KEY_TYPE_RSA,
 928            TA_ALG_MODE_RSA_SSA_PSS, TA_PROP_SIGN_INT_EXT_DIGEST,
 929            TA_PROP_KEY_AGREEMENT_OUT_BUFF);
 930    if (ret != ATCA_SUCCESS)
 931        return WC_HW_E;
 932
 933    ta100_fix_property_endian(&rKeyA);
 934
 935    ret = talib_create_element(atcab_get_device(), &rKeyA, &key->rKeyH);
 936    if (ret != ATCA_SUCCESS)
 937        return WC_HW_E;
 938
 939    /* Public key - use 0, 0 for encryption support! */
 940    ret = talib_handle_init_public_key(&uKeyA, WOLFSSL_TA_KEY_TYPE_RSA,
 941            TA_ALG_MODE_RSA_SSA_PSS, 0, 0);
 942    if (ret != ATCA_SUCCESS)
 943        goto err_free_r;
 944
 945    ta100_fix_property_endian(&uKeyA);
 946
 947    ret = talib_create_element(atcab_get_device(), &uKeyA, &key->uKeyH);
 948    if (ret != ATCA_SUCCESS)
 949        goto err_free_r;
 950
 951    ret = talib_genkey_base(atcab_get_device(), TA_KEYGEN_MODE_NEWKEY,
 952            (uint32_t)key->rKeyH, key->uKey, &uKey_len);
 953    if (ret != ATCA_SUCCESS)
 954        goto err_free_ru;
 955
 956    /* Use talib_write_element, not talib_write_pub_key */
 957    ret = talib_write_element(atcab_get_device(), key->uKeyH,
 958            (uint16_t)uKey_len, key->uKey);
 959    if (ret != ATCA_SUCCESS)
 960        goto err_free_ru;
 961
 962    return atmel_ecc_translate_err(ret);
 963
 964err_free_ru:
 965    (void)talib_delete_handle(atcab_get_device(), (uint32_t)key->uKeyH);
 966    key->uKeyH = 0;
 967err_free_r:
 968    (void)talib_delete_handle(atcab_get_device(), (uint32_t)key->rKeyH);
 969    key->rKeyH = 0;
 970    return WC_HW_E;
 971}
 972
 973int wc_Microchip_rsa_encrypt(const byte* in, word32 inLen, byte* out,
 974                             word32 outLen, RsaKey* key)
 975{
 976    int ret;
 977
 978#ifdef WOLFSSL_ATECC_DEBUG
 979    printf("WOLFSSL_TA_KEY_TYPE_RSA = %d\n", WOLFSSL_TA_KEY_TYPE_RSA);
 980    printf("TA_KEY_TYPE_RSA2048 = %d\n", TA_KEY_TYPE_RSA2048);
 981    printf("=== talib_rsaenc_encrypt debug ===\n");
 982    printf("device: %p\n", atcab_get_device());
 983    printf("uKeyH: 0x%08X (%u)\n", key->uKeyH, key->uKeyH);
 984    printf("inLen: %u\n", inLen);
 985    printf("in: %p\n", in);
 986    printf("outLen: %u\n", outLen);
 987    printf("out: %p\n", out);
 988#endif
 989    /* The current wolfSSL TA100 backend uses the RSA-2048 RSAEnc path. */
 990    ret = talib_rsaenc_encrypt2048(atcab_get_device(), key->uKeyH,
 991                                   (uint16_t)inLen, in,
 992                                   (uint16_t)outLen, out);
 993
 994    return atmel_ecc_translate_err(ret);
 995}
 996
 997int wc_Microchip_rsa_decrypt(const byte* in, word32 inLen, byte* out,
 998                             word32 outLen, RsaKey* key)
 999{
1000    int ret;
1001
1002    /* The current wolfSSL TA100 backend uses the RSA-2048 RSAEnc path. */
1003    ret = talib_rsaenc_decrypt2048(atcab_get_device(), key->rKeyH,
1004                                   (uint16_t)inLen, in,
1005                                   (uint16_t)outLen, out);
1006
1007    return atmel_ecc_translate_err(ret);
1008}
1009
1010
1011int wc_Microchip_rsa_sign(const byte* in, word32 inLen,
1012                          byte* out, word32 outLen, RsaKey* key)
1013{
1014    int ret;
1015    uint16_t sign_size = (uint16_t)outLen;
1016
1017    if (in == NULL || out == NULL || key == NULL) {
1018        return BAD_FUNC_ARG;
1019    }
1020
1021    /* TA100 expects a digest for RSA sign. */
1022    if (inLen != WC_SHA256_DIGEST_SIZE) {
1023        return BAD_FUNC_ARG;
1024    }
1025
1026    /* Sign using the signing private key handle */
1027    ret = talib_sign_external(atcab_get_device(),
1028                              (uint8_t)(TA_SIGN_MODE_EXTERNAL_MSG |
1029                                        WOLFSSL_TA_KEY_TYPE_RSA),
1030                              key->rKeyH, TA_HANDLE_INPUT_BUFFER, in,
1031                              (uint16_t)inLen, out, &sign_size);
1032
1033    ret = atmel_ecc_translate_err(ret);
1034    if (ret == 0) {
1035        return (int)sign_size;
1036    }
1037    return ret;
1038}
1039
1040
1041int wc_Microchip_rsa_verify(const byte* in, word32 inLen,
1042                            byte* sig, word32 sigLen,
1043                            RsaKey* key, int* pVerified)
1044{
1045    int ret;
1046    bool verified = false;
1047
1048    if (in == NULL || sig == NULL || key == NULL) {
1049        return BAD_FUNC_ARG;
1050    }
1051
1052    /* TA100 expects a digest for RSA verify. */
1053    if (inLen != WC_SHA256_DIGEST_SIZE) {
1054        return BAD_FUNC_ARG;
1055    }
1056
1057    /* Verify using the verification public key handle */
1058    ret = talib_verify(atcab_get_device(), WOLFSSL_TA_KEY_TYPE_RSA,
1059                       TA_HANDLE_INPUT_BUFFER, key->uKeyH, sig,
1060                       sigLen, in, (uint16_t)inLen, NULL,
1061                       sigLen, &verified);
1062
1063    ret = atmel_ecc_translate_err(ret);
1064
1065    if (pVerified != NULL) {
1066        *pVerified = (int)verified;
1067    }
1068
1069    return ret;
1070}
1071
1072
1073void wc_Microchip_rsa_free(struct RsaKey* key)
1074{
1075    if (key == NULL) {
1076        return;
1077    }
1078
1079    /* Free signing/encryption key handles */
1080    if (key->rKeyH) {
1081        (void)talib_delete_handle(atcab_get_device(), (uint32_t)key->rKeyH);
1082        key->rKeyH = 0;
1083    }
1084    if (key->uKeyH) {
1085        (void)talib_delete_handle(atcab_get_device(), (uint32_t)key->uKeyH);
1086        key->uKeyH = 0;
1087    }
1088}
1089
1090#endif /* NO_RSA */
1091
1092#ifdef WOLFSSL_ATECC_DEBUG
1093static void atmel_print_info(ta_element_attributes_t attr)
1094{
1095    printf("{0x%02x, 0x%04x, 0x%02x, 0x%02x, 0x%02x, 0x%02x, 0x%02x},\n",
1096            attr.element_CKA, attr.property, attr.usage_key, attr.write_key,
1097            attr.read_key, attr.permission , attr.byte7_settings);
1098}
1099
1100static void atmel_Handle_Attributes(void)
1101{
1102    ATCA_STATUS status;
1103    ta_element_attributes_t attributes;
1104    (void) status;
1105
1106    printf("Symmetric key AES \n"
1107           "Symmetric key HMAC \n"
1108           "Public key ECC \n"
1109           "Public key RSA \n"
1110           "Private key ECC - sign \n"
1111           "Private key ECC - keygen \n");
1112    status = talib_handle_init_symmetric_key(&attributes, TA_KEY_TYPE_AES128,
1113                                             TA_PROP_SYMM_KEY_USAGE_ANY);
1114
1115    /* Symmetric key AES */
1116    atmel_print_info(attributes);
1117
1118    status = talib_handle_init_symmetric_key(&attributes, TA_KEY_TYPE_HMAC,
1119                                             TA_PROP_SYMM_KEY_USAGE_MAC);
1120    /* Symmetric key HMAC */
1121    atmel_print_info(attributes);
1122
1123    status = talib_handle_init_public_key(&attributes, TA_KEY_TYPE_ECCP256,
1124                       TA_ALG_MODE_ECC_ECDSA, TA_PROP_VAL_NO_SECURE_BOOT_SIGN,
1125                       TA_PROP_ROOT_PUB_KEY_VERIFY);
1126
1127    /* Public key ECC */
1128    atmel_print_info(attributes);
1129
1130    status = talib_handle_init_public_key(&attributes, WOLFSSL_TA_KEY_TYPE_RSA,
1131                    TA_ALG_MODE_RSA_SSA_PSS, TA_PROP_VAL_NO_SECURE_BOOT_SIGN,
1132                    TA_PROP_ROOT_PUB_KEY_VERIFY);
1133    /* Public key RSA */
1134    atmel_print_info(attributes);
1135
1136    status = talib_handle_init_private_key(&attributes, TA_KEY_TYPE_ECCP256,
1137                              TA_ALG_MODE_ECC_ECDH, TA_PROP_SIGN_INT_EXT_DIGEST,
1138                              TA_PROP_KEY_AGREEMENT_OUT_BUFF);
1139
1140    /* Private key ECC - sign */
1141    atmel_print_info(attributes);
1142
1143    /* Byte 0 Element Attribute */
1144    attributes.element_CKA = TA_CLASS_PRIVATE_KEY |
1145            (uint8_t)(TA_KEY_TYPE_ECCP256 << TA_HANDLE_INFO_KEY_TYPE_SHIFT) |
1146            (uint8_t)(TA_ALG_MODE_ECC_ECDSA << TA_HANDLE_INFO_ALG_MODE_SHIFT);
1147
1148    attributes.property = (uint16_t)0x00 /*Public Key Handle*/ |
1149            (uint16_t)(0x00 << TA_PROP_SESSION_KEY_SHIFT) |
1150    (uint16_t)(0x00 << TA_PROP_KEY_GEN_SHIFT) |
1151    (uint16_t)(TA_PROP_SIGN_INT_EXT_DIGEST << TA_PROP_SIGN_USE_SHIFT) |
1152    (uint16_t)(TA_PROP_NO_KEY_AGREEMENT << TA_PROP_KEY_AGREEMENT_SHIFT);
1153
1154    /* Byte 3 Element Attribute */
1155    attributes.usage_key = 0x00;
1156
1157    /* Byte 4 Element Attribute */
1158    attributes.write_key = 0x00;
1159
1160    /* Byte 5 Element Attribute */
1161    attributes.read_key = 0x00;
1162
1163    /* Byte 6 Element Attribute */
1164    attributes.permission = TA_PERM_USAGE(TA_PERM_ALWAYS) |
1165            TA_PERM_WRITE(TA_PERM_ALWAYS)| TA_PERM_READ(TA_PERM_ALWAYS) |
1166            TA_PERM_DELETE(TA_PERM_ALWAYS);
1167
1168    /* Byte 7  Element Attribute */
1169    attributes.byte7_settings = ((0x00 & 0x03) << 0) /*Use Count*/ |
1170        TA_NOT_EXPORTABLE_FROM_CHIP_MASK | TA_PERMANENTLY_NOT_LOCKABLE_MASK |
1171    TA_ACCESS_LIMIT_ALWAYS_MASK | (0 << 7) /*Intrusion Detection (N/A here)*/;
1172
1173     /* Private key ECC - keygen */
1174    atmel_print_info(attributes);
1175
1176}
1177#endif
1178
1179#ifdef WOLFSSL_ATECC_DEBUG
1180    #define CHECK_STATUS(s)                                                    \
1181        if ((s) != ATCA_SUCCESS) {                                             \
1182            WOLFSSL_MSG("TA100 Error");                                        \
1183            printf("Error: Line %d in File %s\r\n", __LINE__, __FILE__);       \
1184            printf("STATUS = %X\r\n", (unsigned int)(s));                      \
1185            return atmel_ecc_translate_err(s);                                 \
1186        }
1187#else
1188    #define CHECK_STATUS(s)                                                    \
1189        if ((s) != ATCA_SUCCESS) {                                             \
1190            return atmel_ecc_translate_err(s);                                 \
1191        }
1192#endif
1193static int atmel_createHandles(void)
1194{
1195    ATCA_STATUS status;
1196    uint8_t is_handle_valid = 0;
1197    uint16_t shared_handle = SHARED_DATA_ADDR;
1198    int i;
1199#ifdef WOLFSSL_ATECC_DEBUG
1200    atmel_Handle_Attributes();
1201    WOLFSSL_MSG("atmel_Handle_Attributes() finished");
1202    WOLFSSL_MSG("createHandles starting");
1203#endif
1204    for (i = 0; i < ATECC_MAX_SLOT; i++ ) {
1205
1206        status = talib_is_handle_valid(atcab_get_device(),
1207                                 (uint32_t)shared_handle, &is_handle_valid);
1208        CHECK_STATUS(status);
1209#ifdef WOLFSSL_ATECC_DEBUG
1210        atmel_print_info(gSharedDataAttr[i]);
1211#endif
1212        if(is_handle_valid == 0x01) {
1213            /* Handle already Exists */;
1214#ifndef WOLFSSL_NO_DEL_HANDLE
1215            status = talib_delete_handle(atcab_get_device(),
1216                                    (uint32_t)shared_handle);
1217            CHECK_STATUS(status);
1218#else
1219            shared_handle += 1;
1220            continue;
1221#endif
1222        }
1223
1224        status = talib_create_element_with_handle(atcab_get_device(),
1225                shared_handle, &gSharedDataAttr[i]);
1226        CHECK_STATUS(status);
1227        shared_handle += 1;
1228    }
1229#ifdef WOLFSSL_ATECC_DEBUG
1230    WOLFSSL_MSG("createHandles done");
1231#endif
1232    return 0;
1233}
1234#endif /* WOLFSSL_MICROCHIP_TA100 */
1235
1236int atmel_init(void)
1237{
1238    int ret = 0;
1239
1240#if defined(WOLFSSL_ATECC508A) || defined(WOLFSSL_ATECC608A) || \
1241    defined(WOLFSSL_MICROCHIP_TA100)
1242
1243#if defined(WOLFSSL_ATECC608A)
1244    /*Harmony3 will generate configuration based on user inputs*/
1245    #ifdef MICROCHIP_MPLAB_HARMONY_3
1246    extern ATCAIfaceCfg atecc608_0_init_data;
1247    #endif
1248#endif
1249
1250    if (!mAtcaInitDone) {
1251        ATCA_STATUS status;
1252        int i;
1253
1254    #ifndef SINGLE_THREADED
1255        wc_InitMutex(&mSlotMutex);
1256    #endif
1257
1258        /* Init the free slotId list */
1259        for (i=0; i<ATECC_MAX_SLOT; i++) {
1260            if (i == ATECC_SLOT_AUTH_PRIV || i == ATECC_SLOT_I2C_ENC
1261        #ifdef WOLFSSL_ATECC_TNGTLS
1262                || i == ATECC_SLOT_ENC_PARENT
1263        #endif
1264               ) {
1265                mSlotList[i] = i;
1266            }
1267            else {
1268                /* ECC Slots (mark avail) */
1269                mSlotList[i] = ATECC_INVALID_SLOT;
1270            }
1271        }
1272#ifdef MICROCHIP_MPLAB_HARMONY_3
1273        atcab_release();
1274        atcab_wakeup();
1275#endif
1276        if (ateccx08a_cfg_initialized == 0) {
1277            /* Setup the hardware interface using defaults */
1278            status = atcab_init(gCfg);
1279            /* Initialize the CryptoAuthLib to communicate with */
1280            if (status != ATCA_SUCCESS) {
1281                WOLFSSL_MSG("Failed to initialize atcab");
1282                return WC_HW_E;
1283            }
1284            #ifdef WOLFSSL_MICROCHIP_TA100
1285                /* create handles for TA100 */
1286                if (atmel_createHandles() != 0) {
1287                    WOLFSSL_MSG("atmel_createHandles failed");
1288                    return WC_HW_E;
1289                }
1290            #endif
1291        }
1292
1293        /* show revision information */
1294        atmel_show_rev_info();
1295
1296    #ifdef WOLFSSL_ATECC508A_TLS
1297        /* Configure the ECC508 for use with TLS API functions */
1298        device_init_default();
1299    #endif
1300
1301#if defined(WOLFSSL_ATECC_ECDH_ENC) || defined(WOLFSSL_ATECC_ECDH_IOENC)
1302        /* Init the I2C pipe encryption key. */
1303        /* Value is generated/stored during pair for the ATECC508A and stored
1304            on micro flash */
1305        /* For this example its a fixed value */
1306        if (atmel_init_enc_key() != 0) {
1307            WOLFSSL_MSG("Failed to initialize transport key");
1308            return WC_HW_E;
1309        }
1310#endif
1311
1312        mAtcaInitDone = 1;
1313    }
1314#endif /* WOLFSSL_ATECC508A */
1315    return ret;
1316}
1317
1318void atmel_finish(void)
1319{
1320#if defined(WOLFSSL_ATECC508A) || defined(WOLFSSL_ATECC608A) || \
1321    defined(WOLFSSL_MICROCHIP_TA100)
1322    if (mAtcaInitDone) {
1323        atcab_release();
1324
1325    #ifndef SINGLE_THREADED
1326        wc_FreeMutex(&mSlotMutex);
1327    #endif
1328
1329        mAtcaInitDone = 0;
1330    }
1331#endif
1332}
1333
1334
1335/* Reference PK Callbacks */
1336#ifdef HAVE_PK_CALLBACKS
1337
1338/**
1339 * \brief Used on the server-side only for creating the ephemeral key for ECDH
1340 */
1341int atcatls_create_key_cb(WOLFSSL* ssl, ecc_key* key, unsigned int keySz,
1342    int ecc_curve, void* ctx)
1343{
1344    int ret;
1345    uint8_t peerKey[ATECC_PUBKEY_SIZE];
1346    uint8_t* qx = &peerKey[0];
1347    uint8_t* qy = &peerKey[ATECC_PUBKEY_SIZE/2];
1348    int slotId;
1349
1350    (void)ssl;
1351    (void)ctx;
1352
1353    /* ATECC508A only supports P-256 */
1354    if (ecc_curve == ECC_SECP256R1) {
1355        slotId = atmel_ecc_alloc(ATMEL_SLOT_ECDHE);
1356        if (slotId == ATECC_INVALID_SLOT)
1357            return WC_HW_WAIT_E;
1358
1359        /* generate new ephemeral key on device */
1360        ret = atmel_ecc_create_key(slotId, ecc_curve, peerKey);
1361
1362        /* load generated ECC508A public key into key, used by wolfSSL */
1363        if (ret == 0) {
1364            ret = wc_ecc_import_unsigned(key, qx, qy, NULL, ECC_SECP256R1);
1365        }
1366
1367        if (ret == 0) {
1368            key->slot = slotId;
1369        }
1370        else {
1371            atmel_ecc_free(slotId);
1372        #ifdef WOLFSSL_ATECC_DEBUG
1373            printf("atcatls_create_key_cb: ret %d\n", ret);
1374        #endif
1375        }
1376    }
1377    else {
1378    #ifndef WOLFSSL_ATECC508A_NOSOFTECC
1379        /* use software for non P-256 cases */
1380        WC_RNG rng;
1381        ret = wc_InitRng(&rng);
1382        if (ret == 0) {
1383            ret = wc_ecc_make_key_ex(&rng, keySz, key, ecc_curve);
1384            wc_FreeRng(&rng);
1385        }
1386    #else
1387        ret = NOT_COMPILED_IN;
1388    #endif /* !WOLFSSL_ATECC508A_NOSOFTECC */
1389    }
1390    return ret;
1391}
1392
1393/**
1394 * \brief Creates a shared secret using a peer public key and a device key
1395 */
1396int atcatls_create_pms_cb(WOLFSSL* ssl, ecc_key* otherKey,
1397        unsigned char* pubKeyDer, word32* pubKeySz,
1398        unsigned char* out, word32* outlen,
1399        int side, void* ctx)
1400{
1401    int ret;
1402    ecc_key tmpKey;
1403    uint8_t  peerKeyBuf[ATECC_PUBKEY_SIZE];
1404    uint8_t* peerKey = peerKeyBuf;
1405    uint8_t* qx = &peerKey[0];
1406    uint8_t* qy = &peerKey[ATECC_PUBKEY_SIZE/2];
1407    word32 qxLen = ATECC_PUBKEY_SIZE/2, qyLen = ATECC_PUBKEY_SIZE/2;
1408
1409    if (pubKeyDer == NULL || pubKeySz == NULL ||
1410        out == NULL || outlen == NULL) {
1411        return BAD_FUNC_ARG;
1412    }
1413
1414    (void)ssl;
1415    (void)ctx;
1416    (void)otherKey;
1417
1418    ret = wc_ecc_init(&tmpKey);
1419    if (ret != 0) {
1420        return ret;
1421    }
1422
1423    /* ATECC508A only supports P-256 */
1424    if (otherKey->dp->id == ECC_SECP256R1) {
1425        XMEMSET(peerKey, 0, ATECC_PUBKEY_SIZE);
1426
1427        /* for client: create and export public key */
1428        if (side == WOLFSSL_CLIENT_END) {
1429            int slotId = atmel_ecc_alloc(ATMEL_SLOT_ECDHE);
1430            if (slotId == ATECC_INVALID_SLOT) {
1431                ret = WC_HW_WAIT_E;
1432                goto exit;
1433            }
1434            tmpKey.slot = slotId;
1435
1436            /* generate new ephemeral key on device */
1437            ret = atmel_ecc_create_key(slotId, otherKey->dp->id, peerKey);
1438            if (ret != ATCA_SUCCESS) {
1439                atmel_ecc_free(slotId);
1440                goto exit;
1441            }
1442
1443            /* convert raw unsigned public key to X.963 format for TLS */
1444            ret = wc_ecc_import_unsigned(&tmpKey, qx, qy, NULL, ECC_SECP256R1);
1445            if (ret == 0) {
1446                ret = wc_ecc_export_x963(&tmpKey, pubKeyDer, pubKeySz);
1447            }
1448
1449            /* export peer's key as raw unsigned for hardware */
1450            if (ret == 0) {
1451                ret = wc_ecc_export_public_raw(otherKey, qx, &qxLen,
1452                                               qy, &qyLen);
1453            }
1454        }
1455
1456        /* for server: import public key */
1457        else if (side == WOLFSSL_SERVER_END) {
1458            tmpKey.slot = otherKey->slot;
1459
1460            /* import peer's key and export as raw unsigned for hardware */
1461            ret = wc_ecc_import_x963_ex(pubKeyDer, *pubKeySz, &tmpKey,
1462                                        ECC_SECP256R1);
1463            if (ret == 0) {
1464                ret = wc_ecc_export_public_raw(&tmpKey, qx, &qxLen, qy, &qyLen);
1465            }
1466        }
1467        else {
1468            ret = BAD_FUNC_ARG;
1469        }
1470
1471        if (ret != 0) {
1472            goto exit;
1473        }
1474
1475        ret = atmel_ecc_create_pms(tmpKey.slot, peerKey, out);
1476        *outlen = ATECC_KEY_SIZE;
1477
1478    #if !defined(WOLFSSL_ATECC508A_NOIDLE) && !defined(WOLFSSL_MICROCHIP_TA100)
1479        /* put chip into idle to prevent watchdog situation on chip */
1480        atcab_idle();
1481    #endif
1482
1483        (void)qxLen;
1484        (void)qyLen;
1485    }
1486    else {
1487    #ifndef WOLFSSL_ATECC508A_NOSOFTECC
1488        /* use software for non P-256 cases */
1489        ecc_key*  privKey = NULL;
1490        ecc_key*  pubKey = NULL;
1491
1492        /* for client: create and export public key */
1493        if (side == WOLFSSL_CLIENT_END)
1494        {
1495            WC_RNG rng;
1496            privKey = &tmpKey;
1497            pubKey = otherKey;
1498
1499            ret = wc_InitRng(&rng);
1500            if (ret == 0) {
1501                ret = wc_ecc_make_key_ex(&rng, 0, privKey, otherKey->dp->id);
1502                if (ret == 0) {
1503                    ret = wc_ecc_export_x963(privKey, pubKeyDer, pubKeySz);
1504                }
1505                wc_FreeRng(&rng);
1506            }
1507        }
1508        /* for server: import public key */
1509        else if (side == WOLFSSL_SERVER_END) {
1510            privKey = otherKey;
1511            pubKey = &tmpKey;
1512
1513            ret = wc_ecc_import_x963_ex(pubKeyDer, *pubKeySz, pubKey,
1514                otherKey->dp->id);
1515        }
1516        else {
1517            ret = BAD_FUNC_ARG;
1518        }
1519
1520        /* generate shared secret and return it */
1521        if (ret == 0) {
1522            ret = wc_ecc_shared_secret(privKey, pubKey, out, outlen);
1523        }
1524    #else
1525        ret = NOT_COMPILED_IN;
1526    #endif /* !WOLFSSL_ATECC508A_NOSOFTECC */
1527    }
1528
1529exit:
1530    wc_ecc_free(&tmpKey);
1531
1532#ifdef WOLFSSL_ATECC_DEBUG
1533    if (ret != 0) {
1534        printf("atcab_ecdh_enc: ret %d\n", ret);
1535    }
1536#endif
1537
1538    return ret;
1539}
1540
1541
1542/**
1543 * \brief Sign received digest using private key on device
1544 */
1545int atcatls_sign_certificate_cb(WOLFSSL* ssl, const byte* in, unsigned int inSz,
1546    byte* out, word32* outSz, const byte* key, unsigned int keySz, void* ctx)
1547{
1548    int ret;
1549    byte sigRs[ATECC_SIG_SIZE];
1550    int slotId;
1551
1552    (void)ssl;
1553    (void)inSz;
1554    (void)key;
1555    (void)keySz;
1556    (void)ctx;
1557
1558    if (in == NULL || out == NULL || outSz == NULL) {
1559        return BAD_FUNC_ARG;
1560    }
1561
1562    slotId = atmel_ecc_alloc(ATMEL_SLOT_DEVICE);
1563    if (slotId == ATECC_INVALID_SLOT)
1564        return WC_HW_WAIT_E;
1565
1566    /* We can only sign with P-256 */
1567#ifdef WOLFSSL_MICROCHIP_TA100
1568    ret = atmel_ecc_sign_ex(slotId, ECC_SECP256R1, in, inSz, sigRs);
1569#else
1570    ret = atmel_ecc_sign(MAP_TO_HANDLE(slotId), in, sigRs);
1571#endif
1572    if (ret != ATCA_SUCCESS) {
1573        ret = WC_HW_E; goto exit;
1574    }
1575
1576#if !defined(WOLFSSL_ATECC508A_NOIDLE) && !defined(WOLFSSL_MICROCHIP_TA100)
1577    /* put chip into idle to prevent watchdog situation on chip */
1578    atcab_idle();
1579#endif
1580
1581    /* Encode with ECDSA signature */
1582    ret = wc_ecc_rs_raw_to_sig(
1583        &sigRs[0], ATECC_SIG_SIZE/2,
1584        &sigRs[ATECC_SIG_SIZE/2], ATECC_SIG_SIZE/2,
1585        out, outSz);
1586    if (ret != 0) {
1587        goto exit;
1588    }
1589
1590exit:
1591
1592    atmel_ecc_free(slotId);
1593
1594#ifdef WOLFSSL_ATECC_DEBUG
1595    if (ret != 0) {
1596        printf("atcatls_sign_certificate_cb: ret %d\n", ret);
1597    }
1598#endif
1599
1600    return ret;
1601}
1602
1603/**
1604 * \brief Verify signature received from peers to prove peer's private key.
1605 */
1606int atcatls_verify_signature_cb(WOLFSSL* ssl, const byte* sig,
1607    unsigned int sigSz, const byte* hash, unsigned int hashSz, const byte* key,
1608    unsigned int keySz, int* result, void* ctx)
1609{
1610    int ret;
1611    ecc_key tmpKey;
1612    word32 idx = 0;
1613    uint8_t peerKey[ATECC_PUBKEY_SIZE];
1614    uint8_t* qx = &peerKey[0];
1615    uint8_t* qy = &peerKey[ATECC_PUBKEY_SIZE/2];
1616    word32 qxLen = ATECC_PUBKEY_SIZE/2, qyLen = ATECC_PUBKEY_SIZE/2;
1617    byte sigRs[ATECC_SIG_SIZE];
1618    word32 rSz = ATECC_SIG_SIZE/2;
1619    word32 sSz = ATECC_SIG_SIZE/2;
1620
1621    (void)sigSz;
1622    (void)hashSz;
1623    (void)ctx;
1624
1625    if (ssl == NULL || key == NULL || sig == NULL ||
1626        hash == NULL || result == NULL) {
1627        return BAD_FUNC_ARG;
1628    }
1629
1630    /* import public key */
1631    ret = wc_ecc_init(&tmpKey);
1632    if (ret == 0) {
1633        ret = wc_EccPublicKeyDecode(key, &idx, &tmpKey, keySz);
1634    }
1635    if (ret != 0) {
1636        wc_ecc_free(&tmpKey);
1637        goto exit;
1638    }
1639
1640    if (tmpKey.dp->id == ECC_SECP256R1) {
1641        /* export public as unsigned bin for hardware */
1642        ret = wc_ecc_export_public_raw(&tmpKey, qx, &qxLen, qy, &qyLen);
1643        wc_ecc_free(&tmpKey);
1644        if (ret != 0) {
1645            goto exit;
1646        }
1647
1648        /* decode the ECDSA signature */
1649        ret = wc_ecc_sig_to_rs(sig, sigSz,
1650            &sigRs[0], &rSz,
1651            &sigRs[ATECC_SIG_SIZE/2], &sSz);
1652        if (ret != 0) {
1653            goto exit;
1654        }
1655
1656        ret = atmel_ecc_verify(hash, sigRs, peerKey, result);
1657        if (ret != ATCA_SUCCESS || !*result) {
1658            ret = WC_HW_E; goto exit;
1659        }
1660
1661#if !defined(WOLFSSL_ATECC508A_NOIDLE) && !defined(WOLFSSL_MICROCHIP_TA100)
1662        /* put chip into idle to prevent watchdog situation on chip */
1663        atcab_idle();
1664    #endif
1665    }
1666    else {
1667    #ifndef WOLFSSL_ATECC508A_NOSOFTECC
1668        ret = wc_ecc_verify_hash(sig, sigSz, hash, hashSz, result, &tmpKey);
1669    #else
1670        ret = NOT_COMPILED_IN;
1671    #endif /* !WOLFSSL_ATECC508A_NOSOFTECC */
1672        wc_ecc_free(&tmpKey);
1673        goto exit;
1674    }
1675
1676    (void)rSz;
1677    (void)sSz;
1678    (void)qxLen;
1679    (void)qyLen;
1680
1681    ret = 0; /* success */
1682
1683exit:
1684
1685#ifdef WOLFSSL_ATECC_DEBUG
1686    if (ret != 0) {
1687        printf("atcatls_verify_signature_cb: ret %d\n", ret);
1688    }
1689#endif
1690
1691    return ret;
1692}
1693
1694#ifdef ATCA_TFLEX_SUPPORT
1695static int atcatls_set_certificates(WOLFSSL_CTX *ctx)
1696{
1697    #ifndef ATCATLS_SIGNER_CERT_MAX_SIZE
1698        #define ATCATLS_SIGNER_CERT_MAX_SIZE 0x250
1699    #endif
1700    #ifndef ATCATLS_DEVICE_CERT_MAX_SIZE
1701        #define ATCATLS_DEVICE_CERT_MAX_SIZE 0x250
1702    #endif
1703    #ifndef ATCATLS_CERT_BUFF_MAX_SIZE
1704        #define ATCATLS_CERT_BUFF_MAX_SIZE (ATCATLS_SIGNER_CERT_MAX_SIZE +\
1705                                               ATCATLS_DEVICE_CERT_MAX_SIZE)
1706    #endif
1707    #ifndef ATCATLS_PUBKEY_BUFF_MAX_SIZE
1708        #define ATCATLS_PUBKEY_BUFF_MAX_SIZE 65
1709    #endif
1710
1711    int ret = 0;
1712    ATCA_STATUS status;
1713    size_t signerCertSize = ATCATLS_SIGNER_CERT_MAX_SIZE;
1714    size_t deviceCertSize = ATCATLS_DEVICE_CERT_MAX_SIZE;
1715    uint8_t certBuffer[ATCATLS_CERT_BUFF_MAX_SIZE];
1716    uint8_t signerBuffer[ATCATLS_SIGNER_CERT_MAX_SIZE];
1717#ifdef WOLFSSL_ATECC_TFLXTLS
1718    uint8_t signerPubKeyBuffer[ATCATLS_PUBKEY_BUFF_MAX_SIZE];
1719#endif
1720
1721#ifdef WOLFSSL_ATECC_TNGTLS
1722    ret = tng_atcacert_max_signer_cert_size(&signerCertSize);
1723    if (ret != ATCACERT_E_SUCCESS) {
1724    #ifdef WOLFSSL_ATECC_DEBUG
1725       printf("Failed to get max signer cert size\r\n");
1726    #endif
1727       return ret;
1728    }
1729    else if (signerCertSize > ATCATLS_SIGNER_CERT_MAX_SIZE) {
1730    #ifdef WOLFSSL_ATECC_DEBUG
1731        printf("Signer CA cert buffer too small, need to increase at least"
1732               " to %d\r\n", signerCertSize);
1733    #endif
1734       return -1;
1735    }
1736
1737    /* Read TNGTLS signer cert */
1738    status = tng_atcacert_read_signer_cert(signerBuffer, &signerCertSize);
1739    if (ATCA_SUCCESS != status) {
1740        ret = atmel_ecc_translate_err(status);
1741        return ret;
1742    }
1743
1744    /* Read device cert signed by the signer above */
1745    status = tng_atcacert_read_device_cert(certBuffer, &deviceCertSize,
1746                                           signerBuffer);
1747    if (ATCA_SUCCESS != status) {
1748        ret = atmel_ecc_translate_err(status);
1749        return ret;
1750    }
1751    else if (deviceCertSize > ATCATLS_DEVICE_CERT_MAX_SIZE) {
1752    #ifdef WOLFSSL_ATECC_DEBUG
1753        printf("Device cert buffer too small, need to increase at least"
1754               " to %d\r\n", deviceCertSize);
1755    #endif
1756       return -1;
1757    }
1758#endif /* WOLFSSL_ATECC_TNGTLS */
1759#ifdef WOLFSSL_ATECC_TFLXTLS
1760    /* MAKE SURE TO COPY YOUR CUSTOM CERTIFICATE FILES UNDER CAL/tng
1761     * Verify variable names, here below the code uses typical tflxtls
1762     *  proto example.
1763     *
1764     * g_cert_def_1_signer
1765     * g_cert_ca_public_key_1_signer
1766     * g_cert_def_3_device
1767     */
1768
1769    status = atcacert_read_cert(&g_cert_def_1_signer,
1770                            (const uint8_t*)g_cert_ca_public_key_1_signer,
1771                            signerBuffer, &signerCertSize);
1772    if (status != ATCA_SUCCESS) {
1773    #ifdef WOLFSSL_ATECC_DEBUG
1774        printf("Failed to read TFLXTLS signer cert!\r\n");
1775    #endif
1776        return (int)status;
1777    }
1778    else if (signerCertSize > ATCATLS_SIGNER_CERT_MAX_SIZE) {
1779    #ifdef WOLFSSL_ATECC_DEBUG
1780       printf("Signer TFLXTLS CA cert buffer too small, need to increase"
1781              " at least to %d\r\n", signerCertSize);
1782    #endif
1783       return -1;
1784    }
1785
1786    status = atcacert_get_subj_public_key(&g_cert_def_1_signer, signerBuffer,
1787        signerCertSize, signerPubKeyBuffer);
1788    if (status != ATCA_SUCCESS) {
1789    #ifdef WOLFSSL_ATECC_DEBUG
1790        printf("Failed to read TFLXTLS signer public key!\r\n");
1791    #endif
1792       return (int)status;
1793    }
1794
1795    status = atcacert_read_cert(&g_cert_def_3_device, signerPubKeyBuffer,
1796                                certBuffer, &deviceCertSize);
1797    if (status != ATCA_SUCCESS) {
1798    #ifdef WOLFSSL_ATECC_DEBUG
1799        printf("Failed to read device cert!\r\n");
1800    #endif
1801        return (int)status;
1802    }
1803    else if (deviceCertSize > ATCATLS_DEVICE_CERT_MAX_SIZE) {
1804    #ifdef WOLFSSL_ATECC_DEBUG
1805        printf("Device cert buffer too small, need to increase at least"
1806               " to %d\r\n", deviceCertSize);
1807    #endif
1808       return -1;
1809    }
1810#endif
1811
1812    /* Prepare the full buffer adding the signer certificate */
1813    XMEMCPY(&certBuffer[deviceCertSize], signerBuffer, signerCertSize);
1814
1815    ret = wolfSSL_CTX_use_certificate_chain_buffer_format(ctx,
1816          (const unsigned char*)certBuffer, (signerCertSize + deviceCertSize),
1817          WOLFSSL_FILETYPE_ASN1);
1818    if (ret != WOLFSSL_SUCCESS) {
1819    #ifdef WOLFSSL_ATECC_DEBUG
1820        printf("Error registering certificate chain\r\n");
1821    #endif
1822        ret = -1;
1823    }
1824    else {
1825        ret = 0;
1826    }
1827
1828    return ret;
1829}
1830#endif /* ATCA_TFLEX_SUPPORT */
1831
1832int atcatls_set_callbacks(WOLFSSL_CTX* ctx)
1833{
1834    int ret = 0;
1835    wolfSSL_CTX_SetEccKeyGenCb(ctx, atcatls_create_key_cb);
1836    wolfSSL_CTX_SetEccVerifyCb(ctx, atcatls_verify_signature_cb);
1837    wolfSSL_CTX_SetEccSignCb(ctx, atcatls_sign_certificate_cb);
1838    wolfSSL_CTX_SetEccSharedSecretCb(ctx, atcatls_create_pms_cb);
1839
1840#ifdef ATCA_TFLEX_SUPPORT
1841#if defined(WOLFSSL_ATECC_TNGTLS) || defined(WOLFSSL_ATECC_TFLXTLS)
1842    ret = atcatls_set_certificates(ctx);
1843    if (ret != 0) {
1844    #ifdef WOLFSSL_ATECC_DEBUG
1845        printf("atcatls_set_certificates failed. (%d)\r\n", ret);
1846    #endif
1847    }
1848#endif
1849#endif /* ATCA_TFLEX_SUPPORT */
1850    return ret;
1851}
1852
1853int atcatls_set_callback_ctx(WOLFSSL* ssl, void* user_ctx)
1854{
1855    wolfSSL_SetEccKeyGenCtx(ssl, user_ctx);
1856    wolfSSL_SetEccVerifyCtx(ssl, user_ctx);
1857    wolfSSL_SetEccSignCtx(ssl, user_ctx);
1858    wolfSSL_SetEccSharedSecretCtx(ssl, user_ctx);
1859    return 0;
1860}
1861
1862
1863#endif /* HAVE_PK_CALLBACKS */
1864
1865#if defined(WOLFSSL_MICROCHIP_TA100) && !defined(NO_AES) && \
1866    defined(HAVE_AESGCM) && defined(WOLFSSL_MICROCHIP_AESGCM)
1867
1868/* AES key element attributes for TA100: class=0x62, prop=0x0600, perm=0x55 */
1869static int ta100_aes_handle_created = 0;
1870static uint16_t ta100_aes_handle = TA100_AES_HANDLE;
1871
1872/* Optional runtime override for AES handle. */
1873int wc_Microchip_SetAesGcmHandle(uint16_t handle)
1874{
1875    ta100_aes_handle = handle;
1876    ta100_aes_handle_created = 0;
1877    return 0;
1878}
1879
1880static int ta100_is_aes_handle(uint16_t handle)
1881{
1882    uint8_t info[TA_HANDLE_INFO_SIZE] = { 0 };
1883    ATCA_STATUS status;
1884    uint8_t handle_class;
1885    uint8_t key_type;
1886
1887    status = talib_info_get_handle_info(atcab_get_device(), handle, info);
1888    if (status != ATCA_SUCCESS) {
1889        return 0;
1890    }
1891
1892    handle_class = info[0] & TA_HANDLE_INFO_CLASS_MASK;
1893    key_type = (info[0] & TA_HANDLE_INFO_KEY_TYPE_MASK) >>
1894        TA_HANDLE_INFO_KEY_TYPE_SHIFT;
1895
1896    return (handle_class == TA_CLASS_SYMMETRIC_KEY &&
1897            key_type == TA_KEY_TYPE_AES128);
1898}
1899
1900int wc_Microchip_aes_set_key(Aes* aes, const byte* key, word32 keylen,
1901                                        const byte* iv, int dir)
1902{
1903    ATCA_STATUS status;
1904    bool is_locked = false;
1905    uint8_t is_handle_valid = 0;
1906    ta_element_attributes_t attr;
1907
1908    (void)dir;
1909    (void)iv;
1910
1911    if (aes == NULL) {
1912        return BAD_FUNC_ARG;
1913    }
1914    /* TA100 uses dedicated symmetric key handle, not ECC slot mapping */
1915    aes->key_id = ta100_aes_handle;
1916
1917    aes->keylen = keylen;
1918    aes->rounds = keylen/4 + 6;
1919    XMEMCPY(aes->key, key, keylen);
1920
1921    /* Create AES handle if not already created */
1922    if (!ta100_aes_handle_created) {
1923        status = talib_is_handle_valid(atcab_get_device(),
1924                                       (uint32_t)aes->key_id,
1925                                       &is_handle_valid);
1926        if (status != ATCA_SUCCESS) {
1927            return WC_HW_E;
1928        }
1929
1930        if (is_handle_valid == 0) {
1931            status = talib_handle_init_symmetric_key(&attr,
1932                TA_KEY_TYPE_AES128, TA_PROP_SYMM_KEY_USAGE_ANY);
1933            if (status != ATCA_SUCCESS) {
1934                return WC_HW_E;
1935            }
1936            (void)talib_handle_set_permissions(&attr,
1937                TA_PERM_ALWAYS, TA_PERM_ALWAYS,
1938                TA_PERM_ALWAYS, TA_PERM_ALWAYS);
1939            ta100_fix_property_endian(&attr);
1940
1941            status = talib_create_element_with_handle(atcab_get_device(),
1942                                                      aes->key_id, &attr);
1943            /* Ignore "already exists" error (0xA3), fail on other errors */
1944            if (!(status == ATCA_SUCCESS || status == 0xA3)) {
1945                return WC_HW_E;
1946            }
1947        } else if (!ta100_is_aes_handle(aes->key_id)) {
1948            return WC_HW_E;
1949        }
1950
1951        ta100_aes_handle_created = 1;
1952    }
1953
1954    status = talib_is_handle_locked(atcab_get_device(),
1955        aes->key_id, &is_locked);
1956    if (status == ATCA_SUCCESS && is_locked) {
1957        return WC_HW_E;
1958    }
1959
1960    /* Write AES key to the symmetric key handle */
1961    status = talib_write_element(atcab_get_device(), aes->key_id,
1962            TA_KEY_TYPE_AES128_SIZE, (const uint8_t*)key);
1963    CHECK_STATUS(status);
1964
1965    /* key_block=0 for AES-128 (single 16-byte block) */
1966    status = talib_aes_gcm_keyload(atcab_get_device(), aes->key_id, 0);
1967    CHECK_STATUS(status);
1968
1969    /* Provisioning must lock setup explicitly; do not lock it as a side
1970     * effect of loading an AES key. */
1971    status = talib_is_setup_locked(atcab_get_device(), &is_locked);
1972    CHECK_STATUS(status);
1973    if (!is_locked) {
1974        return WC_HW_E;
1975    }
1976
1977    return atmel_ecc_translate_err(status);
1978}
1979
1980void wc_Microchip_aes_free(Aes* aes)
1981{
1982    (void)aes;
1983}
1984
1985
1986static int wc_Microchip_AesGcmCommon(Aes* aes, byte* out, const byte* in,
1987        word32 sz, const byte* iv, word32 ivSz, byte* authTag, word32 authTagSz,
1988        const byte* authIn, word32 authInSz, int dir)
1989{
1990    ATCA_STATUS status;
1991    byte tag_buf[TA_AES_GCM_TAG_LENGTH];
1992    word32 copy_sz;
1993
1994    (void)aes;
1995
1996    if (aes == NULL) {
1997        return BAD_FUNC_ARG;
1998    }
1999    if (dir != AES_ENCRYPTION && dir != AES_DECRYPTION) {
2000        return BAD_FUNC_ARG;
2001    }
2002    if (ivSz != TA_AES_GCM_IV_LENGTH) {
2003        return BAD_FUNC_ARG;
2004    }
2005    if (authTag == NULL || authTagSz == 0 ||
2006        authTagSz > TA_AES_GCM_TAG_LENGTH) {
2007        return BAD_FUNC_ARG;
2008    }
2009
2010    if (dir == AES_ENCRYPTION) {
2011        /* Note: talib API takes non-const iv */
2012        if (authTagSz != TA_AES_GCM_TAG_LENGTH) {
2013            status = talib_aes_gcm_encrypt(atcab_get_device(), authIn,
2014                                           authInSz, (uint8_t*)iv,
2015                                           in, sz, out, tag_buf);
2016            if (status == ATCA_SUCCESS) {
2017                copy_sz = authTagSz;
2018                XMEMCPY(authTag, tag_buf, copy_sz);
2019            }
2020        }
2021        else {
2022            status = talib_aes_gcm_encrypt(atcab_get_device(), authIn,
2023                                           authInSz, (uint8_t*)iv,
2024                                           in, sz, out, authTag);
2025        }
2026    }
2027    else {
2028        if (authTagSz != TA_AES_GCM_TAG_LENGTH) {
2029            if (sz != 0) {
2030                return NOT_COMPILED_IN;
2031            }
2032            status = talib_aes_gcm_encrypt(atcab_get_device(), authIn,
2033                                           authInSz, (uint8_t*)iv,
2034                                           in, sz, out, tag_buf);
2035            if (status == ATCA_SUCCESS) {
2036                copy_sz = authTagSz;
2037                if (XMEMCMP(tag_buf, authTag, copy_sz) != 0) {
2038                    return AES_GCM_AUTH_E;
2039                }
2040            }
2041        }
2042        else {
2043            status = talib_aes_gcm_decrypt(atcab_get_device(), authIn,
2044                                           authInSz, (uint8_t*)iv,
2045                                           authTag, in, sz, out);
2046        }
2047    }
2048
2049    if (status != ATCA_SUCCESS) {
2050        if (status == TA_CALCULATION && dir == AES_DECRYPTION) {
2051            return AES_GCM_AUTH_E;
2052        }
2053        return atmel_ecc_translate_err(status);
2054    }
2055
2056    return 0;
2057}
2058
2059int wc_Microchip_AesGcmEncrypt(Aes* aes, byte* out, const byte* in, word32 sz,
2060                             const byte* iv, word32 ivSz,
2061                             byte* authTag, word32 authTagSz,
2062                             const byte* authIn, word32 authInSz)
2063{
2064    return wc_Microchip_AesGcmCommon(aes, out, in, sz, iv, ivSz, authTag,
2065                            authTagSz, authIn, authInSz, AES_ENCRYPTION);
2066}
2067
2068int wc_Microchip_AesGcmDecrypt(Aes* aes, byte* out, const byte* in, word32 sz,
2069                             const byte* iv, word32 ivSz,
2070                             const byte* authTag, word32 authTagSz,
2071                             const byte* authIn, word32 authInSz)
2072{
2073    return wc_Microchip_AesGcmCommon(aes, out, in, sz, iv, ivSz, (byte*)authTag,
2074                                   authTagSz, authIn, authInSz, AES_DECRYPTION);
2075}
2076#endif /* WOLFSSL_MICROCHIP_TA100 && !NO_AES && HAVE_AESGCM */
2077
2078#endif /* WOLFSSL_ATMEL || WOLFSSL_ATECC508A || WOLFSSL_ATECC608A ||
2079        * WOLFSSL_ATECC_PKCB || WOLFSSL_MICROCHIP_TA100 */