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

   1/* iotsafe.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/* IoT-safe module for communication with IoT-safe applet on SIM card */
  23
  24#ifdef HAVE_CONFIG_H
  25    #include <config.h>
  26#endif
  27
  28#include <wolfssl/wolfcrypt/settings.h>
  29
  30#ifdef WOLFSSL_IOTSAFE
  31
  32#include <wolfssl/wolfcrypt/random.h>
  33#include <wolfssl/wolfcrypt/ecc.h>
  34#include <wolfssl/wolfcrypt/error-crypt.h>
  35#include <wolfssl/ssl.h>
  36#include <wolfssl/wolfcrypt/port/iotsafe/iotsafe.h>
  37#include <wolfssl/internal.h>
  38
  39#ifdef NO_INLINE
  40    #include <wolfssl/wolfcrypt/misc.h>
  41#else
  42    #define WOLFSSL_MISC_INCLUDED
  43    #include <wolfcrypt/src/misc.c>
  44#endif
  45
  46#ifdef DEBUG_IOTSAFE
  47#include <stdio.h>
  48#endif
  49
  50static int wolfIoT_initialized = 0;
  51
  52/* Modem APDU interface
  53 *
  54 */
  55
  56/* I/O calls */
  57static wolfSSL_IOTSafe_CSIM_read_cb csim_read_cb = NULL;
  58static wolfSSL_IOTSafe_CSIM_write_cb csim_write_cb = NULL;
  59
  60#define GETRAND_CMD_SIZE (24 + 2)
  61#define IOTSAFE_MAX_RETRIES (8)
  62
  63
  64#define AT_CSIM_CMD_SIZE 13
  65#define AT_CMD_HDR_SIZE  10
  66#define AT_CMD_INS_POS (AT_CMD_HDR_SIZE - 8)
  67#define AT_CMD_P1_POS  (AT_CMD_HDR_SIZE - 6)
  68#define AT_CMD_P2_POS  (AT_CMD_HDR_SIZE - 4)
  69#define AT_CMD_LC_POS  (AT_CMD_HDR_SIZE - 2)
  70
  71/* Size of "\r\n + null terminator */
  72#define CSIM_CMD_ENDSTR_SIZE 4
  73
  74/* Buffer for CSIM RX APDU */
  75#define MAXBUF 2048
  76static char csim_read_buf[MAXBUF];
  77static char csim_cmd[IOTSAFE_CMDSIZE_MAX];
  78
  79/* APDU layer: I/O */
  80static int csim_read(char *buf, int len)
  81{
  82    if (csim_read_cb)
  83        return csim_read_cb(buf, len);
  84    else
  85        return -WOLFSSL_ERROR_SYSCALL;
  86}
  87
  88static int csim_write(const char *buf, int len)
  89{
  90#ifdef DEBUG_IOTSAFE
  91    printf(">>> %s\n", buf);
  92#endif
  93    if (csim_write_cb)
  94        return csim_write_cb(buf, len);
  95    else
  96        return -WOLFSSL_ERROR_SYSCALL;
  97}
  98
  99/* APDU string parser/expect
 100 */
 101static int hex_to_bytes(const char *hex, unsigned char *output, unsigned long sz)
 102{
 103    word32 i;
 104    for (i = 0; i < sz; i++) {
 105        signed char ch1, ch2;
 106        ch1 = HexCharToByte(hex[i * 2]);
 107        ch2 = HexCharToByte(hex[i * 2 + 1]);
 108        if ((ch1 < 0) || (ch2 < 0)) {
 109            WOLFSSL_MSG("hex_to_bytes: syntax error");
 110            return -1;
 111        }
 112        output[i] = (unsigned char)((ch1 << 4) + ch2);
 113    }
 114    return (int)sz;
 115}
 116
 117static int bytes_to_hex(const unsigned char *bytes, char *hex, unsigned long sz)
 118{
 119    word32 i;
 120    for (i = 0; i < sz; i++) {
 121        ByteToHexStr(bytes[i], &hex[2 * i]);
 122    }
 123    return (int)(2 * sz);
 124}
 125
 126static int expect_tok(const char *cmd, int size, const char *tok, char **repl)
 127{
 128    char *r_found = NULL;
 129    static char parser_line[MAXBUF / 2];
 130    char *reply = NULL;
 131    int ret;
 132    if (cmd) {
 133        ret = csim_write(cmd, size);
 134        if (ret <= 0)
 135            return ret;
 136    } else {
 137        /* Force enter the read loop on cmd == NULL */
 138        ret = 1;
 139    }
 140    while (ret > 0) {
 141        ret = csim_read(csim_read_buf, MAXBUF);
 142#ifdef DEBUG_IOTSAFE
 143        if (ret > 0)
 144            printf("<<< %s\n", csim_read_buf);
 145#endif
 146        if (tok && (ret > 0) && !r_found) {
 147            /* Mark the beginning of the match in the reply. */
 148            r_found = XSTRSTR(csim_read_buf, tok);
 149            if (r_found) {
 150                XSTRNCPY(parser_line, r_found, MAXBUF / 2 - 1);
 151                /* Do not break here! *
 152                 * Keep reading until csim_read returns 0, or error */
 153            }
 154        }
 155    }
 156    if ((ret >= 0) && (r_found)) {
 157        reply = parser_line + XSTRLEN(tok);
 158        /* If the reply consists of token only,
 159         * return the entire string.
 160         */
 161        if (XSTRLEN(reply) == 0) {
 162            reply = parser_line;
 163        }
 164    }
 165    /* Assign the pointer to the received reply
 166     * only if repl is not NULL
 167     */
 168    if (repl)
 169        *repl = reply;
 170
 171    if (reply)
 172        ret = (int)XSTRLEN(reply);
 173    else
 174        ret = 0;
 175    return ret;
 176}
 177
 178static int expect_ok(const char *cmd, int size)
 179{
 180    return expect_tok(cmd, size, "OK", NULL);
 181}
 182
 183/* Utilities
 184 */
 185
 186/* Conversion utility from hex string format to bytes */
 187static int hexbuffer_conv(char *hex_str, unsigned char *output, unsigned long sz)
 188{
 189    if (XSTRLEN(hex_str) != (2 * sz)) {
 190        return -1;
 191    }
 192    return (int)hex_to_bytes(hex_str, output, sz);
 193}
 194
 195/* Search a TLV by tag in a buffer */
 196static char *search_tlv(const char *haystack, int size, uint8_t tag)
 197{
 198    int i = 0;
 199    uint8_t t;
 200    uint8_t l;
 201    while (i <= size - 4) {
 202        if (hex_to_bytes(&haystack[i], &t, 1) < 0)
 203            return NULL;
 204        if (hex_to_bytes(&haystack[i + 2], &l, 1) < 0)
 205            return NULL;
 206        if (tag == t) {
 207            return (char *)&haystack[i];
 208        }
 209        if (l + i > size)
 210            return NULL;
 211        i += 4 +  2 * l;
 212    }
 213    return NULL;
 214}
 215
 216static int iotsafe_cmd_start(char *cmd, byte cmd_class, byte ins, byte p1, byte p2)
 217{
 218    byte lc = 0;
 219    char *out;
 220    XMEMSET(cmd, 0, IOTSAFE_CMDSIZE_MAX);
 221    XSTRNCPY(cmd, "AT+CSIM= 10,\"", IOTSAFE_CMDSIZE_MAX - 1);
 222    out = cmd + AT_CSIM_CMD_SIZE;
 223    bytes_to_hex(&cmd_class, out, 1);
 224    bytes_to_hex(&ins, out + AT_CMD_INS_POS, 1);
 225    bytes_to_hex(&p1, out + AT_CMD_P1_POS, 1);
 226    bytes_to_hex(&p2, out + AT_CMD_P2_POS, 1);
 227    bytes_to_hex(&lc, out + AT_CMD_LC_POS, 1);
 228    out[10] = 0;
 229    return (int)XSTRLEN(cmd);
 230}
 231
 232static int iotsafe_cmd_add_tlv_ex(char *cmd, byte tag, uint16_t len,
 233        const byte *val, int taglen_size)
 234{
 235    word32 cur_csim_len;
 236    word32 off;
 237    byte cur_lc;
 238    char *out;
 239    int ret;
 240    byte *len_b = (byte *)&len;
 241    char *len_csim_str = (cmd + AT_CSIM_CMD_SIZE - 5);
 242    word32 cmdlen;
 243
 244    cmdlen = (word32)XSTRLEN(cmd);
 245    if (cmdlen < AT_CSIM_CMD_SIZE) {
 246        return BAD_FUNC_ARG;
 247    }
 248
 249    if ((taglen_size < 1) || (taglen_size > 2)) {
 250        return BAD_FUNC_ARG;
 251    }
 252
 253    /* Read out current CSIM len from the existing string.
 254     * The generated command may have the format:
 255     *  "AT+CSIM= 68" (< 100: leading space)
 256     *   or
 257     *  "AT+CSIM=212" (>=100: same positions, leading hundreds)
 258     *
 259     */
 260    cur_csim_len = (word32)len_csim_str[2] - '0';
 261    cur_csim_len += (len_csim_str[1] - '0') * 10;
 262    if (len_csim_str[0] >= '0' &&
 263            len_csim_str[0] <= '9') {
 264        cur_csim_len += (len_csim_str[0] - '0') * 100;
 265    } else if (len_csim_str[0] != ' ') {
 266        return BAD_FUNC_ARG;
 267    }
 268
 269    if ((cmdlen + cur_csim_len + CSIM_CMD_ENDSTR_SIZE) > IOTSAFE_CMDSIZE_MAX) {
 270        return MEMORY_E;
 271    }
 272
 273    /* Read out current Lc parameter in the CSIM command, last byte in the
 274     * header
 275     */
 276    if (hex_to_bytes(cmd + AT_CSIM_CMD_SIZE + AT_CMD_LC_POS, &cur_lc, 1) < 0) {
 277        return BAD_FUNC_ARG;
 278    }
 279
 280    if ((int)cur_lc + 1 + taglen_size + len > 0xFF) {
 281        return BAD_FUNC_ARG;
 282    }
 283    /* Increase Lc and CSIM length according to the TLV len */
 284    cur_lc += 1 + taglen_size + len;
 285    cur_csim_len += 2 + (2 * taglen_size) + 2*len;
 286
 287    /* Position the out buffer to the current end of string */
 288    out = cmd + XSTRLEN(cmd);
 289    off = 0;
 290
 291    /* Write Tag */
 292    bytes_to_hex(&tag, out, 1);
 293    off += 2;
 294
 295    /* Write Len */
 296    if (taglen_size == 2) {
 297        bytes_to_hex(&len_b[1], out + 2, 1);
 298        bytes_to_hex(&len_b[0], out + 4, 1);
 299        off += 4;
 300    } else {
 301        bytes_to_hex(&len_b[0], out + 2, 1);
 302        off += 2;
 303    }
 304
 305    /* Write Val */
 306    ret = bytes_to_hex(val, out + off, len);
 307    off += ret;
 308
 309    /* Terminate string */
 310    out[off] = 0;
 311
 312    /* Write new CSIM command size */
 313    if (cur_csim_len > 99)
 314        len_csim_str[0] = (cur_csim_len / 100) + '0';
 315    else
 316        len_csim_str[0] = ' ';
 317    len_csim_str[1] = ((cur_csim_len % 100) / 10) + '0';
 318    len_csim_str[2] = (cur_csim_len % 10) + '0';
 319
 320    /* Write new Lc value */
 321    bytes_to_hex(&cur_lc, cmd + AT_CSIM_CMD_SIZE + AT_CMD_LC_POS, 1);
 322    return off;
 323}
 324
 325static int iotsafe_cmd_add_tlv16(char *cmd, byte tag, uint16_t len,
 326        const byte *val)
 327{
 328    return iotsafe_cmd_add_tlv_ex(cmd, tag, len, val, 2);
 329}
 330
 331static int iotsafe_cmd_add_tlv(char *cmd, byte tag, byte len, const byte *val)
 332{
 333    return iotsafe_cmd_add_tlv_ex(cmd, tag, len, val, 1);
 334}
 335
 336static void iotsafe_cmd_complete(char *cmd)
 337{
 338    word32 cmdlen = (word32)XSTRLEN(cmd);
 339    char *out;
 340    if (cmdlen + CSIM_CMD_ENDSTR_SIZE > IOTSAFE_CMDSIZE_MAX) {
 341        return;
 342    }
 343    out = cmd + cmdlen;
 344    out[0] = '"';
 345    out[1] = '\r';
 346    out[2] = '\n';
 347    out[3] = 0;
 348}
 349
 350/** IOT-Safe Commands
 351 *
 352 *
 353 */
 354static int expect_csim_response(const char *cmd, word32 size, char **reply)
 355{
 356    const char csim_response_hdr[] = "+CSIM:";
 357    uint8_t len = 0;
 358    char *csim_reply;
 359    int ret;
 360    char *payload;
 361    char *endstr;
 362    ret = expect_tok(cmd, size, csim_response_hdr, &csim_reply);
 363    while (ret == 0) {
 364        ret = expect_tok("AT\r\n", 4, csim_response_hdr, &csim_reply);
 365    }
 366    if (ret < 1) {
 367        return ret;
 368    }
 369    payload = XSTRSTR(csim_reply, "\"");
 370    if (payload == NULL) {
 371        return -1;
 372    }
 373    payload++;
 374    if (XSTRNCMP(payload, "61", 2) == 0) {
 375        if (hex_to_bytes(payload + 2, &len, 1) == 1) {
 376            iotsafe_cmd_start(csim_cmd,1,IOTSAFE_INS_GETRESPONSE, 0, 0);
 377            bytes_to_hex(&len, csim_cmd + AT_CSIM_CMD_SIZE + AT_CMD_LC_POS, 1);
 378            csim_cmd[AT_CSIM_CMD_SIZE + AT_CMD_HDR_SIZE] = 0;
 379            iotsafe_cmd_complete(csim_cmd);
 380            ret = expect_tok(csim_cmd, (int)XSTRLEN(csim_cmd),
 381                    csim_response_hdr, reply);
 382            if (ret < 1)
 383                return -1;
 384            payload = XSTRSTR(*reply, "\"");
 385            if (payload == NULL)
 386                return -1;
 387            payload++;
 388        }
 389    }
 390    ret -= 2;
 391    if (ret >= 4) {
 392        endstr = XSTRSTR(payload, "9000\"");
 393        if (endstr == NULL) {
 394            endstr = XSTRSTR(payload, "\"");
 395        }
 396        if (endstr) {
 397            *endstr = 0;
 398            ret = (int)XSTRLEN(payload);
 399        }
 400    }
 401    payload[ret] = '\0';
 402    *reply = payload;
 403    return ret;
 404}
 405
 406/* Internal initialization function.
 407 * Load the IoT-Safe applet
 408 */
 409
 410static int iotsafe_init(void)
 411{
 412    char *reply;
 413    const char atcmd_load_applet_str[]=
 414        "AT+CSIM=24,\"01A4040007A0000005590010\"\r\n";
 415    int ret;
 416
 417    do {
 418        ret = expect_ok("ATE0\r\n", 6);
 419        if (ret == 0)
 420            ret = expect_tok(NULL, 0, NULL, NULL);
 421    } while (ret == 0);
 422    if (ret < 0)
 423        return ret;
 424
 425    WOLFSSL_MSG("ATE0 OK!");
 426    if (expect_csim_response(atcmd_load_applet_str,
 427                (word32)XSTRLEN(atcmd_load_applet_str), &reply) < 0) {
 428        WOLFSSL_MSG("FAIL: no Applet code response from iot-safe init");
 429        expect_ok("AT", 2);
 430    } else {
 431        WOLFSSL_MSG("IoT Safe Applet INIT OK");
 432    }
 433    if (expect_tok(NULL, 0, NULL, NULL) < 0)
 434        return -1;
 435    wolfIoT_initialized++;
 436    return 0;
 437}
 438
 439
 440/* internal: Read File content into a buffer */
 441static int iotsafe_readfile(uint8_t *file_id, uint16_t file_id_sz,
 442        unsigned char *content, int max_size)
 443{
 444    char *resp;
 445    int ret;
 446    uint16_t off = 0;
 447#ifdef IOTSAFE_NO_GETDATA
 448    int file_sz = max_size;
 449#else
 450    int file_sz = 0;
 451    char *filesz_s;
 452
 453    iotsafe_cmd_start(csim_cmd, IOTSAFE_CLASS, IOTSAFE_INS_GETDATA,
 454            IOTSAFE_GETDATA_FILE, 0);
 455    iotsafe_cmd_add_tlv(csim_cmd, IOTSAFE_TAG_FILE_ID, file_id_sz, file_id);
 456    iotsafe_cmd_complete(csim_cmd);
 457
 458    ret = expect_csim_response(csim_cmd, (word32)XSTRLEN(csim_cmd), &resp);
 459    if (ret <= 0) {
 460        return ret;
 461    }
 462
 463    filesz_s = search_tlv(resp + 4, ret - 4, 0x20);
 464    if ((filesz_s) && (XSTRLEN(filesz_s)) >= 8) {
 465        uint8_t fs_msb, fs_lsb;
 466        if (hex_to_bytes(filesz_s + 4, &fs_msb, 1) < 0)
 467            return -1;
 468        if (hex_to_bytes(filesz_s + 6, &fs_lsb, 1) < 0)
 469            return -1;
 470        file_sz = (fs_msb << 8) + fs_lsb;
 471        WOLFSSL_MSG("Stat successful on file");
 472        #ifdef DEBUG_IOTSAFE
 473            printf("File size: %d (%04x)", file_sz, file_sz);
 474        #endif
 475    }
 476
 477    if (file_sz > max_size) {
 478        WOLFSSL_MSG("iotsafe_readfile: insufficient space in buffer");
 479        return -1;
 480    }
 481#endif
 482
 483    while (off < file_sz) {
 484        byte off_p1, off_p2;
 485        off_p1 = (off >> 8) & 0xff;
 486        off_p2 = (off & 0xff);
 487        iotsafe_cmd_start(csim_cmd, IOTSAFE_CLASS, IOTSAFE_INS_READ_FILE,
 488                off_p1, off_p2);
 489        iotsafe_cmd_add_tlv(csim_cmd, IOTSAFE_TAG_FILE_ID, file_id_sz, file_id);
 490        iotsafe_cmd_complete(csim_cmd);
 491        ret = expect_csim_response(csim_cmd, (word32)XSTRLEN(csim_cmd), &resp);
 492        if (ret >= 2) {
 493            if (ret > 2 * (file_sz - off))
 494                ret = 2 * (file_sz - off);
 495            if (hex_to_bytes(resp, content + off, (ret / 2)) < 0) {
 496                return -1;
 497            }
 498            off += ret/2;
 499#ifdef IOTSAFE_NO_GETDATA
 500            if (ret >= 4 && XSTRNCMP(&resp[ret-4], "0000", 4) == 0) {
 501                /* Strip trailing zeros */
 502                int idx = 0;
 503                for (idx = 0; idx < off-1; idx+=2) {
 504                    if (content[idx] == 0 && content[idx+1] == 0) {
 505                        off = idx;
 506#ifdef DEBUG_IOTSAFE
 507                        WOLFSSL_MSG("Stripped trailing zeros from cert buffer.");
 508                        WOLFSSL_BUFFER(content, off);
 509#endif
 510                        break;
 511                    }
 512                }
 513                break;
 514            }
 515#endif
 516        } else {
 517            WOLFSSL_MSG("IoTSafe: Error reading file.");
 518            return -1;
 519        }
 520    }
 521
 522    return off;
 523}
 524
 525static int iotsafe_getrandom(unsigned char* output, unsigned long sz)
 526{
 527    char *resp = NULL;
 528    int ret;
 529    int i;
 530    byte len = (byte)sz;
 531
 532    if (sz == 0 || sz > 255) {
 533        return BAD_FUNC_ARG;
 534    }
 535    if (!wolfIoT_initialized) {
 536        if (iotsafe_init() < 0) {
 537            return WC_HW_E;
 538        }
 539    }
 540
 541    iotsafe_cmd_start(csim_cmd, IOTSAFE_CLASS, IOTSAFE_INS_GETRANDOM,0,0);
 542    bytes_to_hex(&len, csim_cmd + AT_CSIM_CMD_SIZE + AT_CMD_LC_POS, 1);
 543    csim_cmd[AT_CSIM_CMD_SIZE + AT_CMD_HDR_SIZE] = 0;
 544    iotsafe_cmd_complete(csim_cmd);
 545
 546    ret = expect_csim_response(csim_cmd, (word32)GETRAND_CMD_SIZE, &resp);
 547    if (ret <= 0) {
 548        WOLFSSL_MSG("Unexpected reply from RAND");
 549        ret = WC_HW_E;
 550    } else {
 551        ret = hexbuffer_conv(resp, output, sz);
 552        if (ret < 0)
 553            ret = WC_HW_E;
 554        else
 555            ret = 0;
 556    }
 557
 558    /* Send an empty command until the applet is responsive again */
 559    for (i = 0; i < IOTSAFE_MAX_RETRIES; i++) {
 560        (void)expect_tok(NULL, 0, NULL, NULL);
 561    }
 562    return ret;
 563}
 564
 565
 566
 567#ifdef HAVE_ECC
 568
 569static int iotsafe_parse_public_key(char* resp, int len, ecc_key *key)
 570{
 571    int ret;
 572    char *rkey, *ktype, *payload_str;
 573    char Qx[IOTSAFE_ECC_KSIZE * 2 + 1], Qy[IOTSAFE_ECC_KSIZE * 2 + 1];
 574    if (len < IOTSAFE_TAG_ECC_KEY_FIELD_SZ + 2) {
 575        WOLFSSL_MSG("Response from iot-safe: too short");
 576        return BAD_STATE_E;
 577    }
 578    rkey = search_tlv(resp, len, IOTSAFE_TAG_ECC_KEY_FIELD);
 579    if (rkey == NULL) {
 580        WOLFSSL_MSG("IoT safe Error in rkey response");
 581        return MISSING_KEY;
 582    }
 583    ktype = search_tlv(rkey + 4, IOTSAFE_TAG_ECC_KEY_FIELD_SZ,
 584            IOTSAFE_TAG_ECC_KEY_TYPE);
 585    if (ktype == NULL) {
 586        WOLFSSL_MSG("IoT safe Error in ktype response");
 587        return MISSING_KEY;
 588    }
 589    payload_str = search_tlv(ktype + 4, IOTSAFE_TAG_ECC_KEY_TYPE_SZ,
 590            IOTSAFE_TAG_ECC_KEY_XY);
 591    if (payload_str == NULL) {
 592        WOLFSSL_MSG("IoT safe: Error in payload response");
 593        return MISSING_KEY;
 594    }
 595    XMEMSET(Qx, 0, sizeof(Qx));
 596    XMEMSET(Qy, 0, sizeof(Qy));
 597    ret = wc_ecc_init(key);
 598    if (ret < 0) {
 599        WOLFSSL_MSG("Cannot initialize ecc key to store IoTSafe public key");
 600        return -1;
 601    }
 602    if ((int)(payload_str - resp) + 6 + (int)(IOTSAFE_ECC_KSIZE * 4) > len) {
 603        WOLFSSL_MSG("IoT safe: response too short for key data");
 604        wc_ecc_free(key);
 605        return BAD_STATE_E;
 606    }
 607    XSTRNCPY(Qx, payload_str + 6, IOTSAFE_ECC_KSIZE * 2);
 608    XSTRNCPY(Qy, payload_str + 6 + IOTSAFE_ECC_KSIZE * 2, IOTSAFE_ECC_KSIZE * 2);
 609
 610    ret = wc_ecc_import_raw_ex(key, Qx, Qy, NULL, IOTSAFE_ECC_KTYPE);
 611    if (ret < 0) {
 612        WOLFSSL_MSG("Could not import raw key into ecc key");
 613        return ret;
 614    }
 615    WOLFSSL_MSG("Get Public key: OK");
 616    return 0;
 617}
 618
 619/* Execute GEN_KEYPAIR on the IoT-SAFE applet.
 620 *
 621 * Return -1 on error; 0 if the operation is successful, but
 622 * the generated public key was not yet stored in `key`; 1 if
 623 * the operation is successful and the public key was found in the
 624 * command response and copied to the `key` structure, if not NULL.
 625 */
 626static int iotsafe_gen_keypair(byte *wr_slot, unsigned long id_size,
 627                               ecc_key *key)
 628{
 629    char *resp;
 630    int ret = WC_NO_ERR_TRACE(WC_HW_E);
 631    iotsafe_cmd_start(csim_cmd, IOTSAFE_CLASS, IOTSAFE_INS_GEN_KEYPAIR, 0, 0);
 632    iotsafe_cmd_add_tlv(csim_cmd, IOTSAFE_TAG_PRIVKEY_ID, id_size, wr_slot);
 633    iotsafe_cmd_complete(csim_cmd);
 634    ret = expect_csim_response(csim_cmd, (word32)XSTRLEN(csim_cmd), &resp);
 635    if (ret < 1) {
 636        WOLFSSL_MSG("Unexpected reply from Keygen");
 637        ret = WC_HW_E;
 638    } else if (key != NULL) {
 639        if (iotsafe_parse_public_key(resp, ret, key) == 0) {
 640            /* iotsafe_parse_public_key was successful on response.
 641             * Return '1' here to indicate that the key is populated.
 642             */
 643            ret = 1;
 644        } else {
 645            /* The keygen operation was successful but we have not
 646             * retrieved the generated public key yet.
 647             */
 648            ret = 0;
 649        }
 650    } else {
 651        ret = 0;
 652    }
 653    return ret;
 654}
 655
 656static int iotsafe_get_public_key(byte *pubkey_id, unsigned long id_size,
 657        ecc_key *key)
 658{
 659    int ret;
 660    char *resp;
 661
 662    /* exporting generated public key */
 663    iotsafe_cmd_start(csim_cmd, IOTSAFE_CLASS, IOTSAFE_INS_READ_KEY,0, 0);
 664    iotsafe_cmd_add_tlv(csim_cmd, IOTSAFE_TAG_PUBKEY_ID, id_size, pubkey_id);
 665    iotsafe_cmd_complete(csim_cmd);
 666    ret = expect_csim_response(csim_cmd, (word32)XSTRLEN(csim_cmd), &resp);
 667    if (ret < 1) {
 668        WOLFSSL_MSG("Error exporting EPH public key from IoT-Safe");
 669        return WC_HW_E;
 670    }
 671
 672    return iotsafe_parse_public_key(resp, ret, key);
 673}
 674
 675#define PUT_PK_SID 0x02
 676static int iotsafe_put_public_key(byte *pubkey_id, unsigned long id_size,
 677        ecc_key *key)
 678{
 679    char *resp;
 680    int ret;
 681    int retries = 0;
 682    word32 qxlen = IOTSAFE_ECC_KSIZE, qylen = IOTSAFE_ECC_KSIZE;
 683    byte ecc_pub_raw[IOTSAFE_TAG_ECC_KEY_FIELD_SZ] =  {
 684        IOTSAFE_TAG_ECC_KEY_TYPE,
 685        IOTSAFE_TAG_ECC_KEY_TYPE_SZ,
 686        IOTSAFE_TAG_ECC_KEY_XY,
 687        IOTSAFE_TAG_ECC_KEY_XY_SZ,
 688        IOTSAFE_TAG_ECC_KEY_XY_HDR_BYTE
 689    };
 690
 691    /* Export raw Qx, Qy values */
 692    ret = wc_ecc_export_public_raw(key,
 693        ecc_pub_raw + 5, &qxlen,
 694        ecc_pub_raw + 5 + IOTSAFE_ECC_KSIZE, &qylen);
 695    if (ret != 0) {
 696        WOLFSSL_MSG("IoT Safe: Could not export public key: Error");
 697        return ret;
 698    }
 699
 700    /* Put Public Init */
 701    iotsafe_cmd_start(csim_cmd, IOTSAFE_CLASS, IOTSAFE_INS_PUT_PUBLIC_INIT,
 702            0, PUT_PK_SID);
 703    iotsafe_cmd_add_tlv(csim_cmd, IOTSAFE_TAG_PUBKEY_ID, id_size, pubkey_id);
 704    iotsafe_cmd_complete(csim_cmd);
 705    if (expect_ok(csim_cmd, (word32)XSTRLEN(csim_cmd)) < 0) {
 706        WOLFSSL_MSG("Unexpected reply when storing public key");
 707        return WC_HW_E;
 708    }
 709
 710    do {
 711        ret = expect_ok("AT\r\n", 4);
 712        if (ret == 0) {
 713            if (++retries > IOTSAFE_MAX_RETRIES)
 714                return WC_HW_E;
 715        }
 716    } while (ret == 0);
 717    retries = 0;
 718
 719    if (ret > 0) {
 720        /* Put Public Update */
 721        iotsafe_cmd_start(csim_cmd, IOTSAFE_CLASS, IOTSAFE_INS_PUT_PUBLIC_UPDATE,
 722                IOTSAFE_DATA_LAST, PUT_PK_SID);
 723        iotsafe_cmd_add_tlv(csim_cmd, IOTSAFE_TAG_ECC_KEY_FIELD,
 724                IOTSAFE_TAG_ECC_KEY_FIELD_SZ, ecc_pub_raw);
 725        iotsafe_cmd_complete(csim_cmd);
 726        if (expect_csim_response(csim_cmd,
 727                    (word32)XSTRLEN(csim_cmd), &resp) < 0) {
 728            WOLFSSL_MSG("Unexpected reply when storing public key (update)");
 729            ret = WC_HW_E;
 730        } else {
 731            iotsafe_cmd_start(csim_cmd, IOTSAFE_CLASS,
 732                IOTSAFE_INS_PUT_PUBLIC_INIT, 1, PUT_PK_SID);
 733            iotsafe_cmd_complete(csim_cmd);
 734            if (expect_ok(csim_cmd, (word32)XSTRLEN(csim_cmd)) < 0) {
 735                ret = WC_HW_E;
 736            } else {
 737                ret = 0;
 738            }
 739            do {
 740                ret = expect_ok("AT\r\n", 4);
 741                if (ret == 0) {
 742                    if (++retries > IOTSAFE_MAX_RETRIES)
 743                        ret = WC_HW_E;
 744                }
 745            } while (ret == 0);
 746            if (ret > 0)
 747                ret = 0;
 748        }
 749    }
 750    return ret;
 751}
 752#ifdef HAVE_HKDF
 753static int iotsafe_hkdf_extract(byte* prk, const byte* salt, word32 saltLen,
 754       byte* ikm, word32 ikmLen, int digest)
 755{
 756    int ret;
 757    char *resp;
 758    uint16_t hash_algo = 0;
 759    int hash_len;
 760    uint16_t hash_algo_be = 0;
 761
 762    WOLFSSL_MSG("Enter iotsafe_hkdf_extract");
 763    switch (digest) {
 764#ifndef NO_SHA256
 765        case WC_SHA256:
 766            hash_algo = (uint16_t)1;
 767            hash_len = WC_SHA256_DIGEST_SIZE;
 768            break;
 769#endif
 770#ifdef WOLFSSL_SHA384
 771        case WC_SHA384:
 772            hash_algo = (uint16_t)2;
 773            hash_len = WC_SHA384_DIGEST_SIZE;
 774            break;
 775#endif
 776#ifdef WOLFSSL_SHA512
 777        case WC_SHA512:
 778            hash_algo = (uint16_t)4;
 779            hash_len = WC_SHA512_DIGEST_SIZE;
 780            break;
 781#endif
 782        default:
 783            return BAD_FUNC_ARG;
 784            break;
 785    }
 786
 787    if (ikmLen == 0) {
 788        ikmLen = hash_len;
 789        XMEMSET(ikm, 0, hash_len);
 790    }
 791
 792#ifdef DEBUG_IOTSAFE
 793    printf("IOTSAFE PK HKDF Extract\n");
 794    printf("salt: ");
 795    for(word32 i = 0; i < saltLen; i++)
 796        printf("%02X", salt[i]);
 797
 798    printf("\nikm: ");
 799    for(word32 i = 0; i < ikmLen; i++)
 800        printf("%02X", ikm[i]);
 801
 802    printf("\nhash: %d\n", digest);
 803#endif
 804
 805    hash_algo_be = XHTONS(hash_algo);
 806
 807    iotsafe_cmd_start(csim_cmd, IOTSAFE_CLASS, IOTSAFE_INS_HKDF_EXTRACT, 0, 0);
 808    iotsafe_cmd_add_tlv(csim_cmd, IOTSAFE_TAG_SECRET, ikmLen, ikm);
 809    iotsafe_cmd_add_tlv(csim_cmd, IOTSAFE_TAG_SALT, saltLen,salt);
 810    iotsafe_cmd_add_tlv(csim_cmd, IOTSAFE_TAG_HASH_ALGO, 2, (const byte*)&hash_algo_be);
 811    iotsafe_cmd_complete(csim_cmd);
 812    if (expect_csim_response(csim_cmd, (word32)XSTRLEN(csim_cmd), &resp) < 1) {
 813        WOLFSSL_MSG("Unexpected reply from HKDF extract");
 814        ret = WC_HW_E;
 815    } else {
 816        ret = hexbuffer_conv(resp, prk, hash_len);
 817        if (ret < 0)
 818            ret = WC_HW_E;
 819        else
 820            ret = 0;
 821    }
 822    return ret;
 823}
 824#endif
 825
 826static int iotsafe_sign_hash(byte *privkey_idx, uint16_t id_size,
 827        uint16_t hash_algo, uint8_t sign_algo, const byte *hash, word32 hashLen,
 828        byte *signature, word32 *sigLen)
 829{
 830    byte mode_of_operation = IOTSAFE_MOO_SIGN_ONLY;
 831    uint16_t hash_algo_be = XHTONS(hash_algo);
 832    int ret = WC_NO_ERR_TRACE(WC_HW_E);
 833    char *resp;
 834    char R[2 * IOTSAFE_ECC_KSIZE + 1];
 835    char S[2 * IOTSAFE_ECC_KSIZE + 1];
 836    int retries = 0;
 837
 838    R[2*IOTSAFE_ECC_KSIZE] = '\0';
 839    S[2*IOTSAFE_ECC_KSIZE] = '\0';
 840
 841    WOLFSSL_MSG("Enter iotsafe_sign_hash");
 842
 843    iotsafe_cmd_start(csim_cmd, IOTSAFE_CLASS, IOTSAFE_INS_SIGN_INIT, 0, 1);
 844    iotsafe_cmd_add_tlv(csim_cmd, IOTSAFE_TAG_PRIVKEY_ID, id_size, privkey_idx);
 845    iotsafe_cmd_add_tlv(csim_cmd, IOTSAFE_TAG_MODE_OF_OPERATION, 1,
 846            &mode_of_operation);
 847    iotsafe_cmd_add_tlv(csim_cmd, IOTSAFE_TAG_HASH_ALGO, 2,
 848            (byte *)&hash_algo_be);
 849    iotsafe_cmd_add_tlv(csim_cmd, IOTSAFE_TAG_SIGN_ALGO, 1, &sign_algo);
 850    iotsafe_cmd_complete(csim_cmd);
 851
 852    if (sign_algo == IOTSAFE_SIGN_ECDSA) {
 853        if (*sigLen < 2 * IOTSAFE_ECC_KSIZE) {
 854            return -1;
 855        }
 856        if (expect_ok(csim_cmd, (word32)XSTRLEN(csim_cmd)) < 0) {
 857            WOLFSSL_MSG("Unexpected reply from IoTsafe EC sign");
 858            return WC_HW_E;
 859        }
 860        do {
 861            ret = expect_ok("AT\r\n", 4);
 862            if (ret == 0) {
 863                if (++retries > IOTSAFE_MAX_RETRIES)
 864                    return WC_HW_E;
 865            }
 866        } while (ret == 0);
 867        if (ret < 0)
 868            return WC_HW_E;
 869        retries = 0;
 870
 871        /* Compose sign_update message with hash to sign */
 872        iotsafe_cmd_start(csim_cmd, IOTSAFE_CLASS,
 873                IOTSAFE_INS_SIGN_UPDATE,
 874                IOTSAFE_DATA_LAST,
 875                0x01);
 876        iotsafe_cmd_add_tlv(csim_cmd, IOTSAFE_TAG_HASH_FIELD, hashLen, hash);
 877        iotsafe_cmd_complete(csim_cmd);
 878
 879        ret = expect_csim_response(csim_cmd, (word32)XSTRLEN(csim_cmd), &resp);
 880        if (ret >= 0) {
 881            byte sig_hdr[3];
 882            if (hex_to_bytes(resp, sig_hdr, 3) < 0) {
 883               ret = BAD_FUNC_ARG;
 884            }
 885#ifdef IOTSAFE_SIG_8BIT_LENGTH
 886            else if ((sig_hdr[0] == IOTSAFE_TAG_SIGNATURE_FIELD) &&
 887                       (sig_hdr[1] == 2 * IOTSAFE_ECC_KSIZE)) {
 888                if (ret < 4 + (int)(IOTSAFE_ECC_KSIZE * 4)) {
 889                    ret = WC_HW_E;
 890                } else {
 891                    XSTRNCPY(R, resp + 4, IOTSAFE_ECC_KSIZE * 2);
 892                    XSTRNCPY(S, resp + 4 + IOTSAFE_ECC_KSIZE * 2,
 893                            IOTSAFE_ECC_KSIZE * 2);
 894                    ret = wc_ecc_rs_to_sig(R, S, signature, sigLen);
 895                }
 896            }
 897#endif
 898            else if ((sig_hdr[0] == IOTSAFE_TAG_SIGNATURE_FIELD) &&
 899                       (sig_hdr[1] == 0) &&
 900                       (sig_hdr[2] == 2 * IOTSAFE_ECC_KSIZE)) {
 901                if (ret < 6 + (int)(IOTSAFE_ECC_KSIZE * 4)) {
 902                    ret = WC_HW_E;
 903                } else {
 904                    XSTRNCPY(R, resp + 6, IOTSAFE_ECC_KSIZE * 2);
 905                    XSTRNCPY(S, resp + 6 + IOTSAFE_ECC_KSIZE * 2,
 906                            IOTSAFE_ECC_KSIZE * 2);
 907                    ret = wc_ecc_rs_to_sig(R, S, signature, sigLen);
 908                }
 909            } else {
 910                ret = WC_HW_E;
 911                WOLFSSL_MSG("Invalid response from EC sign update");
 912            }
 913        } else {
 914            WOLFSSL_MSG("Invalid/no response from EC sign update");
 915        }
 916
 917        /* Terminate sign/sign session. */
 918        iotsafe_cmd_start(csim_cmd, IOTSAFE_CLASS, IOTSAFE_INS_SIGN_INIT, 1, 1);
 919        iotsafe_cmd_complete(csim_cmd);
 920        if (expect_ok(csim_cmd, (word32)XSTRLEN(csim_cmd)) < 0) {
 921            ret = WC_HW_E;
 922        }
 923        do {
 924            ret = expect_ok("AT\r\n", 4);
 925            if (ret == 0) {
 926                if (++retries > IOTSAFE_MAX_RETRIES)
 927                    ret = WC_HW_E;
 928            }
 929        } while (ret == 0);
 930        if (ret < 0)
 931            return WC_HW_E;
 932        else
 933            ret = 0;
 934    } else {
 935        ret = NOT_COMPILED_IN; /* RSA not yet supported */
 936    }
 937    WOLFSSL_MSG("iotsafe_sign_hash return point");
 938    return ret;
 939}
 940
 941static int iotsafe_verify_hash(byte *pubkey_idx, uint16_t id_size,
 942        uint16_t hash_algo, uint8_t sign_algo,
 943        const byte *hash, word32 hashLen,
 944        const byte *sig, word32 sigLen,
 945        int *result)
 946{
 947    byte mode_of_operation = IOTSAFE_MOO_SIGN_ONLY;
 948    uint16_t hash_algo_be = XHTONS(hash_algo);
 949    int ret = 1;
 950    char *resp;
 951    int retries = 0;
 952    *result = 0;
 953
 954    iotsafe_cmd_start(csim_cmd, IOTSAFE_CLASS, IOTSAFE_INS_VERIFY_INIT, 0, 1);
 955    iotsafe_cmd_add_tlv(csim_cmd, IOTSAFE_TAG_PUBKEY_ID, id_size, pubkey_idx);
 956    iotsafe_cmd_add_tlv(csim_cmd, IOTSAFE_TAG_MODE_OF_OPERATION, 1,
 957            &mode_of_operation);
 958    iotsafe_cmd_add_tlv(csim_cmd, IOTSAFE_TAG_HASH_ALGO, 2,
 959            (byte *)&hash_algo_be);
 960    iotsafe_cmd_add_tlv(csim_cmd, IOTSAFE_TAG_SIGN_ALGO, 1, &sign_algo);
 961    iotsafe_cmd_complete(csim_cmd);
 962
 963    if (sign_algo == IOTSAFE_SIGN_ECDSA) {
 964        if (expect_ok(csim_cmd, (word32)XSTRLEN(csim_cmd)) < 0) {
 965            WOLFSSL_MSG("Unexpected reply from IoTsafe EC verify");
 966            return WC_HW_E;
 967        }
 968        do {
 969            ret = expect_ok("AT\r\n", 4);
 970            if (ret == 0) {
 971                if (++retries > IOTSAFE_MAX_RETRIES)
 972                    return WC_HW_E;
 973            }
 974        } while (ret == 0);
 975        if (ret < 0)
 976            return WC_HW_E;
 977        retries = 0;
 978
 979        /* Compose verify_update message with hash + signature */
 980        iotsafe_cmd_start(csim_cmd, IOTSAFE_CLASS,
 981                IOTSAFE_INS_VERIFY_UPDATE,
 982                IOTSAFE_DATA_LAST,
 983                0x01);
 984        iotsafe_cmd_add_tlv(csim_cmd, IOTSAFE_TAG_HASH_FIELD, hashLen, hash);
 985        iotsafe_cmd_add_tlv16(csim_cmd, IOTSAFE_TAG_SIGNATURE_FIELD,
 986                sigLen,sig);
 987        iotsafe_cmd_complete(csim_cmd);
 988
 989        ret = expect_csim_response(csim_cmd, (word32)XSTRLEN(csim_cmd), &resp);
 990        if (ret < 0) {
 991            WOLFSSL_MSG("Invalid response from EC verify update");
 992        } else if (ret > 0) {
 993            if (XSTRCMP("6D01", resp) == 0) {
 994                WOLFSSL_MSG("Invalid signature!");
 995                /* 6D01 : Invalid signature. Return 0 and set *result to 0 */
 996                *result = 0;
 997                ret = 0;
 998            } else {
 999                ret = WC_HW_E; /* IoT-safe bus error */
1000            }
1001        }
1002        else if (ret == 0) {
1003            *result = 1;
1004            ret = 0;
1005        }
1006
1007        /* Terminate sign/verify session. */
1008        iotsafe_cmd_start(csim_cmd, IOTSAFE_CLASS, IOTSAFE_INS_VERIFY_INIT,1,1);
1009        iotsafe_cmd_complete(csim_cmd);
1010        if (expect_ok(csim_cmd, (word32)XSTRLEN(csim_cmd)) < 0) {
1011            *result = 0;
1012            ret = WC_HW_E;
1013        }
1014
1015        do {
1016            ret = expect_ok("AT\r\n", 4);
1017            if (ret == 0) {
1018                if (++retries > IOTSAFE_MAX_RETRIES)
1019                    return WC_HW_E;
1020            }
1021        } while (ret == 0);
1022        if (ret < 0) {
1023            return WC_HW_E;
1024        } else {
1025            ret = 0;
1026        }
1027        retries = 0;
1028    } else {
1029        /* TODO: RSA */
1030        ret = NOT_COMPILED_IN;
1031    }
1032    return ret;
1033}
1034
1035
1036/*
1037 * Callbacks for IoT-Safe ECC/ECDH functions
1038 *
1039 *
1040 */
1041
1042#ifndef IOTSAFE_ID_SIZE
1043#   define IOTSAFE_ID_SIZE (1)
1044#endif
1045
1046#ifdef HAVE_PK_CALLBACKS
1047static int wolfIoT_ecc_keygen(WOLFSSL* ssl, struct ecc_key* key,
1048    unsigned int keySz, int ecc_curve, void* ctx)
1049{
1050    int ret;
1051    IOTSAFE *iotsafe = wolfSSL_get_iotsafe_ctx(ssl);
1052
1053    if (iotsafe == NULL) {
1054        return BAD_FUNC_ARG;
1055    }
1056    WOLFSSL_MSG("IOTSAFE: Called wolfIoT_ecc_keygen");
1057
1058#ifdef DEBUG_IOTSAFE
1059    printf("IOTSAFE PK ECC KeyGen: keySz %d, Curve ID %d, Slot %d\n",
1060        keySz, ecc_curve, iotsafe->ecdh_keypair_slot);
1061#endif
1062
1063    if (iotsafe->enabled) {
1064        ret = iotsafe_gen_keypair((byte *)&iotsafe->ecdh_keypair_slot,
1065                IOTSAFE_ID_SIZE, key);
1066        if (ret == 0) {
1067            ret = iotsafe_get_public_key((byte *)&iotsafe->ecdh_keypair_slot,
1068                    IOTSAFE_ID_SIZE, key);
1069        } else if (ret > 0) {
1070            /* Key has been stored during generation */
1071            ret = 0;
1072        }
1073    } else {
1074        WC_RNG *rng = wolfSSL_GetRNG(ssl);
1075        ret = wc_ecc_init(key);
1076        if (ret == 0) {
1077            /* create new key */
1078            ret = wc_ecc_make_key_ex(rng, keySz, key, ecc_curve);
1079        }
1080    }
1081    (void)ctx;
1082    return ret;
1083}
1084
1085#ifdef HAVE_HKDF
1086/* ikm will not be NULL. */
1087static int wolfIoT_hkdf_extract(byte* prk, const byte* salt, word32 saltLen,
1088       byte* ikm, word32 ikmLen, int digest, void* ctx)
1089{
1090    int ret;
1091    const  byte* localSalt;  /* either points to user input or tmp */
1092    byte tmp[WC_MAX_DIGEST_SIZE]; /* localSalt helper */
1093
1094    WOLFSSL_MSG("IOTSAFE: Called wolfIoT_hkdf_extract\n");
1095
1096    localSalt = salt;
1097
1098    if (saltLen == 0) {
1099        ret = wc_HmacSizeByType(digest);
1100            if (ret < 0)
1101                return ret;
1102            saltLen = ret;
1103            if (localSalt == NULL) {
1104                XMEMSET(tmp, 0, saltLen);
1105                localSalt = tmp;
1106            }
1107    }
1108
1109    ret = iotsafe_hkdf_extract(prk, localSalt, saltLen, ikm, ikmLen, digest);
1110    (void)ctx;
1111    return ret;
1112}
1113#endif
1114
1115static int wolfIoT_ecc_sign(WOLFSSL* ssl,
1116       const unsigned char* in, unsigned int inSz,
1117       unsigned char* out, word32* outSz,
1118       const unsigned char* keyDer, unsigned int keySz,
1119       void* ctx)
1120{
1121    int ret;
1122    IOTSAFE *iotsafe = wolfSSL_get_iotsafe_ctx(ssl);
1123    WC_RNG    *rng;
1124    word32    idx = 0;
1125    ecc_key   *myKey;
1126    byte*     keyBuf = (byte*)keyDer;
1127#ifndef WOLFSSL_SMALL_STACK
1128    ecc_key _myKey;
1129#endif
1130
1131    if (iotsafe == NULL) {
1132        return BAD_FUNC_ARG;
1133    }
1134    WOLFSSL_MSG("IOTSAFE: Called wolfIoT_ecc_sign");
1135
1136#ifdef DEBUG_IOTSAFE
1137    printf("IOTSAFE PK ECC Sign: InSz %d, KeySz %d\n", inSz, keySz);
1138#endif
1139
1140    if (iotsafe->enabled) {
1141        ret = iotsafe_sign_hash((byte *)&iotsafe->privkey_id, IOTSAFE_ID_SIZE,
1142                IOTSAFE_HASH_SHA256,
1143                IOTSAFE_SIGN_ECDSA,
1144                in, inSz, out, outSz);
1145        return ret;
1146    }
1147
1148#ifndef WOLFSSL_SMALL_STACK
1149    myKey = &_myKey;
1150#else
1151    myKey = (ecc_key*)XMALLOC(sizeof(ecc_key), NULL, DYNAMIC_TYPE_ECC);
1152    if (myKey == NULL)
1153        return MEMORY_E;
1154#endif
1155
1156    rng = wolfSSL_GetRNG(ssl);
1157    ret = wc_ecc_init(myKey);
1158    if (ret == 0)
1159        ret = wc_EccPrivateKeyDecode(keyBuf, &idx, myKey, keySz);
1160    if (ret == 0)
1161        ret = wc_ecc_sign_hash(in, inSz, out, outSz, rng, myKey);
1162    wc_ecc_free(myKey);
1163    WC_FREE_VAR_EX(myKey, NULL, DYNAMIC_TYPE_ECC);
1164
1165    (void)ctx;
1166    return ret;
1167}
1168
1169static int wolfIoT_ecc_verify(WOLFSSL *ssl,
1170       const unsigned char* sig, unsigned int sigSz,
1171       const unsigned char* hash, unsigned int hashSz,
1172       const unsigned char* keyDer, unsigned int keySz,
1173       int* result, void* ctx)
1174{
1175
1176    int ret;
1177    ecc_key *key;
1178    word32 r_size = IOTSAFE_ECC_KSIZE, s_size = IOTSAFE_ECC_KSIZE;
1179    uint16_t id_size = IOTSAFE_ID_SIZE;
1180    word32 inOutIdx = 0;
1181    IOTSAFE *iotsafe = wolfSSL_get_iotsafe_ctx(ssl);
1182    byte *pubkey_slot;
1183    byte *sig_raw;
1184#ifndef WOLFSSL_SMALL_STACK
1185    byte _sig_raw[IOTSAFE_ECC_KSIZE* 2];
1186    ecc_key _key;
1187
1188    sig_raw = _sig_raw;
1189    key = &_key;
1190#endif
1191
1192    if (iotsafe == NULL) {
1193        return BAD_FUNC_ARG;
1194    }
1195
1196    pubkey_slot = (byte *)&iotsafe->peer_cert_slot;
1197
1198    WOLFSSL_MSG("IOTSAFE: Called wolfIoT_ecc_verify");
1199
1200#ifdef DEBUG_IOTSAFE
1201    printf("IOTSAFE PK ECC Verify: SigSz %d, HashSz %d, KeySz %d, Slot %d\n",
1202        sigSz, hashSz, keySz, *pubkey_slot);
1203#endif
1204
1205    /* Invalidate verification, by default. */
1206    *result = 0;
1207
1208#ifdef WOLFSSL_SMALL_STACK
1209    sig_raw = (byte*)XMALLOC(IOTSAFE_ECC_KSIZE * 2, NULL, DYNAMIC_TYPE_SIGNATURE);
1210    if (sig_raw == NULL)
1211        return MEMORY_E;
1212    key = (ecc_key*)XMALLOC(sizeof(ecc_key), NULL, DYNAMIC_TYPE_ECC);
1213    if (key == NULL) {
1214        XFREE(sig_raw, NULL, DYNAMIC_TYPE_SIGNATURE);
1215        return MEMORY_E;
1216    }
1217#endif
1218    ret = wc_ecc_init(key);
1219    if (ret != 0) {
1220        WC_FREE_VAR_EX(key, NULL, DYNAMIC_TYPE_ECC);
1221        WC_FREE_VAR_EX(sig_raw, NULL, DYNAMIC_TYPE_SIGNATURE);
1222        return ret;
1223    }
1224
1225    if (iotsafe->enabled) {
1226        /* Store the server's public key in IoT-safe vault
1227         * Create an ecc object to handle the key */
1228
1229        /* Convert ECC signature into R,S */
1230        ret = wc_ecc_sig_to_rs(sig, sigSz,
1231            sig_raw, &r_size,
1232            sig_raw + IOTSAFE_ECC_KSIZE, &s_size);
1233        if (ret == 0) {
1234            /* Import from keyDer argument */
1235            ret = wc_EccPublicKeyDecode(keyDer, &inOutIdx, key, keySz);
1236        }
1237        if (ret == 0) {
1238            /* Store public key in IoT-safe slot */
1239            ret = iotsafe_put_public_key(pubkey_slot, id_size, key);
1240            if (ret < 0) {
1241            #ifdef DEBUG_IOTSAFE
1242                printf("IOTSAFE: put public key failed\n");
1243            #endif
1244            }
1245        }
1246        if (ret == 0) {
1247            /* Call iotsafe_verify_hash with ECC256 + SHA256 */
1248            ret = iotsafe_verify_hash(pubkey_slot, id_size,
1249                    IOTSAFE_HASH_SHA256, IOTSAFE_SIGN_ECDSA,
1250                    hash, hashSz, sig_raw, 2 * IOTSAFE_ECC_KSIZE,
1251                    result);
1252        }
1253    }
1254    else {
1255        ret = wc_EccPublicKeyDecode(keyDer, &inOutIdx, key, keySz);
1256        if (ret == 0) {
1257            ret = wc_ecc_verify_hash(sig, sigSz, hash, hashSz, result, key);
1258        }
1259    }
1260    wc_ecc_free(key);
1261    WC_FREE_VAR_EX(key, NULL, DYNAMIC_TYPE_ECC);
1262    WC_FREE_VAR_EX(sig_raw, NULL, DYNAMIC_TYPE_SIGNATURE);
1263    (void)ctx;
1264    return ret;
1265}
1266
1267static int wolfIoT_ecc_shared_secret(WOLFSSL* ssl, struct ecc_key* otherKey,
1268        unsigned char* pubKeyDer, word32* pubKeySz,
1269        unsigned char* out, word32* outlen,
1270        int side, void* ctx)
1271{
1272    int ret;
1273    char *resp;
1274    ecc_key *tmpKey;
1275    IOTSAFE *iotsafe = wolfSSL_get_iotsafe_ctx(ssl);
1276    byte *keypair_slot;
1277    byte *pubkey_idx;
1278    int retries = 0;
1279#ifndef WOLFSSL_SMALL_STACK
1280    ecc_key _tmpKey;
1281    tmpKey = &_tmpKey;
1282#endif
1283
1284    if (iotsafe == NULL) {
1285        return BAD_FUNC_ARG;
1286    }
1287
1288    WOLFSSL_MSG("IOTSAFE: Called wolfIoT_ecc_shared_secret");
1289
1290#ifdef DEBUG_IOTSAFE
1291    printf("IOTSAFE PK ECC PMS: Side %s, Peer Curve %d\n",
1292        side == WOLFSSL_CLIENT_END ? "client" : "server", otherKey->dp->id);
1293#endif
1294
1295    WC_ALLOC_VAR_EX(tmpKey, ecc_key, 1, NULL, DYNAMIC_TYPE_ECC,
1296        return MEMORY_E);
1297    ret = wc_ecc_init(tmpKey);
1298    if (ret != 0) {
1299        WC_FREE_VAR_EX(tmpKey, NULL, DYNAMIC_TYPE_ECC);
1300        return ret;
1301    }
1302
1303    if (iotsafe->enabled) {
1304        uint16_t id_size = IOTSAFE_ID_SIZE;
1305        keypair_slot = (byte *)(&iotsafe->ecdh_keypair_slot);
1306        pubkey_idx = (byte *)(&iotsafe->peer_pubkey_slot);
1307
1308        /* TLS v1.3 calls key gen already, so don't do it here */
1309        if (wolfSSL_GetVersion(ssl) < WOLFSSL_TLSV1_3) {
1310            WOLFSSL_MSG("Generating ECDH key pair");
1311            ret = iotsafe_gen_keypair(keypair_slot, id_size, tmpKey);
1312            if (ret < 0) {
1313                WOLFSSL_MSG("Error generating IoT-safe key pair");
1314            }
1315            if (ret == 0) {
1316                WOLFSSL_MSG("Public key not yet retrieved, using GetPublic");
1317                /* Importing generated public key */
1318                ret = iotsafe_get_public_key(keypair_slot, id_size, tmpKey);
1319                if (ret < 0) {
1320                    WOLFSSL_MSG("Error retrieving public key via GetPublic");
1321                    ret = WC_HW_E;
1322                }
1323            } else if (ret == 1) {
1324               ret = 0;
1325            }
1326            if (ret == 0) {
1327                /* Exporting generated public key into DER buffer */
1328                ret = wc_ecc_export_x963(tmpKey, pubKeyDer, pubKeySz);
1329                if (ret == 0) {
1330                    WOLFSSL_MSG(
1331                            "IoT-SAFE: Key pair generated, public key exported");
1332                } else {
1333                    WOLFSSL_MSG("IoT-SAFE: Error storing Public key.");
1334                }
1335            }
1336        }
1337
1338        if (ret == 0) {
1339            /* Store received public key from other endpoint in applet */
1340            ret = iotsafe_put_public_key(pubkey_idx, id_size, otherKey);
1341            if (ret < 0) {
1342                WOLFSSL_MSG("IoT-SAFE: Error in PutPublic");
1343            }
1344        }
1345        if (ret == 0) {
1346            do {
1347                ret = expect_ok("AT\r\n", 4);
1348                if (ret == 0) {
1349                    if (++retries > IOTSAFE_MAX_RETRIES)
1350                        ret = WC_HW_E;
1351                }
1352            } while (ret == 0);
1353            if (ret > 0) {
1354                /* Generating shared secret
1355                */
1356                iotsafe_cmd_start(csim_cmd, IOTSAFE_CLASS, IOTSAFE_INS_COMPUTE_DH,
1357                        0, 0);
1358                iotsafe_cmd_add_tlv(csim_cmd, IOTSAFE_TAG_PRIVKEY_ID,
1359                        IOTSAFE_ID_SIZE, keypair_slot);
1360                iotsafe_cmd_add_tlv(csim_cmd, IOTSAFE_TAG_PUBKEY_ID,
1361                        IOTSAFE_ID_SIZE, pubkey_idx);
1362                iotsafe_cmd_complete(csim_cmd);
1363                ret = expect_csim_response(csim_cmd, (word32)XSTRLEN(csim_cmd),
1364                        &resp);
1365            }
1366        }
1367        if (ret <= 0) {
1368            WOLFSSL_MSG("Unexpected reply in ECDH command");
1369            ret = WC_HW_E;
1370        } else if ((word32)(ret / 2) > *outlen) {
1371            ret = BUFFER_E;
1372        } else {
1373            int out_len = hex_to_bytes(resp, out, ret / 2);
1374            if (out_len < 0) {
1375                ret = BAD_FUNC_ARG;
1376            } else {
1377                *outlen = (word32)out_len;
1378                ret = 0;
1379            }
1380        }
1381    } else {
1382        ecc_key*  privKey = NULL;
1383        ecc_key*  pubKey = NULL;
1384        /* for client: create and export public key */
1385        if (side == WOLFSSL_CLIENT_END) {
1386            privKey = tmpKey;
1387            pubKey = otherKey;
1388
1389            /* TLS v1.3 calls key gen already, so don't do it here */
1390            if (wolfSSL_GetVersion(ssl) < WOLFSSL_TLSV1_3) {
1391                WC_RNG *rng = wolfSSL_GetRNG(ssl);
1392                ret = wc_ecc_make_key_ex(rng, 0, privKey, otherKey->dp->id);
1393                if (ret == 0) {
1394                    ret = wc_ecc_export_x963(privKey, pubKeyDer, pubKeySz);
1395                }
1396            }
1397        }
1398        /* for server: import public key */
1399        else if (side == WOLFSSL_SERVER_END) {
1400            privKey = otherKey;
1401            pubKey = tmpKey;
1402
1403            ret = wc_ecc_import_x963_ex(pubKeyDer, *pubKeySz, pubKey,
1404                    otherKey->dp->id);
1405        }
1406        else {
1407            ret = BAD_FUNC_ARG;
1408        }
1409        /* generate shared secret and return it */
1410        if (ret == 0) {
1411            ret = wc_ecc_shared_secret(privKey, pubKey, out, outlen);
1412        }
1413    }
1414    wc_ecc_free(tmpKey);
1415    WC_FREE_VAR_EX(tmpKey, NULL, DYNAMIC_TYPE_ECC);
1416    (void)ctx;
1417    return ret;
1418}
1419
1420#ifndef NO_DH
1421/* Public DH Key Callback support */
1422static int wolfIoT_dh_agree(WOLFSSL* ssl, struct DhKey* key,
1423        const unsigned char* priv, unsigned int privSz,
1424        const unsigned char* otherPubKeyDer, unsigned int otherPubKeySz,
1425        unsigned char* out, word32* outlen,
1426        void* ctx)
1427{
1428
1429    WOLFSSL_MSG("IOTSAFE: Called wolfIoT_ecc_dh_agree");
1430    (void)ctx;
1431    (void)ssl;
1432    (void)key;
1433    (void)priv;
1434    (void)privSz;
1435    (void)otherPubKeyDer;
1436    (void)otherPubKeySz;
1437    (void)out;
1438    (void)outlen;
1439
1440    /* return an error to notify user this function
1441     * is not yet implemented
1442     */
1443    return WC_HW_E;
1444}
1445#endif /* ! NO_DH */
1446
1447#endif /* HAVE_PK_CALLBACKS */
1448
1449/* Public API for ecc */
1450
1451int wc_iotsafe_ecc_import_public_ex(ecc_key *key, byte *key_id, uint16_t id_size)
1452{
1453    return iotsafe_get_public_key(key_id, id_size, key);
1454}
1455
1456int wc_iotsafe_ecc_export_public_ex(ecc_key *key, byte *key_id, uint16_t id_size)
1457{
1458    return iotsafe_put_public_key(key_id, id_size, key);
1459}
1460
1461int wc_iotsafe_ecc_sign_hash_ex(byte *in, word32 inlen, byte *out,
1462        word32 *outlen, byte *key_id, uint16_t id_size)
1463{
1464    return iotsafe_sign_hash(key_id, id_size, IOTSAFE_HASH_SHA256,
1465            IOTSAFE_SIGN_ECDSA, in, inlen, out, outlen);
1466}
1467
1468int wc_iotsafe_ecc_verify_hash_ex(byte *sig, word32 siglen, byte *hash,
1469        word32 hashlen, int *res, byte *key_id, uint16_t id_size)
1470{
1471    int ret;
1472    word32 r_size = IOTSAFE_ECC_KSIZE;
1473    word32 s_size = IOTSAFE_ECC_KSIZE;
1474    byte sig_raw[IOTSAFE_ECC_KSIZE * 2];
1475
1476    /* Invalidate result, by default. */
1477    *res = 0;
1478
1479    /* Convert ECC signature into R,S */
1480    ret = wc_ecc_sig_to_rs(sig, siglen, sig_raw, &r_size, sig_raw
1481            + IOTSAFE_ECC_KSIZE, &s_size);
1482    if (ret == 0)
1483        ret = iotsafe_verify_hash(key_id, id_size, IOTSAFE_HASH_SHA256,
1484                IOTSAFE_SIGN_ECDSA, hash, hashlen, sig_raw, 2 * IOTSAFE_ECC_KSIZE,
1485                res);
1486    return ret;
1487}
1488
1489int wc_iotsafe_ecc_gen_k_ex(byte *key_id, uint16_t id_size)
1490{
1491    return iotsafe_gen_keypair(key_id, id_size, NULL);
1492}
1493
1494int wc_iotsafe_ecc_import_public(ecc_key *key, byte key_id)
1495{
1496    return iotsafe_get_public_key(&key_id, 1, key);
1497}
1498
1499int wc_iotsafe_ecc_export_public(ecc_key *key, byte key_id)
1500{
1501    return iotsafe_put_public_key(&key_id, 1, key);
1502}
1503
1504int wc_iotsafe_ecc_sign_hash(byte *in, word32 inlen, byte *out,
1505        word32 *outlen, byte key_id)
1506{
1507    return iotsafe_sign_hash(&key_id, 1, IOTSAFE_HASH_SHA256, IOTSAFE_SIGN_ECDSA,
1508            in, inlen, out, outlen);
1509}
1510
1511
1512int wc_iotsafe_ecc_verify_hash(byte *sig, word32 siglen, byte *hash,
1513        word32 hashlen, int *res, byte key_id)
1514{
1515    return wc_iotsafe_ecc_verify_hash_ex(sig, siglen, hash, hashlen, res,
1516            &key_id, 1);
1517}
1518int wc_iotsafe_ecc_gen_k(byte key_id)
1519{
1520    return iotsafe_gen_keypair(&key_id, 1, NULL);
1521}
1522
1523#endif /* HAVE_ECC */
1524
1525/* API for GetRandom, used as custom Rand seed or block.
1526 * Returns 0 on success. */
1527int wolfIoTSafe_GetRandom(unsigned char *out, word32 sz)
1528{
1529    return iotsafe_getrandom(out, sz);
1530}
1531
1532/* API for GetCert (proxy for Read File / Close File)
1533 */
1534
1535int wolfIoTSafe_GetCert_ex(uint8_t *id, uint16_t id_sz, unsigned char *output,
1536        unsigned long sz)
1537{
1538    XMEMSET(output, 0, sz);
1539    return iotsafe_readfile(id, id_sz, output, (word32)sz);
1540}
1541
1542int wolfIoTSafe_GetCert(uint8_t id, unsigned char *output, unsigned long sz)
1543{
1544    return wolfIoTSafe_GetCert_ex(&id, 1, output, sz);
1545}
1546
1547/* API to set target specific I/O callbacks */
1548void wolfIoTSafe_SetCSIM_read_cb(wolfSSL_IOTSafe_CSIM_read_cb rf)
1549{
1550    csim_read_cb = rf;
1551}
1552
1553void wolfIoTSafe_SetCSIM_write_cb(wolfSSL_IOTSafe_CSIM_write_cb wf)
1554{
1555    csim_write_cb = wf;
1556}
1557
1558/* API to equip target wolfSSL CTX to the IoT-Safe subsystem. */
1559int wolfSSL_CTX_iotsafe_enable(WOLFSSL_CTX *ctx)
1560{
1561    if ( !wolfIoT_initialized) {
1562        if (iotsafe_init() < 0)
1563            return WC_HW_E;
1564    }
1565
1566#if defined(HAVE_PK_CALLBACKS)
1567    #ifdef HAVE_ECC
1568    wolfSSL_CTX_SetEccSignCb(ctx, wolfIoT_ecc_sign);
1569    wolfSSL_CTX_SetEccVerifyCb(ctx, wolfIoT_ecc_verify);
1570    wolfSSL_CTX_SetEccKeyGenCb(ctx, wolfIoT_ecc_keygen);
1571    wolfSSL_CTX_SetEccSharedSecretCb(ctx, wolfIoT_ecc_shared_secret);
1572    #ifdef HAVE_HKDF
1573    wolfSSL_CTX_SetHKDFExtractCb(ctx, wolfIoT_hkdf_extract);
1574    #endif
1575    #ifndef NO_DH
1576    wolfSSL_CTX_SetDhAgreeCb(ctx, wolfIoT_dh_agree);
1577    #endif /* NO_DH */
1578    WOLFSSL_MSG("ECC callbacks set to IoT_safe interface");
1579    #endif
1580    #ifndef NO_RSA
1581    /* wolfSSL_CTX_SetRsaSignCb(wolfIoT_rsa_sign); */ /* TODO: RSA callbacks */
1582    #endif
1583#else
1584    (void)ctx;
1585#endif
1586    return 0;
1587}
1588
1589int wolfSSL_iotsafe_on_ex(WOLFSSL *ssl, byte *privkey_id, byte *ecdh_keypair_slot,
1590        byte *peer_pubkey_slot, byte *peer_cert_slot, word16 id_size)
1591{
1592#if defined(HAVE_PK_CALLBACKS)
1593    int ret;
1594    IOTSAFE iotsafe;
1595    XMEMCPY(&iotsafe.privkey_id, privkey_id, id_size);
1596    XMEMCPY(&iotsafe.ecdh_keypair_slot, ecdh_keypair_slot, id_size);
1597    XMEMCPY(&iotsafe.peer_pubkey_slot, peer_pubkey_slot, id_size);
1598    XMEMCPY(&iotsafe.peer_cert_slot, peer_cert_slot, id_size);
1599    iotsafe.enabled = 1;
1600    ret = wolfSSL_set_iotsafe_ctx(ssl, &iotsafe);
1601    if (ret == 0) {
1602        WOLFSSL_MSG("IOTSAFE is ON");
1603    } else {
1604        WOLFSSL_MSG("Error setting IOT-Safe Context on SSL Session");
1605    }
1606    return ret;
1607#else
1608    (void)ssl;
1609    (void)privkey_id;
1610    (void)ecdh_keypair_slot;
1611    (void)peer_cert_slot;
1612    (void)peer_pubkey_slot;
1613    (void)id_size;
1614    return NOT_COMPILED_IN;
1615#endif
1616}
1617
1618int wolfSSL_iotsafe_on(WOLFSSL *ssl, byte privkey_id,
1619       byte ecdh_keypair_slot, byte peer_pubkey_slot, byte peer_cert_slot)
1620{
1621    return wolfSSL_iotsafe_on_ex(ssl, &privkey_id, &ecdh_keypair_slot,
1622            &peer_pubkey_slot, &peer_cert_slot, 1);
1623}
1624#endif /* WOLFSSL_IOTSAFE */