luna - wolfssl/wolfcrypt/src/port/caam/caam

   1/* caam_qnx.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/* settings.h is only included for wolfSSL version and IAR build warnings
  27 * wolfssl/wolfcrypt/- path includes other than
  28 * wolfssl/wolfcrypt/port/caam/caam_* should be avoided!! */
  29#undef WC_NO_HARDEN
  30#define WC_NO_HARDEN /* silence warning, it is irrelevant here */
  31#include <wolfssl/wolfcrypt/settings.h>
  32
  33#if defined(__QNX__) || defined(__QNXNTO__)
  34
  35#include <wolfssl/wolfcrypt/port/caam/caam_driver.h>
  36#include <wolfssl/version.h>
  37
  38#include <errno.h>
  39#include <stdio.h>
  40#include <stdlib.h>
  41#include <string.h>
  42#include <unistd.h>
  43#include <pthread.h>
  44#include <sys/iofunc.h>
  45#include <sys/dispatch.h>
  46#include <sys/neutrino.h>
  47#include <sys/resmgr.h>
  48#include <devctl.h>
  49#include <semaphore.h>
  50
  51/* virtual address for accessing CAAM addresses */
  52uintptr_t virtual_base = 0;
  53
  54static void* localMemory = NULL;
  55static unsigned int localPhy = 0;
  56sem_t localMemSem;
  57
  58/* Can be overridden, variable for how large of a local buffer to have.
  59 * This allows for large performance gains when avoiding mapping new memory
  60 * for each operation. */
  61#ifndef WOLFSSL_CAAM_QNX_MEMORY
  62    #define WOLFSSL_CAAM_QNX_MEMORY 250000
  63#endif
  64
  65/* keep track of which ID memory belongs to so it can be free'd up */
  66#define MAX_PART 7
  67pthread_mutex_t sm_mutex;
  68CAAM_ADDRESS sm_ownerId[MAX_PART];
  69
  70/* variables for I/O of resource manager */
  71resmgr_connect_funcs_t connect_funcs;
  72resmgr_io_funcs_t      io_funcs;
  73dispatch_t             *dpp;
  74resmgr_attr_t          rattr;
  75dispatch_context_t     *ctp;
  76iofunc_attr_t          ioattr;
  77
  78int io_devctl (resmgr_context_t *ctp, io_devctl_t *msg, iofunc_ocb_t *ocb);
  79int io_open (resmgr_context_t *ctp, io_open_t  *msg, RESMGR_HANDLE_T *handle,
  80        void *extra);
  81int io_read (resmgr_context_t *ctp, io_read_t  *msg, RESMGR_OCB_T *ocb);
  82int io_write(resmgr_context_t *ctp, io_write_t *msg, RESMGR_OCB_T *ocb);
  83int io_close_ocb(resmgr_context_t *ctp, void *reserved, RESMGR_OCB_T *ocb);
  84
  85
  86/* read the contents at offset from BASE address */
  87unsigned int CAAM_READ(CAAM_ADDRESS reg) {
  88    return in32(reg);
  89}
  90
  91
  92/* takes in offset from BASE address */
  93void CAAM_WRITE(CAAM_ADDRESS reg, unsigned int in)
  94{
  95    out32(reg, in);
  96}
  97
  98
  99/* Sets the base address to use for read/write
 100 * returns 0 on success
 101 */
 102int CAAM_SET_BASEADDR(CAAM_ADDRESS* baseAddr)
 103{
 104#ifndef __aarch64__
 105    void* vaddr;
 106
 107    /* address range for CAAM is CAAM_BASE plus 0x10000 */
 108    vaddr = (void*)mmap_device_io(0x0000FFFF, CAAM_BASE);
 109    if (vaddr == MAP_FAILED) {
 110        WOLFSSL_MSG("Unable to map virtual memory");
 111        return -1;
 112    }
 113    *baseAddr = (CAAM_ADDRESS)vaddr;
 114#endif
 115
 116    return 0;
 117}
 118
 119
 120int CAAM_SET_JOBRING_ADDR(CAAM_ADDRESS* base, CAAM_ADDRESS* ringInPhy,
 121    void** ringInVir)
 122{
 123    void* vaddr;
 124
 125#ifdef __aarch64__
 126    /* if on an AArch64 system make assumption that it is an i.MX8 QXP */
 127    /* use block of memory set aside for job ring 2 */
 128    /* try to map to job rings 2 address */
 129    *base = mmap_device_io(0x0000FFFF, CAAM_BASE + 0x00030000);
 130#else
 131    /* try to map to job rings 1 address */
 132    *base = mmap_device_io(0x0000FFFF, CAAM_BASE + 0x00001000);
 133#endif
 134    if (*base == (uintptr_t)MAP_FAILED) {
 135        WOLFSSL_MSG("Unable to map virtual memory");
 136        return -1;
 137    }
 138
 139    /* create DMA buffer for job rings */
 140    vaddr = mmap(0, 1024, PROT_READ | PROT_WRITE | PROT_NOCACHE,
 141        MAP_SHARED | MAP_PHYS | MAP_ANON, NOFD, 0);
 142    if (vaddr == (void*)MAP_FAILED) {
 143        WOLFSSL_MSG("mmap failed\n");
 144        return -1;
 145    }
 146
 147    *ringInPhy = CAAM_ADR_TO_PHYSICAL(vaddr, 1024);
 148    *ringInVir = vaddr;
 149    return 0;
 150}
 151
 152
 153void CAAM_UNSET_JOBRING_ADDR(CAAM_ADDRESS base, CAAM_ADDRESS ringInPhy,
 154    void* ringInVir)
 155{
 156    munmap_device_io(base, 0x0000FFFF);
 157    munmap(ringInVir, 1024);
 158}
 159
 160
 161/* cleans up having set the base address */
 162void CAAM_UNSET_BASEADDR(CAAM_ADDRESS baseAddr)
 163{
 164#ifndef __aarch64__
 165    munmap_device_io(baseAddr, 0x0000FFFF);
 166#endif
 167}
 168
 169/* convert a virtual address to a physical address
 170 * returns the physical address on success
 171 */
 172CAAM_ADDRESS CAAM_ADR_TO_PHYSICAL(void* in, int inSz)
 173{
 174    off64_t ofst = 0;
 175    int ret, count = 0;;
 176
 177    if (in == NULL)
 178        return 0;
 179
 180    if (inSz == 0)
 181        inSz = 1;
 182
 183    do {
 184        ret = mem_offset64(in, NOFD, inSz, &ofst, NULL);
 185        if (ret != 0) {
 186            WOLFSSL_MSG("posix offset failed");
 187        #if defined(WOLFSSL_CAAM_DEBUG) || defined(WOLFSSL_CAAM_PRINT)
 188            perror("posix offset failed : ");
 189        #endif
 190        }
 191        msync(in, inSz, MS_INVALIDATE);
 192        count++;
 193    } while (ret != 0 && ret == -1 && count < 5);
 194
 195    return (CAAM_ADDRESS)ofst;
 196}
 197
 198
 199/* convert a physical address to virtual address
 200 * returns the virtual address on success
 201 */
 202CAAM_ADDRESS CAAM_ADR_TO_VIRTUAL(CAAM_ADDRESS in, int len)
 203{
 204    void* ret;
 205    ret = mmap_device_memory(NULL, len, PROT_READ | PROT_WRITE | PROT_NOCACHE,
 206            0, in);
 207    return (CAAM_ADDRESS)ret;
 208}
 209
 210
 211/* map a virtual address to a created coherent physical address
 212 * returns the mapped address on success
 213 */
 214void* CAAM_ADR_MAP(CAAM_ADDRESS in, int inSz, unsigned char copy)
 215{
 216    int  sz;
 217    void *vaddr;
 218
 219    sz = inSz;
 220    if (inSz == 0) {
 221        sz = 1;
 222    }
 223
 224    vaddr = mmap(NULL, sz, PROT_READ | PROT_WRITE | PROT_NOCACHE,
 225                    MAP_PHYS | MAP_SHARED | MAP_ANON, NOFD, 0);
 226    if (vaddr == MAP_FAILED) {
 227        WOLFSSL_MSG("Failed to map memory");
 228    #if defined(WOLFSSL_CAAM_DEBUG) || defined(WOLFSSL_CAAM_PRINT)
 229        perror("Failed to map memory : ");
 230    #endif
 231        return NULL;
 232    }
 233    else {
 234        if (copy && in != 0 && inSz > 0) {
 235            memcpy(vaddr, (void*)in, inSz);
 236        }
 237
 238        if (msync(vaddr, sz, MS_SYNC) != 0) {
 239            WOLFSSL_MSG("Failed to sync memory after copy");
 240        }
 241    }
 242    return vaddr;
 243}
 244
 245
 246/* un map address, should be called when done with a mapped address */
 247void CAAM_ADR_UNMAP(void* vaddr, CAAM_ADDRESS out, int outSz,
 248        unsigned char copy)
 249{
 250    int sz;
 251
 252    sz = outSz;
 253    if (outSz == 0)
 254        sz = 1;
 255
 256    if (msync(vaddr, sz, MS_SYNC) != 0) {
 257    #if defined(WOLFSSL_CAAM_DEBUG) || defined(WOLFSSL_CAAM_PRINT)
 258        perror("Failed to sync output");
 259    #endif
 260        /* even though the address was not synced up still try to copy and
 261           unmap it */
 262    }
 263
 264    if (copy && out != 0 && outSz > 0) {
 265        memcpy((unsigned char*)out, (unsigned char*)vaddr, outSz);
 266    }
 267    munmap(vaddr, sz);
 268}
 269
 270
 271/* synchronize virtual buffer with physical
 272 * return 0 on success */
 273int CAAM_ADR_SYNC(void* vaddr, int sz)
 274{
 275    if (msync(vaddr, sz, MS_SYNC) != 0) {
 276    #if defined(WOLFSSL_CAAM_DEBUG) || defined(WOLFSSL_CAAM_PRINT)
 277        perror("address sync failed");
 278    #endif
 279        return -1;
 280    }
 281    return 0;
 282}
 283
 284
 285/* macros for QNX devctl commands */
 286#define WC_TRNG_CMD __DIOTF(_DCMD_ALL, CAAM_ENTROPY, iov_t)
 287#define WC_CAAM_GET_PART __DIOTF(_DCMD_ALL, CAAM_GET_PART, iov_t)
 288#define WC_CAAM_FREE_PART __DIOT(_DCMD_ALL, CAAM_FREE_PART, iov_t)
 289#define WC_CAAM_FIND_PART __DIOTF(_DCMD_ALL, CAAM_FIND_PART, iov_t)
 290#define WC_CAAM_READ_PART __DIOTF(_DCMD_ALL, CAAM_READ_PART, iov_t)
 291#define WC_CAAM_WRITE_PART __DIOT(_DCMD_ALL, CAAM_WRITE_PART, iov_t)
 292
 293#define WC_CAAM_ECDSA_KEYPAIR __DIOTF(_DCMD_ALL, CAAM_ECDSA_KEYPAIR, iov_t)
 294#define WC_CAAM_ECDSA_VERIFY __DIOT(_DCMD_ALL, CAAM_ECDSA_VERIFY, iov_t)
 295#define WC_CAAM_ECDSA_SIGN __DIOTF(_DCMD_ALL, CAAM_ECDSA_SIGN, iov_t)
 296#define WC_CAAM_ECDSA_ECDH __DIOTF(_DCMD_ALL, CAAM_ECDSA_ECDH, iov_t)
 297
 298#define WC_CAAM_BLOB_ENCAP __DIOTF(_DCMD_ALL, CAAM_BLOB_ENCAP, iov_t)
 299#define WC_CAAM_BLOB_DECAP __DIOTF(_DCMD_ALL, CAAM_BLOB_DECAP, iov_t)
 300
 301#define WC_CAAM_CMAC __DIOTF(_DCMD_ALL, CAAM_CMAC, iov_t)
 302#define WC_CAAM_AESECB __DIOTF(_DCMD_ALL, CAAM_AESECB, iov_t)
 303#define WC_CAAM_AESCBC __DIOTF(_DCMD_ALL, CAAM_AESCBC, iov_t)
 304#define WC_CAAM_AESCTR __DIOTF(_DCMD_ALL, CAAM_AESCTR, iov_t)
 305#define WC_CAAM_AESCCM __DIOTF(_DCMD_ALL, CAAM_AESCCM, iov_t)
 306#define WC_CAAM_AESGCM __DIOTF(_DCMD_ALL, CAAM_AESGCM, iov_t)
 307
 308#define WC_CAAM_FIFO_S __DIOTF(_DCMD_ALL, CAAM_FIFO_S, iov_t)
 309
 310
 311/* partAddr is virtual address
 312 * partSz   size expected to access
 313 *
 314 * returns 0 on ok
 315 */
 316static int sanityCheckPartitionAddress(CAAM_ADDRESS partAddr, int partSz)
 317{
 318    if (partAddr < CAAM_PAGE || partAddr > CAAM_PAGE + (MAX_PART*4096) ||
 319            partSz > 4096) {
 320        WOLFSSL_MSG("error in physical address range");
 321        return -1;
 322    }
 323    return 0;
 324}
 325
 326
 327/* return 0 on success */
 328static int getArgs(unsigned int args[4], resmgr_context_t *ctp, io_devctl_t *msg,
 329        unsigned int *idx, unsigned int maxIdx)
 330{
 331    int expectedSz;
 332    iov_t in_iov;
 333
 334    expectedSz = sizeof(unsigned int) * 4;
 335    if (*idx + expectedSz > maxIdx) {
 336        WOLFSSL_MSG("not enough for arguments");
 337        return -1;
 338    }
 339
 340    SETIOV(&in_iov, args, expectedSz);
 341    if (resmgr_msgreadv(ctp, &in_iov, 1, *idx) != expectedSz) {
 342        WOLFSSL_MSG("unexpected msg size read");
 343        return -1;
 344    }
 345    *idx += expectedSz;
 346    return 0;
 347}
 348
 349
 350/* helper function to setup and run CMAC operation
 351 * returns EOK on success
 352 */
 353static int doCMAC(resmgr_context_t *ctp, io_devctl_t *msg, unsigned int args[4],
 354        unsigned int idx)
 355{
 356    DESCSTRUCT  desc;
 357    CAAM_BUFFER tmp[3];
 358    iov_t in_iovs[3], out_iov;
 359
 360    int msgSz = 0, ret, numBuf, keySz;
 361    unsigned char ctx[32];    /* running CMAC context is a constant 32 bytes */
 362    unsigned char keybuf[32 + BLACK_KEY_MAC_SZ];/*max AES key size is 32 + MAC*/
 363    unsigned char *buf = NULL;
 364
 365    numBuf = 2; /* start with 2 (key + ctx) for case with no msg input */
 366    keySz  = args[1];
 367    if (args[2] == 1) { /* is it a black key? */
 368        keySz = keySz + BLACK_KEY_MAC_SZ;
 369    }
 370    SETIOV(&in_iovs[0], keybuf, keySz);
 371    SETIOV(&in_iovs[1], ctx, sizeof(ctx));
 372    msgSz = args[3];
 373    if (msgSz < 0) {
 374        WOLFSSL_MSG("CMAC msg size was a negative value");
 375        return EBADMSG;
 376    }
 377
 378    if (msgSz > 0) {
 379        buf = (unsigned char*)CAAM_ADR_MAP(0, msgSz, 0);
 380        if (buf == NULL) {
 381            return ECANCELED;
 382        }
 383        SETIOV(&in_iovs[2], buf, msgSz);
 384        numBuf = numBuf + 1; /* increase buffer size by one when adding msg */
 385    }
 386
 387    ret = resmgr_msgreadv(ctp, in_iovs, numBuf, idx);
 388    if (ret < (msgSz + keySz + sizeof(ctx))) {
 389        /* sanity check that enough data was sent */
 390        if (buf != NULL)
 391            CAAM_ADR_UNMAP(buf, 0, msgSz, 0);
 392        return EOVERFLOW;
 393    }
 394
 395    tmp[0].TheAddress = (CAAM_ADDRESS)keybuf;
 396    tmp[0].Length = args[1];
 397
 398    tmp[1].TheAddress = (CAAM_ADDRESS)ctx;
 399    tmp[1].Length = sizeof(ctx);
 400
 401    if (msgSz > 0) {
 402        tmp[2].TheAddress = (CAAM_ADDRESS)buf;
 403        tmp[2].Length     = msgSz;
 404    }
 405    caamDescInit(&desc, CAAM_CMAC, args, tmp, numBuf);
 406    ret = caamAesCmac(&desc, numBuf, args);
 407    if (msgSz > 0) {
 408        if (buf != NULL)
 409            CAAM_ADR_UNMAP(buf, 0, msgSz, 0);
 410    }
 411
 412    if (ret != Success) {
 413        return EBADMSG;
 414    }
 415    SETIOV(&out_iov, ctx, sizeof(ctx));
 416
 417    /* extra sanity check that out buffer is large enough */
 418    if (sizeof(ctx) > msg->o.nbytes) {
 419        return EOVERFLOW;
 420    }
 421    ret = resmgr_msgwritev(ctp, &out_iov, 1, sizeof(msg->o));
 422    if (ret < 0) {
 423        return ECANCELED;
 424    }
 425
 426    return EOK;
 427}
 428
 429
 430/* helper function to setup and run TRNG operation
 431 * returns EOK on success
 432 */
 433static int doTRNG(resmgr_context_t *ctp, io_devctl_t *msg, unsigned int args[4],
 434        unsigned int idx)
 435{
 436    int length, ret;
 437    unsigned char *buf;
 438    iov_t out_iov;
 439
 440    length = args[0];
 441
 442    /* sanity check that length out is not over the edge */
 443    if (length > msg->o.nbytes) {
 444        WOLFSSL_MSG("Length too large for TRNG out size available");
 445        return EOVERFLOW;
 446    }
 447
 448    if (length > 0) {
 449        buf = (unsigned char*)CAAM_ADR_MAP(0, length, 0);
 450        if (buf == NULL) {
 451            return ECANCELED;
 452        }
 453
 454        ret = caamEntropy(buf, length);
 455        if (ret == CAAM_WAITING) {
 456            /* waiting for more entropy */
 457            CAAM_ADR_UNMAP(buf, 0, length, 0);
 458            return EAGAIN;
 459        }
 460
 461        SETIOV(&out_iov, buf, length);
 462        ret = resmgr_msgwritev(ctp, &out_iov, 1, sizeof(msg->o));
 463        DEBUG_PRINT_ARRAY(buf, length, "RNG data");
 464        CAAM_ADR_UNMAP(buf, 0, length, 0);
 465        if (ret < 0) {
 466            return ECANCELED;
 467        }
 468    }
 469    return EOK;
 470}
 471
 472
 473/* helper function to setup and run BLOB operation
 474 * returns EOK on success
 475 */
 476static int doBLOB(resmgr_context_t *ctp, io_devctl_t *msg, unsigned int args[4],
 477        unsigned int idx)
 478{
 479    int WC_CAAM_BLOB_SZ = 48; /* extra blob size from manual */
 480    int dir, ret, inSz, outSz;
 481    DESCSTRUCT  desc;
 482    CAAM_BUFFER tmp[3];
 483    iov_t in_iovs[2], out_iov;
 484
 485    unsigned char *inBuf, *outBuf;
 486    unsigned char keymod[BLACK_BLOB_KEYMOD_SZ];
 487    /* 16 is max size for keymod (8 with red blobs and 16 with black) */
 488
 489    if (msg->i.dcmd == WC_CAAM_BLOB_ENCAP) {
 490        dir = CAAM_BLOB_ENCAP;
 491    }
 492    else {
 493        dir = CAAM_BLOB_DECAP;
 494    }
 495
 496    inSz = args[2];
 497    if (inSz < 0) {
 498        return EBADMSG;
 499    }
 500
 501    if (args[0] == 1 && dir == CAAM_BLOB_ENCAP) {
 502        inSz = inSz + BLACK_KEY_MAC_SZ;
 503    }
 504
 505    SETIOV(&in_iovs[0], keymod, args[3]);
 506    if ((inSz + args[3]) > (ctp->size - idx)) {
 507        return EOVERFLOW;
 508    }
 509
 510    inBuf = (unsigned char*)CAAM_ADR_MAP(0, inSz, 0);
 511    if (inBuf == NULL) {
 512        return ECANCELED;
 513    }
 514    SETIOV(&in_iovs[1], inBuf, inSz);
 515    ret = resmgr_msgreadv(ctp, in_iovs, 2, idx);
 516    if (ret < inSz + args[3]) {
 517        return EBADMSG;
 518    }
 519
 520    /* key mod */
 521    tmp[0].TheAddress = (CAAM_ADDRESS)keymod;
 522    tmp[0].Length = args[3];
 523
 524    /* input */
 525    tmp[1].TheAddress = (CAAM_ADDRESS)inBuf;
 526    tmp[1].Length = args[2];
 527
 528    /* output */
 529    outSz = args[2];
 530    if (msg->i.dcmd == WC_CAAM_BLOB_ENCAP) {
 531        outSz = outSz + WC_CAAM_BLOB_SZ;
 532    }
 533    else {
 534        outSz = outSz - WC_CAAM_BLOB_SZ;
 535    }
 536    if (outSz < 0) {
 537        return EBADMSG;
 538    }
 539
 540    if (args[0] == 1 && dir == CAAM_BLOB_DECAP) {
 541        outBuf = (unsigned char*)CAAM_ADR_MAP(0, outSz + BLACK_KEY_MAC_SZ, 0);
 542    }
 543    else {
 544        outBuf = (unsigned char*)CAAM_ADR_MAP(0, outSz, 0);
 545    }
 546    if (outBuf == NULL) {
 547        CAAM_ADR_UNMAP(inBuf, 0, inSz, 0);
 548        return ECANCELED;
 549    }
 550    tmp[2].TheAddress = (CAAM_ADDRESS)outBuf;
 551    tmp[2].Length     = outSz;
 552
 553    caamDescInit(&desc, dir, args, tmp, 3);
 554    ret = caamBlob(&desc);
 555    CAAM_ADR_UNMAP(inBuf, 0, inSz, 0);
 556
 557    /* adjust outSz for MAC tag at the end of black key */
 558    if (args[0] == 1 && dir == CAAM_BLOB_DECAP) {
 559        outSz = outSz + BLACK_KEY_MAC_SZ;
 560    }
 561
 562    if (ret != Success) {
 563        CAAM_ADR_UNMAP(outBuf, 0, outSz, 0);
 564        return ECANCELED;
 565    }
 566
 567    CAAM_ADR_SYNC(outBuf, outSz);
 568    SETIOV(&out_iov, outBuf, outSz);
 569    if (outSz > msg->o.nbytes) {
 570        CAAM_ADR_UNMAP(outBuf, 0, outSz, 0);
 571        return EOVERFLOW;
 572    }
 573    ret = resmgr_msgwritev(ctp, &out_iov, 1, sizeof(msg->o));
 574    CAAM_ADR_UNMAP(outBuf, 0, outSz, 0);
 575    if (ret < 0) {
 576        return ECANCELED;
 577    }
 578    return EOK;
 579}
 580
 581
 582/* helper function to setup and make ECC key
 583 * returns EOK on success
 584 */
 585static int doAEAD(resmgr_context_t *ctp, io_devctl_t *msg, unsigned int args[4],
 586        unsigned int idx, int type)
 587{
 588    int ret = EOK, i = 0;
 589    DESCSTRUCT desc;
 590    CAAM_BUFFER tmp[6];
 591    iov_t in_iovs[6], out_iovs[2];
 592    int inIdx = 0, outIdx = 0, algo;
 593    unsigned char *key = NULL, *iv = NULL, *in = NULL, *out = NULL, *aad = NULL,
 594                  *tag = NULL;
 595    int keySz, ivSz = 0, inSz, outSz, aadSz = 0, tagSz = 0;
 596
 597    memset(tmp, 0, sizeof(tmp));
 598
 599    /* get key info */
 600    keySz = args[1] & 0xFFFF; /* key size */
 601    key   = (unsigned char*)CAAM_ADR_MAP(0, keySz, 0);
 602    if (key == NULL) {
 603        ret = ECANCELED;
 604    }
 605    SETIOV(&in_iovs[inIdx], key, keySz);
 606    inIdx++;
 607
 608    /* check for IV */
 609    if (ret == EOK) {
 610        ivSz = (args[1] >> 24)  & 0xFF;
 611        iv   = (unsigned char*)CAAM_ADR_MAP(0, ivSz, 0);
 612        if (iv == NULL) {
 613            ret = ECANCELED;
 614        }
 615        SETIOV(&in_iovs[inIdx], iv, ivSz);
 616        inIdx++;
 617    }
 618
 619    /* get input buffer */
 620    if (ret == EOK) {
 621        inSz = args[2]; /* input size */
 622        in   = (unsigned char*)CAAM_ADR_MAP(0, inSz, 0);
 623        if (in == NULL) {
 624            ret = ECANCELED;
 625        }
 626        SETIOV(&in_iovs[inIdx], in, inSz);
 627        inIdx++;
 628    }
 629
 630    /* create output buffer to store results */
 631    if (ret == EOK) {
 632        outSz = args[2]; /* output size */
 633        out   = (unsigned char*)CAAM_ADR_MAP(0, outSz, 0);
 634    }
 635
 636    /* add in TAG and AAD if set */
 637    if (ret == EOK) {
 638        tagSz = (args[1] >> 16) & 0xFF;
 639        tag   = (unsigned char*)CAAM_ADR_MAP(0, tagSz, 0);
 640        if (tag == NULL) {
 641            ret = ECANCELED;
 642        }
 643    }
 644
 645    /* when decrypting the TAG is an input */
 646    if (ret == EOK) {
 647        if ((args[0] & 0xFFFF) == CAAM_DEC) {
 648            SETIOV(&in_iovs[inIdx], tag, tagSz);
 649            inIdx++;
 650        }
 651
 652        /* AAD input */
 653        aadSz = (args[0] >> 16) & 0xFFFF;
 654        if (aadSz > 0) {
 655            aad = (unsigned char*)CAAM_ADR_MAP(0, aadSz, 0);
 656            if (aad == NULL) {
 657                ret = ECANCELED;
 658            }
 659            SETIOV(&in_iovs[inIdx], aad, aadSz);
 660            inIdx++;
 661        }
 662    }
 663
 664    if (ret == EOK) {
 665        if (resmgr_msgreadv(ctp, in_iovs, inIdx, idx) < 0) {
 666            ret = EBADMSG;
 667        }
 668    }
 669
 670    if (ret == EOK) {
 671        switch (type) {
 672            case WC_CAAM_AESCCM: algo = CAAM_AESCCM; break;
 673            case WC_CAAM_AESGCM: algo = CAAM_AESGCM; break;
 674            default:
 675                WOLFSSL_MSG("Unknown/supported AES mode");
 676                ret =  ECANCELED;
 677        }
 678    }
 679
 680    if (ret == EOK) {
 681        tmp[i].Length = keySz;
 682        tmp[i].TheAddress = (CAAM_ADDRESS)key;
 683        i++;
 684
 685        tmp[i].Length = ivSz;
 686        tmp[i].TheAddress = (CAAM_ADDRESS)iv;
 687        i++;
 688
 689        tmp[i].Length = inSz;
 690        tmp[i].TheAddress = (CAAM_ADDRESS)in;
 691        i++;
 692
 693        tmp[i].Length = outSz;
 694        tmp[i].TheAddress = (CAAM_ADDRESS)out;
 695        i++;
 696
 697        tmp[i].Length = tagSz;
 698        tmp[i].TheAddress = (CAAM_ADDRESS)tag;
 699        i++;
 700
 701        tmp[i].Length = aadSz;
 702        tmp[i].TheAddress = (CAAM_ADDRESS)aad;
 703        i++;
 704
 705        caamDescInit(&desc, algo, args, tmp, 6);
 706        if (caamAead(&desc, tmp, args) != Success) {
 707            ret = ECANCELED;
 708        }
 709    }
 710
 711    /* sync the new IV/MAC and output buffer */
 712    if (ret == EOK) {
 713        CAAM_ADR_SYNC(out, outSz);
 714        SETIOV(&out_iovs[0], out, outSz);
 715        outIdx++;
 716
 717        if ((desc.state == CAAM_ENC &&
 718                 (type == WC_CAAM_AESCCM || type == WC_CAAM_AESGCM))) {
 719            CAAM_ADR_SYNC(tag, tagSz);
 720            SETIOV(&out_iovs[1], tag, tagSz);
 721            outIdx++;
 722        }
 723
 724        if (resmgr_msgwritev(ctp, &out_iovs[0], outIdx, sizeof(msg->o)) < 0) {
 725            ret = ECANCELED;
 726        }
 727    }
 728
 729    if (key != NULL)
 730        CAAM_ADR_UNMAP(key, 0, keySz, 0);
 731    if (iv != NULL)
 732        CAAM_ADR_UNMAP(iv, 0, ivSz, 0);
 733    if (in != NULL)
 734        CAAM_ADR_UNMAP(in, 0, inSz, 0);
 735    if (out != NULL)
 736        CAAM_ADR_UNMAP(out, 0, outSz, 0);
 737    if (tag != NULL)
 738        CAAM_ADR_UNMAP(tag, 0, tagSz, 0);
 739    if (aad != NULL)
 740        CAAM_ADR_UNMAP(aad, 0, aadSz, 0);
 741
 742    return ret;
 743}
 744
 745
 746/* helper function to setup and make ECC key
 747 * returns EOK on success
 748 */
 749static int doAES(resmgr_context_t *ctp, io_devctl_t *msg, unsigned int args[4],
 750        unsigned int idx, int type)
 751{
 752    int ret = EOK, i = 0;
 753    DESCSTRUCT desc;
 754    CAAM_BUFFER tmp[6];
 755    iov_t in_iovs[6], out_iovs[2];
 756    int inIdx = 0, outIdx = 0;
 757    int algo;
 758    unsigned char *key = NULL, *iv = NULL, *in = NULL, *out = NULL;
 759    unsigned char *pt = NULL;
 760    int keySz, ivSz = 0, inSz, outSz;
 761    unsigned int phyMem = 0;
 762
 763    memset(tmp, 0, sizeof(tmp));
 764
 765    /* get key info */
 766    keySz = args[1] & 0xFFFF; /* key size */
 767    inSz = args[2]; /* input size */
 768    outSz = args[2]; /* output size */
 769    if (type == WC_CAAM_AESCBC || type == WC_CAAM_AESCTR) {
 770        ivSz = 16;
 771    }
 772
 773    if (keySz + inSz + outSz + ivSz < WOLFSSL_CAAM_QNX_MEMORY) {
 774        if (sem_trywait(&localMemSem) == 0) {
 775            key = localMemory;
 776            phyMem = localPhy;
 777        }
 778    }
 779
 780    /* local pre-mapped memory was not used, try to map some memory now */
 781    if (key == NULL) {
 782        pt = (unsigned char*)CAAM_ADR_MAP(0, keySz + inSz + outSz + ivSz, 0);
 783        key = pt;
 784    }
 785
 786    if (key == NULL) {
 787        ret = ECANCELED;
 788    }
 789    SETIOV(&in_iovs[inIdx], key, keySz);
 790    inIdx++;
 791
 792    /* check for IV */
 793    if (ret == EOK) {
 794        if (type == WC_CAAM_AESCBC || type == WC_CAAM_AESCTR) {
 795            ivSz = 16;
 796            iv   = key + keySz + inSz;
 797            if (iv == NULL) {
 798                ret = ECANCELED;
 799            }
 800            SETIOV(&in_iovs[inIdx], iv, ivSz);
 801            inIdx++;
 802        }
 803    }
 804
 805    /* get input buffer */
 806    if (ret == EOK) {
 807        in   = key + keySz;
 808        if (in == NULL) {
 809            ret = ECANCELED;
 810        }
 811        SETIOV(&in_iovs[inIdx], in, inSz);
 812        inIdx++;
 813    }
 814
 815    /* create output buffer to store results */
 816    if (ret == EOK) {
 817        out   = key + keySz + inSz + ivSz;
 818        if (out == NULL) {
 819            ret = ECANCELED;
 820        }
 821    }
 822
 823    if (ret == EOK) {
 824        if (resmgr_msgreadv(ctp, in_iovs, inIdx, idx) < 0) {
 825            ret = ECANCELED;
 826        }
 827    }
 828
 829    if (ret == EOK) {
 830        switch (type) {
 831            case WC_CAAM_AESCBC: algo = CAAM_AESCBC; break;
 832            case WC_CAAM_AESCTR: algo = CAAM_AESCTR; break;
 833            case WC_CAAM_AESECB: algo = CAAM_AESECB; break;
 834            default:
 835                WOLFSSL_MSG("Unknown/supported AES mode");
 836                ret = ECANCELED;
 837        }
 838    }
 839
 840    if (ret == EOK) {
 841        tmp[i].Length = keySz;
 842        tmp[i].TheAddress = (CAAM_ADDRESS)key;
 843        i++;
 844
 845        if (type == WC_CAAM_AESCBC || type == WC_CAAM_AESCTR) {
 846            tmp[i].Length = ivSz;
 847            tmp[i].TheAddress = (CAAM_ADDRESS)iv;
 848            i++;
 849        }
 850
 851        tmp[i].Length = inSz;
 852        tmp[i].TheAddress = (CAAM_ADDRESS)in;
 853        i++;
 854
 855        tmp[i].Length = outSz;
 856        tmp[i].TheAddress = (CAAM_ADDRESS)out;
 857
 858        caamDescInit(&desc, algo, args, tmp, 6);
 859        if (caamAesCombined(&desc, tmp, args, phyMem) != Success) {
 860            ret = ECANCELED;
 861        }
 862    }
 863
 864    /* sync the new IV/MAC and output buffer */
 865    if (ret == EOK) {
 866        CAAM_ADR_SYNC(key, keySz + inSz + ivSz + outSz);
 867        if (type == WC_CAAM_AESCBC || type == WC_CAAM_AESCTR) {
 868            SETIOV(&out_iovs[1], iv, ivSz);
 869            outIdx++;
 870        }
 871        SETIOV(&out_iovs[0], out, outSz);
 872        outIdx++;
 873
 874        if (resmgr_msgwritev(ctp, &out_iovs[0], outIdx, sizeof(msg->o)) < 0) {
 875            ret = ECANCELED;
 876        }
 877    }
 878
 879    if (pt != NULL) {
 880        CAAM_ADR_UNMAP(pt, 0, keySz + inSz + outSz + ivSz, 0);
 881    }
 882    else {
 883        /* done using local mapped memory */
 884        sem_post(&localMemSem);
 885    }
 886
 887    return ret;
 888}
 889
 890
 891/* helper function to setup and make ECC key
 892 * returns EOK on success
 893 */
 894static int doECDSA_KEYPAIR(resmgr_context_t *ctp, io_devctl_t *msg,
 895    unsigned int args[4], unsigned int idx, iofunc_ocb_t *ocb)
 896{
 897    int ret = EOK;
 898    int keySz;
 899    int privSz;
 900    DESCSTRUCT desc;
 901    CAAM_BUFFER tmp[2];
 902    iov_t out_iovs[3];
 903    unsigned char *priv = NULL, *pub = NULL;
 904
 905    privSz = keySz = args[3];
 906    if (args[0] == CAAM_BLACK_KEY_CCM) {
 907        privSz += BLACK_KEY_MAC_SZ;
 908    }
 909    if (args[0] == CAAM_BLACK_KEY_SM) {
 910        privSz = sizeof(unsigned int);
 911    }
 912
 913    /* private key */
 914    tmp[0].Length = privSz;
 915    priv = (unsigned char*)CAAM_ADR_MAP(0, privSz, 0);
 916    if (priv == NULL) {
 917        ret = ECANCELED;
 918    }
 919    tmp[0].TheAddress = (CAAM_ADDRESS)priv;
 920
 921    /* public key */
 922    if (ret == EOK) {
 923        tmp[1].Length = keySz * 2;
 924        pub = (unsigned char*)CAAM_ADR_MAP(0, keySz * 2, 0);
 925        if (pub == NULL) {
 926            ret = ECANCELED;
 927        }
 928        tmp[1].TheAddress = (CAAM_ADDRESS)pub;
 929    }
 930
 931    if (ret == EOK) {
 932        caamDescInit(&desc, CAAM_ECDSA_KEYPAIR, args, tmp, 2);
 933        if (caamECDSAMake(&desc, tmp, args) != Success) {
 934            ret = ECANCELED;
 935        }
 936    }
 937
 938    if (ret == EOK) {
 939        SETIOV(&out_iovs[0], tmp[0].TheAddress, privSz);
 940        SETIOV(&out_iovs[1], tmp[1].TheAddress, keySz * 2);
 941        SETIOV(&out_iovs[2], args, sizeof(int) * 4);
 942        if (resmgr_msgwritev(ctp, &out_iovs[0], 3, sizeof(msg->o)) < 0) {
 943            ret = ECANCELED;
 944        }
 945    }
 946
 947    /* claim ownership of a secure memory location */
 948    if (ret == EOK && args[0] == CAAM_BLACK_KEY_SM) {
 949        if (pthread_mutex_lock(&sm_mutex) != EOK) {
 950            ret = ECANCELED;
 951        }
 952        else {
 953            sm_ownerId[args[2]] = (CAAM_ADDRESS)ocb;
 954            pthread_mutex_unlock(&sm_mutex);
 955        }
 956    }
 957
 958    if (priv != NULL)
 959        CAAM_ADR_UNMAP(priv, 0, privSz, 0);
 960    if (pub != NULL)
 961        CAAM_ADR_UNMAP(pub, 0, keySz*2, 0);
 962    return ret;
 963}
 964
 965
 966/* helper function to setup and do ECC verify
 967 * returns EOK on success
 968 */
 969static int doECDSA_VERIFY(resmgr_context_t *ctp, io_devctl_t *msg,
 970        unsigned int args[4], unsigned int idx)
 971{
 972    DESCSTRUCT  desc;
 973    CAAM_BUFFER tmp[5];
 974    iov_t in_iovs[4];
 975    int ret, pubSz;
 976
 977    unsigned char *hash, *pubkey = NULL, *r, *s;
 978    CAAM_ADDRESS securePub;
 979
 980    if (args[0] == CAAM_BLACK_KEY_SM) {
 981        pubSz = sizeof(CAAM_ADDRESS);
 982
 983        SETIOV(&in_iovs[0], &securePub, sizeof(CAAM_ADDRESS));
 984    }
 985    else {
 986        pubSz  = args[3]*2;
 987        pubkey = (unsigned char*)CAAM_ADR_MAP(0, pubSz, 0);
 988        if (pubkey == NULL) {
 989            return ECANCELED;
 990        }
 991
 992        SETIOV(&in_iovs[0], pubkey, args[3]*2);
 993    }
 994
 995    hash = (unsigned char*)CAAM_ADR_MAP(0, args[2], 0);
 996    if (hash == NULL) {
 997        if (pubkey != NULL)
 998            CAAM_ADR_UNMAP(pubkey, 0, pubSz, 0);
 999        return ECANCELED;
1000    }
1001    SETIOV(&in_iovs[1], hash, args[2]);
1002
1003    r = (unsigned char*)CAAM_ADR_MAP(0, args[3], 0);
1004    if (r == NULL) {
1005        if (pubkey != NULL)
1006            CAAM_ADR_UNMAP(pubkey, 0, pubSz, 0);
1007        CAAM_ADR_UNMAP(hash, 0, args[2], 0);
1008        return ECANCELED;
1009    }
1010    SETIOV(&in_iovs[2], r, args[3]);
1011
1012    s = (unsigned char*)CAAM_ADR_MAP(0, args[3], 0);
1013    if (s == NULL) {
1014        if (pubkey != NULL)
1015            CAAM_ADR_UNMAP(pubkey, 0, pubSz, 0);
1016        CAAM_ADR_UNMAP(hash, 0, args[2], 0);
1017        CAAM_ADR_UNMAP(r, 0, args[3], 0);
1018        return ECANCELED;
1019    }
1020    SETIOV(&in_iovs[3], s, args[3]);
1021
1022    ret = resmgr_msgreadv(ctp, in_iovs, 4, idx);
1023    if (((args[3] * 2) + args[2] + pubSz) > ret) {
1024        if (pubkey != NULL)
1025            CAAM_ADR_UNMAP(pubkey, 0, pubSz, 0);
1026        CAAM_ADR_UNMAP(hash, 0, args[2], 0);
1027        CAAM_ADR_UNMAP(r, 0, args[3], 0);
1028        CAAM_ADR_UNMAP(s, 0, args[3], 0);
1029        return EOVERFLOW;
1030    }
1031
1032    /* setup CAAM buffers to pass to driver */
1033    if (args[0] == CAAM_BLACK_KEY_SM) {
1034        tmp[0].TheAddress = securePub;
1035    }
1036    else {
1037        tmp[0].TheAddress = (CAAM_ADDRESS)pubkey;
1038    }
1039    tmp[0].Length = args[3]*2;
1040
1041    tmp[1].TheAddress = (CAAM_ADDRESS)hash;
1042    tmp[1].Length = args[2];
1043
1044    tmp[2].TheAddress = (CAAM_ADDRESS)r;
1045    tmp[2].Length = args[3];
1046
1047    tmp[3].TheAddress = (CAAM_ADDRESS)s;
1048    tmp[3].Length = args[3];
1049
1050    if (pubkey != NULL)
1051        CAAM_ADR_SYNC(pubkey, pubSz);
1052    CAAM_ADR_SYNC(hash, args[2]);
1053    CAAM_ADR_SYNC(r, args[3]);
1054    CAAM_ADR_SYNC(s, args[3]);
1055    caamDescInit(&desc, CAAM_ECDSA_VERIFY, args, tmp, 4);
1056    ret = caamECDSAVerify(&desc, tmp, 4, args);
1057
1058    /* free all buffers before inspecting the return value */
1059    CAAM_ADR_UNMAP(hash, 0, args[2], 0);
1060    CAAM_ADR_UNMAP(r, 0, args[3], 0);
1061    CAAM_ADR_UNMAP(s, 0, args[3], 0);
1062    if (pubkey != NULL)
1063        CAAM_ADR_UNMAP(pubkey, 0, pubSz, 0);
1064
1065    if (ret != Success) {
1066        return EBADMSG;
1067    }
1068    return EOK;
1069}
1070
1071
1072/* helper function to setup and do ECC sign
1073 * returns EOK on success
1074 */
1075static int doECDSA_SIGN(resmgr_context_t *ctp, io_devctl_t *msg,
1076        unsigned int args[4], unsigned int idx)
1077{
1078    int ret, keySz;
1079    DESCSTRUCT  desc;
1080    CAAM_BUFFER tmp[4];
1081
1082    unsigned char *key = NULL, *hash, *r, *s;
1083    CAAM_ADDRESS blackKey;
1084
1085    iov_t in_iovs[2], out_iovs[2];
1086
1087    if (args[0] == CAAM_BLACK_KEY_SM) {
1088        keySz = sizeof(CAAM_ADDRESS);
1089        SETIOV(&in_iovs[0], &blackKey, sizeof(CAAM_ADDRESS));
1090    }
1091    else {
1092        keySz = args[3];
1093        if (args[0] == CAAM_BLACK_KEY_CCM) {
1094            keySz += BLACK_KEY_MAC_SZ;
1095        }
1096        key   = (unsigned char*)CAAM_ADR_MAP(0, keySz, 0);
1097        if (key == NULL) {
1098            return ECANCELED;
1099        }
1100        SETIOV(&in_iovs[0], key, keySz);
1101    }
1102
1103    hash = (unsigned char*)CAAM_ADR_MAP(0, args[2], 0);
1104    if (hash == NULL) {
1105        if (key != NULL)
1106            CAAM_ADR_UNMAP(key, 0, keySz, 0);
1107        return ECANCELED;
1108    }
1109    SETIOV(&in_iovs[1], hash, args[2]);
1110    ret = resmgr_msgreadv(ctp, in_iovs, 2, idx);
1111    if ((keySz + args[2]) > ret) {
1112        WOLFSSL_MSG("Overflow reading key and hash");
1113        CAAM_ADR_UNMAP(hash, 0, args[2], 0);
1114        if (key != NULL)
1115            CAAM_ADR_UNMAP(key, 0, keySz, 0);
1116        return EOVERFLOW;
1117    }
1118
1119
1120    /* setup CAAM buffers to pass to driver */
1121    if (args[0] == CAAM_BLACK_KEY_SM) {
1122        tmp[0].TheAddress = blackKey;
1123        tmp[0].Length = args[3];
1124    }
1125    else {
1126        tmp[0].TheAddress = (CAAM_ADDRESS)key;
1127        tmp[0].Length = keySz;
1128    }
1129
1130    tmp[1].TheAddress = (CAAM_ADDRESS)hash;
1131    tmp[1].Length = args[2];
1132
1133    r = (unsigned char*)CAAM_ADR_MAP(0, args[3], 0);
1134    if (r == NULL) {
1135        CAAM_ADR_UNMAP(hash, 0, args[2], 0);
1136        if (key != NULL)
1137            CAAM_ADR_UNMAP(key, 0, keySz, 0);
1138        return ECANCELED;
1139    }
1140    tmp[2].TheAddress = (CAAM_ADDRESS)r;
1141    tmp[2].Length = args[3];
1142
1143    s = (unsigned char*)CAAM_ADR_MAP(0, args[3], 0);
1144    if (s == NULL) {
1145        CAAM_ADR_UNMAP(r, 0, args[3], 0);
1146        CAAM_ADR_UNMAP(hash, 0, args[2], 0);
1147        if (key != NULL)
1148            CAAM_ADR_UNMAP(key, 0, keySz, 0);
1149        return ECANCELED;
1150    }
1151    tmp[3].TheAddress = (CAAM_ADDRESS)s;
1152    tmp[3].Length = args[3];
1153
1154    caamDescInit(&desc, CAAM_ECDSA_SIGN, args, tmp, 4);
1155    ret = caamECDSASign(&desc, 4, args);
1156    CAAM_ADR_UNMAP(hash, 0, args[2], 0);
1157    if (key != NULL)
1158        CAAM_ADR_UNMAP(key, 0, keySz, 0);
1159    if (ret != Success) {
1160        CAAM_ADR_UNMAP(s, 0, args[3], 0);
1161        CAAM_ADR_UNMAP(r, 0, args[3], 0);
1162        return EBADMSG;
1163    }
1164
1165    if ((args[3] * 2) > msg->o.nbytes) {
1166        CAAM_ADR_UNMAP(s, 0, args[3], 0);
1167        CAAM_ADR_UNMAP(r, 0, args[3], 0);
1168        return EOVERFLOW;
1169    }
1170
1171    CAAM_ADR_SYNC(r, args[3]);
1172    CAAM_ADR_SYNC(s, args[3]);
1173    SETIOV(&out_iovs[0], r, args[3]);
1174    SETIOV(&out_iovs[1], s, args[3]);
1175
1176    ret = resmgr_msgwritev(ctp, &out_iovs[0], 2, sizeof(msg->o));
1177    CAAM_ADR_UNMAP(s, 0, args[3], 0);
1178    CAAM_ADR_UNMAP(r, 0, args[3], 0);
1179    if (ret < 0) {
1180        return ECANCELED;
1181    }
1182    return EOK;
1183}
1184
1185
1186/* helper function to setup and get an ECC shared secret
1187 * returns EOK on success
1188 */
1189static int doECDSA_ECDH(resmgr_context_t *ctp, io_devctl_t *msg,
1190        unsigned int args[4], unsigned int idx)
1191{
1192    int ret;
1193    DESCSTRUCT desc;
1194    CAAM_BUFFER tmp[3];
1195    int expectedSz = 0;
1196    iov_t in_iovs[2], out_iov;
1197
1198    unsigned char *pubkey = NULL, *key = NULL, *shared;
1199    CAAM_ADDRESS securePub, blackKey;
1200
1201    /* when using memory in secure partition just send the address */
1202    if (args[1] == CAAM_BLACK_KEY_SM) {
1203        SETIOV(&in_iovs[0], &securePub, sizeof(CAAM_ADDRESS));
1204        expectedSz += sizeof(CAAM_ADDRESS);
1205    }
1206    else {
1207        pubkey = (unsigned char*)CAAM_ADR_MAP(0, args[3]*2, 0);
1208        if (pubkey == NULL) {
1209            return ECANCELED;
1210        }
1211
1212        SETIOV(&in_iovs[0], pubkey, args[3]*2);
1213        expectedSz += args[3]*2;
1214    }
1215
1216    if (args[0] == CAAM_BLACK_KEY_SM) {
1217        SETIOV(&in_iovs[1], &blackKey, sizeof(CAAM_ADDRESS));
1218        expectedSz += sizeof(CAAM_ADDRESS);
1219    }
1220    else {
1221        if (args[0] == CAAM_BLACK_KEY_CCM) {
1222            key = (unsigned char*)CAAM_ADR_MAP(0, args[3] + BLACK_KEY_MAC_SZ, 0);
1223        }
1224        else {
1225            key = (unsigned char*)CAAM_ADR_MAP(0, args[3], 0);
1226        }
1227        if (key == NULL) {
1228            if (pubkey != NULL)
1229                CAAM_ADR_UNMAP(pubkey, 0, args[3]*2, 0);
1230            return ECANCELED;
1231        }
1232
1233        if (args[0] == CAAM_BLACK_KEY_CCM) {
1234            SETIOV(&in_iovs[1], key, args[3] + BLACK_KEY_MAC_SZ);
1235            expectedSz += args[3] + BLACK_KEY_MAC_SZ;
1236        }
1237        else {
1238            SETIOV(&in_iovs[1], key, args[3]);
1239            expectedSz += args[3];
1240        }
1241    }
1242
1243    ret = resmgr_msgreadv(ctp, in_iovs, 2, idx);
1244    if (expectedSz > ret) {
1245        if (pubkey != NULL)
1246            CAAM_ADR_UNMAP(pubkey, 0, args[3]*2, 0);
1247        if (key != NULL)
1248            CAAM_ADR_UNMAP(key, 0, args[3], 0);
1249        return ECANCELED;
1250    }
1251
1252    /* setup CAAM buffers to pass to driver */
1253    if (args[1] == CAAM_BLACK_KEY_SM) {
1254        tmp[0].TheAddress = securePub;
1255    }
1256    else {
1257        tmp[0].TheAddress = (CAAM_ADDRESS)pubkey;
1258    }
1259    tmp[0].Length = args[3]*2;
1260
1261    if (args[0] == CAAM_BLACK_KEY_SM) {
1262        tmp[1].TheAddress = blackKey;
1263    }
1264    else {
1265        tmp[1].TheAddress = (CAAM_ADDRESS)key;
1266    }
1267    tmp[1].Length = args[3];
1268
1269    shared = (unsigned char*)CAAM_ADR_MAP(0, args[3], 0);
1270    if (shared == NULL) {
1271        if (pubkey != NULL)
1272            CAAM_ADR_UNMAP(pubkey, 0, args[3]*2, 0);
1273        if (key != NULL)
1274            CAAM_ADR_UNMAP(key, 0, args[3], 0);
1275        return ECANCELED;
1276    }
1277
1278    tmp[2].TheAddress = (CAAM_ADDRESS)shared;
1279    tmp[2].Length = args[3];
1280    caamDescInit(&desc, CAAM_ECDSA_ECDH, args, tmp, 3);
1281    ret = caamECDSA_ECDH(&desc, 3, args);
1282    if (pubkey != NULL)
1283        CAAM_ADR_UNMAP(pubkey, 0, args[3]*2, 0);
1284    if (key != NULL)
1285        CAAM_ADR_UNMAP(key, 0, args[3], 0);
1286
1287    if (ret != Success) {
1288        CAAM_ADR_UNMAP(shared, 0, args[3], 0);
1289        return EBADMSG;
1290    }
1291
1292    if (args[3] > msg->o.nbytes) {
1293        CAAM_ADR_UNMAP(shared, 0, args[3], 0);
1294        return EOVERFLOW;
1295    }
1296    CAAM_ADR_SYNC(shared, args[3]);
1297    SETIOV(&out_iov, shared, args[3]);
1298    resmgr_msgwritev(ctp, &out_iov, 1, sizeof(msg->o));
1299    CAAM_ADR_UNMAP(shared, 0, args[3], 0);
1300    return EOK;
1301}
1302
1303
1304/* helper function to setup and cover data
1305 * returns EOK on success
1306 */
1307static int doFIFO_S(resmgr_context_t *ctp, io_devctl_t *msg,
1308        unsigned int args[4], unsigned int idx)
1309{
1310    int ret;
1311    DESCSTRUCT desc;
1312    CAAM_BUFFER tmp[2];
1313    iov_t in_iov, out_iov;
1314    unsigned char *inBuf, *outBuf;
1315
1316    inBuf = (unsigned char*)CAAM_ADR_MAP(0, args[1], 0);
1317    if (inBuf == NULL) {
1318        return ECANCELED;
1319    }
1320
1321    SETIOV(&in_iov, inBuf, args[1]);
1322    ret = resmgr_msgreadv(ctp, &in_iov, 1, idx);
1323    if (ret < args[1]) {
1324        return EBADMSG;
1325    }
1326
1327    outBuf = (unsigned char*)CAAM_ADR_MAP(0, args[1] + BLACK_KEY_MAC_SZ, 0);
1328    if (outBuf == NULL) {
1329        CAAM_ADR_UNMAP(inBuf, 0, args[1], 0);
1330        return ECANCELED;
1331    }
1332
1333    tmp[0].TheAddress = (CAAM_ADDRESS)inBuf;
1334    tmp[0].Length     = args[1];
1335    tmp[1].TheAddress = (CAAM_ADDRESS)outBuf;
1336    tmp[1].Length     = args[1]; /* tmp1 actually needs an additional 16 bytes
1337                                  * for MAC */
1338
1339    caamDescInit(&desc, CAAM_FIFO_S, args, tmp, 2);
1340    ret = caamKeyCover(&desc, 2, args);
1341    CAAM_ADR_UNMAP(inBuf, 0, args[1], 0);
1342    if (ret != Success) {
1343        CAAM_ADR_UNMAP(outBuf, 0, args[1] + BLACK_KEY_MAC_SZ, 0);
1344        return EBADMSG;
1345    }
1346
1347    if (args[1] + BLACK_KEY_MAC_SZ > msg->o.nbytes) {
1348        CAAM_ADR_UNMAP(outBuf, 0, args[1] + BLACK_KEY_MAC_SZ, 0);
1349        WOLFSSL_MSG("would cause output buffer overflow");
1350        return EOVERFLOW;
1351    }
1352
1353    SETIOV(&out_iov, outBuf, args[1] + BLACK_KEY_MAC_SZ);
1354    resmgr_msgwritev(ctp, &out_iov, 1, sizeof(msg->o));
1355    CAAM_ADR_UNMAP(outBuf, 0, args[1] + BLACK_KEY_MAC_SZ, 0);
1356    return EOK;
1357}
1358
1359
1360/* helper function to get partition
1361 * returns EOK on success
1362 */
1363static int doGET_PART(resmgr_context_t *ctp, io_devctl_t *msg,
1364        unsigned int args[4], unsigned int idx, iofunc_ocb_t *ocb)
1365{
1366    int partNumber;
1367    int partSz;
1368    CAAM_ADDRESS partAddr;
1369    iov_t out_iov;
1370
1371    partNumber = args[0];
1372    partSz     = args[1];
1373
1374    partAddr = caamGetPartition(partNumber, partSz, 0);
1375    if (partAddr == 0) {
1376        return EBADMSG;
1377    }
1378
1379    SETIOV(&out_iov, &partAddr, sizeof(CAAM_ADDRESS));
1380    resmgr_msgwritev(ctp, &out_iov, 1, sizeof(msg->o));
1381
1382    if (pthread_mutex_lock(&sm_mutex) != EOK) {
1383        return ECANCELED;
1384    }
1385    else {
1386        sm_ownerId[partNumber] = (CAAM_ADDRESS)ocb;
1387        pthread_mutex_unlock(&sm_mutex);
1388    }
1389    return EOK;
1390}
1391
1392
1393/* helper function to write to a partition
1394 * returns EOK on success
1395 */
1396static int doWRITE_PART(resmgr_context_t *ctp, io_devctl_t *msg,
1397        unsigned int args[4], unsigned int idx)
1398{
1399    int partSz, ret;
1400    CAAM_ADDRESS partAddr;
1401    CAAM_ADDRESS vaddr;
1402    unsigned char *buf;
1403    iov_t in_iov;
1404
1405    /* get arguments */
1406    partAddr = args[0];
1407    partSz   = args[1];
1408
1409    buf = (unsigned char*)CAAM_ADR_MAP(0, partSz, 0);
1410    if (buf == NULL) {
1411        return ECANCELED;
1412    }
1413
1414    SETIOV(&in_iov, buf, partSz);
1415    ret = resmgr_msgreadv(ctp, &in_iov, 1, idx);
1416    if (ret != partSz) {
1417        CAAM_ADR_UNMAP(buf, 0, partSz, 0);
1418        return EBADMSG;
1419    }
1420
1421    /* sanity check on address and length */
1422    if (sanityCheckPartitionAddress(partAddr, partSz) != 0) {
1423        CAAM_ADR_UNMAP(buf, 0, partSz, 0);
1424        return EBADMSG;
1425    }
1426
1427    vaddr = CAAM_ADR_TO_VIRTUAL(partAddr, partSz);
1428    if (vaddr == 0) {
1429        CAAM_ADR_UNMAP(buf, 0, partSz, 0);
1430        return ECANCELED;
1431    }
1432
1433    CAAM_ADR_UNMAP(buf, vaddr, partSz, 1);
1434    CAAM_ADR_UNMAP((void*)vaddr, 0, partSz, 0);
1435    return EOK;
1436}
1437
1438
1439/* helper function to read a partition
1440 * returns EOK on success
1441 */
1442static int doREAD_PART(resmgr_context_t *ctp, io_devctl_t *msg,
1443        unsigned int args[4], unsigned int idx)
1444{
1445    int partSz;
1446    CAAM_ADDRESS partAddr;
1447    CAAM_ADDRESS vaddr;
1448    unsigned char *buf;
1449    iov_t out_iov;
1450
1451    /* get arguments */
1452    partAddr = args[0];
1453    partSz   = args[1];
1454
1455    if (partSz > msg->o.nbytes) {
1456        WOLFSSL_MSG("not enough space to store read bytes");
1457        return EOVERFLOW;
1458    }
1459
1460    /* sanity check on address and length */
1461    if (sanityCheckPartitionAddress(partAddr, partSz) != 0) {
1462        return EBADMSG;
1463    }
1464
1465    buf = (unsigned char*)CAAM_ADR_MAP(0, partSz, 0);
1466    if (buf == NULL) {
1467        return ECANCELED;
1468    }
1469
1470    vaddr = CAAM_ADR_TO_VIRTUAL(partAddr, partSz);
1471    if (vaddr == 0) {
1472        CAAM_ADR_UNMAP(buf, 0, partSz, 0);
1473        return ECANCELED;
1474    }
1475
1476    memcpy(buf, (unsigned char*)vaddr, partSz);
1477    SETIOV(&out_iov, buf, partSz);
1478    resmgr_msgwritev(ctp, &out_iov, 1, sizeof(msg->o));
1479    CAAM_ADR_UNMAP(buf,   0, partSz, 0);
1480    CAAM_ADR_UNMAP((void*)vaddr, 0, partSz, 0);
1481    return EOK;
1482}
1483
1484
1485int io_devctl (resmgr_context_t *ctp, io_devctl_t *msg, iofunc_ocb_t *ocb)
1486{
1487    int ret = EBADMSG;
1488    unsigned int idx = sizeof(msg->i);
1489    unsigned int args[4];
1490    iov_t out_iov;
1491
1492    /* check if at least got the msg header */
1493    if( ctp->size < sizeof(msg->i) ) {
1494        return EBADMSG;
1495    }
1496
1497    if ((ret = iofunc_devctl_default (ctp, msg, ocb)) != _RESMGR_DEFAULT) {
1498        return ret;
1499    }
1500
1501    /* check callers access rights for read/write */
1502    if ((ret = iofunc_devctl_verify(ctp, msg, ocb,
1503                    _IO_DEVCTL_VERIFY_OCB_READ | _IO_DEVCTL_VERIFY_OCB_WRITE))
1504                    != EOK) {
1505        WOLFSSL_MSG("issue verify devctl");
1506        return ret;
1507    }
1508    /* _IO_DEVCTL_VERIFY_PRIV      : restrict to root */
1509    /* _IO_DEVCTL_VERIFY_ACC_ISUID : restrict to owner of device */
1510    /* _IO_DEVCTL_VERIFY_ACC_ISGID : restrict to group permissions */
1511
1512    if (getArgs(args, ctp, msg, &idx, ctp->size) != 0) {
1513        WOLFSSL_MSG("issue reading arguments");
1514        return EBADMSG;
1515    }
1516
1517    switch (msg->i.dcmd) {
1518        case WC_CAAM_CMAC:
1519            ret = doCMAC(ctp, msg, args, idx);
1520            break;
1521
1522        case WC_TRNG_CMD:
1523            ret = doTRNG(ctp, msg, args, idx);
1524            break;
1525
1526        case WC_CAAM_BLOB_ENCAP:
1527        case WC_CAAM_BLOB_DECAP:
1528            ret = doBLOB(ctp, msg, args, idx);
1529            break;
1530
1531        case WC_CAAM_AESECB:
1532        case WC_CAAM_AESCTR:
1533        case WC_CAAM_AESCBC:
1534            ret = doAES(ctp, msg, args, idx, msg->i.dcmd);
1535            break;
1536
1537        case WC_CAAM_AESCCM:
1538        case WC_CAAM_AESGCM:
1539            ret = doAEAD(ctp, msg, args, idx, msg->i.dcmd);
1540            break;
1541
1542        case WC_CAAM_ECDSA_KEYPAIR:
1543            ret = doECDSA_KEYPAIR(ctp, msg, args, idx, ocb);
1544            break;
1545
1546        case WC_CAAM_ECDSA_VERIFY:
1547            ret = doECDSA_VERIFY(ctp, msg, args, idx);
1548            break;
1549
1550        case WC_CAAM_ECDSA_SIGN:
1551            ret = doECDSA_SIGN(ctp, msg, args, idx);
1552            break;
1553
1554        case WC_CAAM_ECDSA_ECDH:
1555            ret = doECDSA_ECDH(ctp, msg, args, idx);
1556            break;
1557
1558        case WC_CAAM_FIFO_S:
1559            ret = doFIFO_S(ctp, msg, args, idx);
1560            break;
1561
1562        case WC_CAAM_GET_PART:
1563            ret = doGET_PART(ctp, msg, args, idx, ocb);
1564            break;
1565
1566        case WC_CAAM_FREE_PART:
1567            caamFreePart(args[0]);
1568
1569            if (pthread_mutex_lock(&sm_mutex) != EOK) {
1570                ret = ECANCELED;
1571            }
1572            else {
1573                sm_ownerId[args[0]] = 0;
1574                pthread_mutex_unlock(&sm_mutex);
1575                ret = EOK;
1576            }
1577            break;
1578
1579        case WC_CAAM_FIND_PART:
1580            ret = caamFindUnusedPartition();
1581            if (ret < 0) {
1582                /* none found, try again later */
1583                return EAGAIN;
1584            }
1585            SETIOV(&out_iov, &ret, sizeof(ret));
1586            resmgr_msgwritev(ctp, &out_iov, 1, sizeof(msg->o));
1587            ret = EOK;
1588            break;
1589
1590        case WC_CAAM_WRITE_PART:
1591            ret = doWRITE_PART(ctp, msg, args, idx);
1592            break;
1593
1594        case WC_CAAM_READ_PART:
1595            ret = doREAD_PART(ctp, msg, args, idx);
1596            break;
1597
1598        default:
1599            WOLFSSL_MSG("unknown option");
1600            return (ENOSYS);
1601    }
1602
1603    return ret;
1604}
1605
1606
1607int io_open(resmgr_context_t *ctp, io_open_t *msg, RESMGR_HANDLE_T *handle,
1608        void *extra)
1609{
1610    WOLFSSL_MSG("starting up");
1611    return (iofunc_open_default (ctp, msg, handle, extra));
1612}
1613
1614
1615int io_close_ocb(resmgr_context_t *ctp, void *reserved, RESMGR_OCB_T *ocb)
1616{
1617    int i;
1618
1619    WOLFSSL_MSG("shutting down");
1620
1621    /* free up any dangling owned memory */
1622    if (pthread_mutex_lock(&sm_mutex) != EOK) {
1623        return ECANCELED;
1624    }
1625    else {
1626        for (i = 0; i < MAX_PART; i++) {
1627            if (sm_ownerId[i] == (CAAM_ADDRESS)ocb) {
1628                sm_ownerId[i] = 0;
1629            #if defined(WOLFSSL_CAAM_DEBUG) || defined(WOLFSSL_CAAM_PRINT)
1630                printf("found dangiling partition at index %d\n", i);
1631            #endif
1632                caamFreePart(i);
1633            }
1634        }
1635        pthread_mutex_unlock(&sm_mutex);
1636    }
1637    return iofunc_close_ocb_default(ctp, reserved, ocb);
1638}
1639
1640
1641#if 0
1642static int getSupported(char* in)
1643{
1644        /* printf("CAAM Status [0x%8.8x]   = 0x%8.8x\n",
1645         *    CAAM_STATUS, WC_CAAM_READ(CAAM_STATUS));
1646         */
1647        printf("CAAM Version MS Register [0x%8.8x]  = 0x%8.8x\n",
1648            CAAM_VERSION_MS, CAAM_READ(CAAM_VERSION_MS));
1649        printf("CAAM Version LS Register [0x%8.8x]  = 0x%8.8x\n",
1650            CAAM_VERSION_LS, CAAM_READ(CAAM_VERSION_LS));
1651        printf("CAAM Support MS Register [0x%8.8x] = 0x%8.8x\n",
1652            CAMM_SUPPORT_MS, CAAM_READ(CAMM_SUPPORT_MS));
1653        printf("CAAM Support LS [0x%8.8x] = 0x%8.8x\n",
1654            CAMM_SUPPORT_LS, CAAM_READ(CAMM_SUPPORT_LS));
1655
1656    return strlen(in)+1;
1657}
1658#endif
1659
1660char cannedResponse[] = {
1661        "wolfCrypt QNX CAAM driver version "
1662        LIBWOLFSSL_VERSION_STRING
1663        "\nSupports:\n"
1664        "\tAES-CMAC\n"
1665        "\tAES (GCM/CCM/ECB/CBC/CTR)\n"
1666        "\tECC (sign, verify, ecdh, keygen)\n"
1667        "\tBlobs (black and red)\n"
1668};
1669
1670/* read is only used to get banner info of the driver */
1671int io_read (resmgr_context_t *ctp, io_read_t *msg, RESMGR_OCB_T *ocb)
1672{
1673    int status;
1674
1675    /* check callers access rights */
1676    if ((status = iofunc_read_verify(ctp, msg, ocb, NULL)) != EOK) {
1677        return (status);
1678    }
1679
1680    /* only support read not pread */
1681    if ((msg->i.xtype & _IO_XTYPE_MASK) != _IO_XTYPE_NONE) {
1682        return (ENOSYS);
1683    }
1684
1685    if (ocb->offset == 0) { /* just fill up what can */
1686        int sz = min(msg->i.nbytes, sizeof(cannedResponse));
1687        MsgReply(ctp->rcvid, sz, cannedResponse, sz);
1688        ocb->offset += sz;
1689    }
1690    else {
1691        MsgReply(ctp->rcvid, EOK, NULL, 0);
1692    }
1693
1694    return (_RESMGR_NOREPLY);
1695}
1696
1697
1698int io_write(resmgr_context_t *ctp, io_write_t *msg, RESMGR_OCB_T *ocb)
1699{
1700    (void)ctp;
1701    (void)msg;
1702    (void)ocb;
1703
1704    /* write is not supported */
1705    return (ENOSYS);
1706}
1707
1708
1709int main(int argc, char *argv[])
1710{
1711    int name;
1712    int i;
1713
1714    pthread_mutex_init(&sm_mutex, NULL);
1715    for (i = 0; i < MAX_PART; i++) {
1716        sm_ownerId[i] = 0;
1717    }
1718
1719    if (InitCAAM() != 0) {
1720        WOLFSSL_MSG("unable to start up caam driver!");
1721        exit(1);
1722    }
1723    localMemory = (unsigned char*)CAAM_ADR_MAP(0, WOLFSSL_CAAM_QNX_MEMORY, 0);
1724    localPhy = CAAM_ADR_TO_PHYSICAL(localMemory, WOLFSSL_CAAM_QNX_MEMORY);
1725    sem_init(&localMemSem, 1, 1);
1726
1727    dpp = dispatch_create();
1728    if (dpp == NULL) {
1729        exit (1);
1730    }
1731    memset(&rattr, 0, sizeof(rattr));
1732    iofunc_func_init(_RESMGR_CONNECT_NFUNCS, &connect_funcs,
1733            _RESMGR_IO_NFUNCS, &io_funcs);
1734
1735    connect_funcs.open = io_open;
1736    io_funcs.close_ocb = io_close_ocb;
1737    io_funcs.read      = io_read;
1738    io_funcs.write     = io_write;
1739    io_funcs.devctl    = io_devctl;
1740
1741    iofunc_attr_init (&ioattr, S_IFCHR | 0666, NULL, NULL);
1742    name = resmgr_attach(dpp, &rattr, "/dev/wolfCrypt",
1743            _FTYPE_ANY, 0, &connect_funcs, &io_funcs, &ioattr);
1744    if (name == -1) {
1745        exit (1);
1746    }
1747
1748    ctp = dispatch_context_alloc(dpp);
1749    while (1) {
1750        dispatch_context_t *current_ctp;
1751
1752        current_ctp = dispatch_block(ctp);
1753        if (current_ctp == NULL) {
1754            /* test if was just an interrupt, if so retry */
1755            if (errno == EINTR)
1756                continue;
1757
1758            /* other errors are EFAULT, EINVAL, ENOMEM
1759             * close down in these cases */
1760            perror("Error from dispatch_block ");
1761            break;
1762        }
1763        else {
1764            ctp = current_ctp;
1765            dispatch_handler(ctp);
1766        }
1767    }
1768
1769    sem_destroy(&localMemSem);
1770    pthread_mutex_destroy(&sm_mutex);
1771    if (localMemory != NULL)
1772        CAAM_ADR_UNMAP(localMemory, 0, WOLFSSL_CAAM_QNX_MEMORY, 0);
1773
1774    CleanupCAAM();
1775    return 0;
1776}
1777
1778#endif /* __QNX__ || __QNXNTO__ */