luna - wolfssl/mcapi/mcapi

   1/* mcapi_test.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
  23
  24/* Tests Microchip CRYPTO API layer */
  25
  26#ifdef HAVE_CONFIG_H
  27    #include <config.h>
  28#endif
  29
  30#ifndef WOLFSSL_USER_SETTINGS
  31    #include <wolfssl/options.h>
  32#endif
  33#include <wolfssl/wolfcrypt/settings.h>
  34
  35/* mc api header */
  36#include "crypto.h"
  37
  38/* sanity test against our default implementation, wolfssl headers  */
  39#include <wolfssl/wolfcrypt/md5.h>
  40#include <wolfssl/wolfcrypt/sha.h>
  41#include <wolfssl/wolfcrypt/sha256.h>
  42#include <wolfssl/wolfcrypt/sha512.h>
  43#include <wolfssl/wolfcrypt/hmac.h>
  44#include <wolfssl/wolfcrypt/compress.h>
  45#include <wolfssl/wolfcrypt/random.h>
  46#include <wolfssl/wolfcrypt/des3.h>
  47#include <wolfssl/wolfcrypt/aes.h>
  48#include <wolfssl/wolfcrypt/ecc.h>
  49#include <wolfssl/wolfcrypt/rsa.h>
  50#define USE_CERT_BUFFERS_1024
  51#include <wolfssl/certs_test.h>
  52
  53#if defined(WOLFSSL_MICROCHIP_PIC32MZ)
  54    #define MICROCHIP_PIC32
  55    #include <xc.h>
  56    #pragma config ICESEL = ICS_PGx2
  57            /* ICE/ICD Comm Channel Select (Communicate on PGEC2/PGED2) */
  58    #include <stdio.h>
  59    #include <stdlib.h>
  60    #include "PIC32MZ-serial.h"
  61    #define  SYSTEMConfigPerformance(n) /* void out SYSTEMConfigPerformance(); */
  62#elif defined(MICROCHIP_PIC32)
  63    #define PIC32_STARTER_KIT
  64    #include <stdio.h>
  65    #include <stdlib.h>
  66    #include <p32xxxx.h>
  67    #define _SUPPRESS_PLIB_WARNING
  68    #define _DISABLE_OPENADC10_CONFIGPORT_WARNING
  69    #include <plib.h>
  70    #include <sys/appio.h>
  71    #define init_serial()  /* void out init_serial() */
  72#else
  73    #include <stdio.h>  /* order matters above ? */
  74#endif
  75#define OUR_DATA_SIZE 1024
  76static byte ourData[OUR_DATA_SIZE];
  77static byte* key = NULL;
  78static byte* iv  = NULL;
  79static CRYPT_RNG_CTX mcRng;
  80static WC_RNG        defRng;
  81
  82static int check_md5(void);
  83static int check_sha(void);
  84static int check_sha256(void);
  85static int check_sha384(void);
  86static int check_sha512(void);
  87static int check_hmac(void);
  88static int check_compress(void);
  89static int check_rng(void);
  90static int check_des3(void);
  91static int check_aescbc(void);
  92static int check_aesctr(void);
  93static int check_aesdirect(void);
  94static int check_rsa(void);
  95static int check_ecc(void);
  96
  97
  98int main(int argc, char** argv)
  99{
 100    int ret;
 101    int i;
 102
 103    (void)argc;
 104    (void)argv;
 105
 106#if defined(MICROCHIP_PIC32)
 107    init_serial() ;  /* initialize PIC32MZ serial I/O */
 108    SYSTEMConfigPerformance(80000000);
 109    DBINIT();
 110#endif
 111
 112    /* align key, iv pointers */
 113    key = (byte*)XMALLOC(32, NULL, DYNAMIC_TYPE_KEY);
 114    if (key == NULL) {
 115        printf("mcapi key alloc failed\n");
 116        return -1;
 117    }
 118
 119    iv = (byte*)XMALLOC(16, NULL, DYNAMIC_TYPE_KEY);
 120    if (iv == NULL) {
 121        printf("mcapi iv alloc failed\n");
 122        return -1;
 123    }
 124
 125    for (i = 0; i < OUR_DATA_SIZE; i++)
 126        ourData[i] = (byte)i;
 127
 128    ret = check_md5();
 129    if (ret != 0) {
 130        printf("mcapi check_md5 failed\n");
 131        return -1;
 132    }
 133
 134    ret = check_sha();
 135    if (ret != 0) {
 136        printf("mcapi check_sha failed\n");
 137        return -1;
 138    }
 139
 140    ret = check_sha256();
 141    if (ret != 0) {
 142        printf("mcapi check_sha256 failed\n");
 143        return -1;
 144    }
 145
 146    ret = check_sha384();
 147    if (ret != 0) {
 148        printf("mcapi check_sha384 failed\n");
 149        return -1;
 150    }
 151
 152    ret = check_sha512();
 153    if (ret != 0) {
 154        printf("mcapi check_sha512 failed\n");
 155        return -1;
 156    }
 157
 158    ret = check_hmac();
 159    if (ret != 0) {
 160        printf("mcapi check_hmac failed\n");
 161        return -1;
 162    }
 163
 164    ret = check_compress();
 165    if (ret != 0) {
 166        printf("mcapi check_compress failed\n");
 167        return -1;
 168    }
 169
 170    ret = check_rng();
 171    if (ret != 0) {
 172        printf("mcapi check_rng failed\n");
 173        return -1;
 174    }
 175
 176    ret = check_des3();
 177    if (ret != 0) {
 178        printf("mcapi check_des3 failed\n");
 179        return -1;
 180    }
 181
 182    ret = check_aescbc();
 183    if (ret != 0) {
 184        printf("mcapi check_aes cbc failed\n");
 185        return -1;
 186    }
 187
 188    ret = check_aesctr();
 189    if (ret != 0) {
 190        printf("mcapi check_aes ctr failed\n");
 191        return -1;
 192    }
 193
 194    ret = check_aesdirect();
 195    if (ret != 0) {
 196        printf("mcapi check_aes direct failed\n");
 197        return -1;
 198    }
 199
 200    ret = check_rsa();
 201    if (ret != 0) {
 202        printf("mcapi check_rsa failed\n");
 203        return -1;
 204    }
 205
 206    ret = check_ecc();
 207    if (ret != 0) {
 208        printf("mcapi check_ecc failed\n");
 209        return -1;
 210    }
 211
 212    XFREE(iv,  NULL, DYNAMIC_TYPE_KEY);
 213    XFREE(key, NULL, DYNAMIC_TYPE_KEY);
 214
 215    return 0;
 216}
 217
 218
 219/* check mcapi md5 against internal */
 220static int check_md5(void)
 221{
 222    CRYPT_MD5_CTX mcMd5;
 223    Md5           defMd5;
 224    int           ret;
 225    byte          mcDigest[CRYPT_MD5_DIGEST_SIZE];
 226    byte          defDigest[MD5_DIGEST_SIZE];
 227
 228    CRYPT_MD5_Initialize(&mcMd5);
 229    ret = wc_InitMd5(&defMd5);
 230
 231    if (ret == 0) {
 232        CRYPT_MD5_DataAdd(&mcMd5, ourData, OUR_DATA_SIZE);
 233        ret = wc_Md5Update(&defMd5, ourData, OUR_DATA_SIZE);
 234    }
 235
 236    if (ret == 0) {
 237        CRYPT_MD5_Finalize(&mcMd5, mcDigest);
 238        ret = wc_Md5Final(&defMd5, defDigest);
 239    }
 240
 241    if (ret != 0) {
 242        printf("md5 failed\n");
 243        return -1;
 244    }
 245
 246    if (memcmp(mcDigest, defDigest, CRYPT_MD5_DIGEST_SIZE) != 0) {
 247        printf("md5 final memcmp failed\n");
 248        return -1;
 249    }
 250    printf("md5         mcapi test passed\n");
 251
 252    return ret;
 253}
 254
 255
 256/* check mcapi sha against internal */
 257static int check_sha(void)
 258{
 259    CRYPT_SHA_CTX mcSha;
 260    Sha           defSha;
 261    int           ret = 0;
 262    byte          mcDigest[CRYPT_SHA_DIGEST_SIZE];
 263    byte          defDigest[SHA_DIGEST_SIZE];
 264
 265    CRYPT_SHA_Initialize(&mcSha);
 266    ret = wc_InitSha(&defSha);
 267    if (ret != 0) {
 268        printf("sha init default failed\n");
 269        return -1;
 270    }
 271
 272    CRYPT_SHA_DataAdd(&mcSha, ourData, OUR_DATA_SIZE);
 273    wc_ShaUpdate(&defSha, ourData, OUR_DATA_SIZE);
 274
 275    CRYPT_SHA_Finalize(&mcSha, mcDigest);
 276    wc_ShaFinal(&defSha, defDigest);
 277
 278    if (memcmp(mcDigest, defDigest, CRYPT_SHA_DIGEST_SIZE) != 0) {
 279        printf("sha final memcmp failed\n");
 280        return -1;
 281    }
 282    printf("sha         mcapi test passed\n");
 283
 284    return 0;
 285}
 286
 287
 288/* check mcapi sha256 against internal */
 289static int check_sha256(void)
 290{
 291    CRYPT_SHA256_CTX mcSha256;
 292    wc_Sha256        defSha256;
 293    int              ret;
 294    byte             mcDigest[CRYPT_SHA256_DIGEST_SIZE];
 295    byte             defDigest[WC_SHA256_DIGEST_SIZE];
 296
 297    CRYPT_SHA256_Initialize(&mcSha256);
 298    ret = wc_InitSha256(&defSha256);
 299    if (ret != 0) {
 300        printf("sha256 init default failed\n");
 301        return -1;
 302    }
 303
 304    CRYPT_SHA256_DataAdd(&mcSha256, ourData, OUR_DATA_SIZE);
 305    ret = wc_Sha256Update(&defSha256, ourData, OUR_DATA_SIZE);
 306    if (ret != 0) {
 307        printf("sha256 update default failed\n");
 308        return -1;
 309    }
 310
 311    CRYPT_SHA256_Finalize(&mcSha256, mcDigest);
 312    ret = wc_Sha256Final(&defSha256, defDigest);
 313    if (ret != 0) {
 314        printf("sha256 final default failed\n");
 315        return -1;
 316    }
 317
 318    if (memcmp(mcDigest, defDigest, CRYPT_SHA256_DIGEST_SIZE) != 0) {
 319        printf("sha256 final memcmp failed\n");
 320        return -1;
 321    }
 322    printf("sha256      mcapi test passed\n");
 323
 324    return 0;
 325}
 326
 327
 328/* check mcapi sha384 against internal */
 329static int check_sha384(void)
 330{
 331    CRYPT_SHA384_CTX mcSha384;
 332    wc_Sha384        defSha384;
 333    int              ret;
 334    byte             mcDigest[CRYPT_SHA384_DIGEST_SIZE];
 335    byte             defDigest[WC_SHA384_DIGEST_SIZE];
 336
 337    CRYPT_SHA384_Initialize(&mcSha384);
 338    ret = wc_InitSha384(&defSha384);
 339    if (ret != 0) {
 340        printf("sha384 init default failed\n");
 341        return -1;
 342    }
 343
 344    CRYPT_SHA384_DataAdd(&mcSha384, ourData, OUR_DATA_SIZE);
 345    ret = wc_Sha384Update(&defSha384, ourData, OUR_DATA_SIZE);
 346    if (ret != 0) {
 347        printf("sha384 update default failed\n");
 348        return -1;
 349    }
 350
 351    CRYPT_SHA384_Finalize(&mcSha384, mcDigest);
 352    ret = wc_Sha384Final(&defSha384, defDigest);
 353    if (ret != 0) {
 354        printf("sha384 final default failed\n");
 355        return -1;
 356    }
 357
 358    if (memcmp(mcDigest, defDigest, CRYPT_SHA384_DIGEST_SIZE) != 0) {
 359        printf("sha384 final memcmp failed\n");
 360        return -1;
 361    }
 362    printf("sha384      mcapi test passed\n");
 363
 364    return 0;
 365}
 366
 367
 368/* check mcapi sha512 against internal */
 369static int check_sha512(void)
 370{
 371    CRYPT_SHA512_CTX mcSha512;
 372    wc_Sha512        defSha512;
 373    int              ret;
 374    byte             mcDigest[CRYPT_SHA512_DIGEST_SIZE];
 375    byte             defDigest[WC_SHA512_DIGEST_SIZE];
 376
 377    CRYPT_SHA512_Initialize(&mcSha512);
 378    ret = wc_InitSha512(&defSha512);
 379    if (ret != 0) {
 380        printf("sha512 init default failed\n");
 381        return -1;
 382    }
 383
 384    CRYPT_SHA512_DataAdd(&mcSha512, ourData, OUR_DATA_SIZE);
 385    ret = wc_Sha512Update(&defSha512, ourData, OUR_DATA_SIZE);
 386    if (ret != 0) {
 387        printf("sha512 update default failed\n");
 388        return -1;
 389    }
 390
 391    CRYPT_SHA512_Finalize(&mcSha512, mcDigest);
 392    ret = wc_Sha512Final(&defSha512, defDigest);
 393    if (ret != 0) {
 394        printf("sha512 final default failed\n");
 395        return -1;
 396    }
 397
 398    if (memcmp(mcDigest, defDigest, CRYPT_SHA512_DIGEST_SIZE) != 0) {
 399        printf("sha512 final memcmp failed\n");
 400        return -1;
 401    }
 402    printf("sha512      mcapi test passed\n");
 403
 404    return 0;
 405}
 406
 407
 408/* check mcapi hmac against internal */
 409static int check_hmac(void)
 410{
 411    CRYPT_HMAC_CTX mcHmac;
 412    Hmac           defHmac;
 413    int            ret;
 414    byte           mcDigest[CRYPT_SHA512_DIGEST_SIZE];
 415    byte           defDigest[WC_SHA512_DIGEST_SIZE];
 416
 417    memcpy((char*)key, "Jefe", 4);
 418
 419    /* SHA1 */
 420    CRYPT_HMAC_SetKey(&mcHmac, CRYPT_HMAC_SHA, key, 4);
 421    ret = wc_HmacSetKey(&defHmac, WC_SHA, key, 4);
 422    if (ret != 0) {
 423        printf("hmac sha setkey default failed\n");
 424        return -1;
 425    }
 426
 427    CRYPT_HMAC_DataAdd(&mcHmac, ourData, OUR_DATA_SIZE);
 428    ret = wc_HmacUpdate(&defHmac, ourData, OUR_DATA_SIZE);
 429    if (ret != 0) {
 430        printf("hmac sha update default failed\n");
 431        return -1;
 432    }
 433
 434    CRYPT_HMAC_Finalize(&mcHmac, mcDigest);
 435    ret = wc_HmacFinal(&defHmac, defDigest);
 436    if (ret != 0) {
 437        printf("hmac sha final default failed\n");
 438        return -1;
 439    }
 440
 441    if (memcmp(mcDigest, defDigest, CRYPT_SHA_DIGEST_SIZE) != 0) {
 442        printf("hmac sha final memcmp failed\n");
 443        return -1;
 444    }
 445    printf("hmac sha    mcapi test passed\n");
 446
 447    /* SHA-256 */
 448    CRYPT_HMAC_SetKey(&mcHmac, CRYPT_HMAC_SHA256, key, 4);
 449    ret = wc_HmacSetKey(&defHmac, WC_SHA256, key, 4);
 450    if (ret != 0) {
 451        printf("hmac sha256 setkey default failed\n");
 452        return -1;
 453    }
 454
 455    CRYPT_HMAC_DataAdd(&mcHmac, ourData, OUR_DATA_SIZE);
 456    ret = wc_HmacUpdate(&defHmac, ourData, OUR_DATA_SIZE);
 457    if (ret != 0) {
 458        printf("hmac sha256 update default failed\n");
 459        return -1;
 460    }
 461
 462    CRYPT_HMAC_Finalize(&mcHmac, mcDigest);
 463    ret = wc_HmacFinal(&defHmac, defDigest);
 464    if (ret != 0) {
 465        printf("hmac sha256 final default failed\n");
 466        return -1;
 467    }
 468
 469    if (memcmp(mcDigest, defDigest, CRYPT_SHA256_DIGEST_SIZE) != 0) {
 470        printf("hmac sha256 final memcmp failed\n");
 471        return -1;
 472    }
 473    printf("hmac sha256 mcapi test passed\n");
 474
 475    /* SHA-384 */
 476    CRYPT_HMAC_SetKey(&mcHmac, CRYPT_HMAC_SHA384, key, 4);
 477    ret = wc_HmacSetKey(&defHmac, WC_SHA384, key, 4);
 478    if (ret != 0) {
 479        printf("hmac sha384 setkey default failed\n");
 480        return -1;
 481    }
 482
 483    CRYPT_HMAC_DataAdd(&mcHmac, ourData, OUR_DATA_SIZE);
 484    ret = wc_HmacUpdate(&defHmac, ourData, OUR_DATA_SIZE);
 485    if (ret != 0) {
 486        printf("hmac sha384 update default failed\n");
 487        return -1;
 488    }
 489
 490    CRYPT_HMAC_Finalize(&mcHmac, mcDigest);
 491    ret = wc_HmacFinal(&defHmac, defDigest);
 492    if (ret != 0) {
 493        printf("hmac sha384 final default failed\n");
 494        return -1;
 495    }
 496
 497    if (memcmp(mcDigest, defDigest, CRYPT_SHA384_DIGEST_SIZE) != 0) {
 498        printf("hmac sha384 final memcmp failed\n");
 499        return -1;
 500    }
 501    printf("hmac sha384 mcapi test passed\n");
 502
 503    /* SHA-512 */
 504    CRYPT_HMAC_SetKey(&mcHmac, CRYPT_HMAC_SHA512, key, 4);
 505    ret = wc_HmacSetKey(&defHmac, WC_SHA512, key, 4);
 506    if (ret != 0) {
 507        printf("hmac sha512 setkey default failed\n");
 508        return -1;
 509    }
 510
 511    CRYPT_HMAC_DataAdd(&mcHmac, ourData, OUR_DATA_SIZE);
 512    ret = wc_HmacUpdate(&defHmac, ourData, OUR_DATA_SIZE);
 513    if (ret != 0) {
 514        printf("hmac sha512 update default failed\n");
 515        return -1;
 516    }
 517
 518    CRYPT_HMAC_Finalize(&mcHmac, mcDigest);
 519    ret = wc_HmacFinal(&defHmac, defDigest);
 520    if (ret != 0) {
 521        printf("hmac sha512 final default failed\n");
 522        return -1;
 523    }
 524
 525    if (memcmp(mcDigest, defDigest, CRYPT_SHA512_DIGEST_SIZE) != 0) {
 526        printf("hmac sha512 final memcmp failed\n");
 527        return -1;
 528    }
 529    printf("hmac sha512 mcapi test passed\n");
 530
 531    return 0;
 532}
 533
 534
 535/* check mcapi compress against internal */
 536static int check_compress(void)
 537{
 538    const unsigned char text[] =
 539    "Biodiesel cupidatat marfa, cliche aute put a bird on it incididunt elit\n"
 540    "polaroid. Sunt tattooed bespoke reprehenderit. Sint twee organic id\n"
 541    "marfa. Commodo veniam ad esse gastropub. 3 wolf moon sartorial vero,\n"
 542    "plaid delectus biodiesel squid +1 vice. Post-ironic keffiyeh leggings\n"
 543    "selfies cray fap hoodie, forage anim. Carles cupidatat shoreditch, VHS\n"
 544    "small batch meggings kogi dolore food truck bespoke gastropub.\n"
 545    "\n"
 546    "Terry richardson adipisicing actually typewriter tumblr, twee whatever\n"
 547    "four loko you probably haven't heard of them high life. Messenger bag\n"
 548    "whatever tattooed deep v mlkshk. Brooklyn pinterest assumenda chillwave\n"
 549    "et, banksy ullamco messenger bag umami pariatur direct trade forage.\n"
 550    "Typewriter culpa try-hard, pariatur sint brooklyn meggings. Gentrify\n"
 551    "food truck next level, tousled irony non semiotics PBR ethical anim cred\n"
 552    "readymade. Mumblecore brunch lomo odd future, portland organic terry\n"
 553    "four loko whatever street art yr farm-to-table.\n";
 554
 555    unsigned int inSz  = sizeof(text);
 556    unsigned int outSz;
 557    unsigned char cBuffer[1024];
 558    unsigned char dBuffer[1024];
 559
 560    int ret1, ret2;
 561
 562    /* dynamic */
 563    ret1 = CRYPT_HUFFMAN_Compress(cBuffer, sizeof(cBuffer), text, inSz, 0);
 564    ret2 = wc_Compress(dBuffer, sizeof(dBuffer), text, inSz, 0);
 565
 566    if (ret1 != ret2 || ret1 < 0) {
 567        printf("compress dynamic ret failed\n");
 568        return -1;
 569    }
 570    outSz = ret1;
 571
 572    if (memcmp(cBuffer, dBuffer, outSz) != 0) {
 573        printf("compress dynamic cmp failed\n");
 574        return -1;
 575    }
 576
 577    ret1 = CRYPT_HUFFMAN_DeCompress(dBuffer, sizeof(dBuffer), cBuffer, outSz);
 578
 579    if (memcmp(dBuffer, text, inSz) != 0) {
 580        printf("mcapi decompress dynamic cmp failed\n");
 581        return -1;
 582    }
 583
 584    memset(dBuffer, 0, sizeof(dBuffer));
 585    ret2 = wc_DeCompress(dBuffer, sizeof(dBuffer), cBuffer, outSz);
 586
 587    if (ret1 != ret2 || ret2 < 0) {
 588        printf("decompress dynamic ret failed\n");
 589    }
 590    if (memcmp(dBuffer, text, inSz) != 0) {
 591        printf("decompress dynamic cmp failed\n");
 592        return -1;
 593    }
 594
 595    memset(cBuffer, 0, sizeof(cBuffer));
 596    memset(dBuffer, 0, sizeof(dBuffer));
 597
 598    /* static */
 599    ret1 = CRYPT_HUFFMAN_Compress(cBuffer, sizeof(cBuffer), text, inSz, 1);
 600    ret2 = wc_Compress(dBuffer, sizeof(dBuffer), text, inSz, 1);
 601
 602    if (ret1 != ret2 || ret1 < 0) {
 603        printf("compress static ret failed\n");
 604        return -1;
 605    }
 606    outSz = ret1;
 607
 608    if (memcmp(cBuffer, dBuffer, outSz) != 0) {
 609        printf("compress static cmp failed\n");
 610        return -1;
 611    }
 612
 613
 614    ret1 = CRYPT_HUFFMAN_DeCompress(dBuffer, sizeof(dBuffer), cBuffer, outSz);
 615
 616    if (memcmp(dBuffer, text, inSz) != 0) {
 617        printf("mcapi decompress static cmp failed\n");
 618        return -1;
 619    }
 620
 621    memset(dBuffer, 0, sizeof(dBuffer));
 622    ret2 = wc_DeCompress(dBuffer, sizeof(dBuffer), cBuffer, outSz);
 623    if (ret1 != ret2 || ret2 < 0) {
 624        printf("decompress static ret failed\n");
 625    }
 626    if (memcmp(dBuffer, text, inSz) != 0) {
 627        printf("decompress static cmp failed\n");
 628        return -1;
 629    }
 630
 631    printf("huffman     mcapi test passed\n");
 632
 633    return 0;
 634}
 635
 636
 637#define RANDOM_BYTE_SZ 32
 638
 639/* check mcapi rng */
 640static int check_rng(void)
 641{
 642    int           ret;
 643    int           i;
 644    byte          in[RANDOM_BYTE_SZ];
 645    byte          out[RANDOM_BYTE_SZ];
 646
 647    for (i = 0; i < RANDOM_BYTE_SZ; i++)
 648        in[i] = (byte)i;
 649
 650    for (i = 0; i < RANDOM_BYTE_SZ; i++)
 651        out[i] = (byte)i;
 652
 653    ret = wc_InitRng(&defRng);
 654    if (ret != 0) {
 655        printf("default rng init failed\n");
 656        return -1;
 657    }
 658
 659    ret = CRYPT_RNG_Initialize(&mcRng);
 660    if (ret != 0) {
 661        printf("mcapi rng init failed\n");
 662        return -1;
 663    }
 664
 665    ret = CRYPT_RNG_Get(&mcRng, &out[0]);
 666    if (ret != 0) {
 667        printf("mcapi rng get failed\n");
 668        return -1;
 669    }
 670
 671    ret = CRYPT_RNG_BlockGenerate(&mcRng, out, RANDOM_BYTE_SZ);
 672    if (ret != 0) {
 673        printf("mcapi rng block gen failed\n");
 674        return -1;
 675    }
 676
 677    if (memcmp(in, out, RANDOM_BYTE_SZ) == 0) {
 678        printf("mcapi rng block gen output failed\n");
 679        return -1;
 680    }
 681
 682    printf("rng         mcapi test passed\n");
 683
 684    return 0;
 685}
 686
 687
 688#define TDES_TEST_SIZE 32
 689
 690/* check mcapi des3 */
 691static int check_des3(void)
 692{
 693    CRYPT_TDES_CTX mcDes3;
 694    Des3           defDes3;
 695    int            ret;
 696    byte           out1[TDES_TEST_SIZE];
 697    byte           out2[TDES_TEST_SIZE];
 698
 699    memcpy((char*)key, "1234567890abcdefghijklmn", 24);
 700    memcpy((char*)iv,  "12345678", 8);
 701
 702    /* cbc encrypt */
 703    ret = CRYPT_TDES_KeySet(&mcDes3, key, iv, CRYPT_TDES_ENCRYPTION);
 704    if (ret != 0) {
 705        printf("mcapi tdes key set failed\n");
 706        return -1;
 707    }
 708    ret = wc_Des3_SetKey(&defDes3, key, iv, DES_ENCRYPTION);
 709    if (ret != 0) {
 710        printf("default des3 key set failed\n");
 711        return -1;
 712    }
 713
 714    ret = CRYPT_TDES_CBC_Encrypt(&mcDes3, out1, ourData, TDES_TEST_SIZE);
 715    if (ret != 0) {
 716        printf("mcapi tdes cbc encrypt failed\n");
 717        return -1;
 718    }
 719    ret = wc_Des3_CbcEncrypt(&defDes3, out2, ourData, TDES_TEST_SIZE);
 720    if (ret != 0) {
 721        printf("mcapi default tdes cbc encrypt failed\n");
 722        return -1;
 723    }
 724
 725    if (memcmp(out1, out2, TDES_TEST_SIZE) != 0) {
 726        printf("mcapi tdes cbc encrypt cmp failed\n");
 727        return -1;
 728    }
 729
 730    /* cbc decrypt */
 731    ret = CRYPT_TDES_KeySet(&mcDes3, key, iv, CRYPT_TDES_DECRYPTION);
 732    if (ret != 0) {
 733        printf("mcapi tdes key set failed\n");
 734        return -1;
 735    }
 736    ret = wc_Des3_SetKey(&defDes3, key, iv, DES_DECRYPTION);
 737    if (ret != 0) {
 738        printf("default des3 key set failed\n");
 739        return -1;
 740    }
 741
 742    ret = CRYPT_TDES_CBC_Decrypt(&mcDes3, out2, out1, TDES_TEST_SIZE);
 743    if (ret != 0) {
 744        printf("mcapi tdes cbc decrypt failed\n");
 745        return -1;
 746    }
 747    ret = wc_Des3_CbcDecrypt(&defDes3, out1, out1, TDES_TEST_SIZE);
 748    if (ret != 0) {
 749        printf("mcapi default tdes cbc decrypt failed\n");
 750        return -1;
 751    }
 752
 753    if (memcmp(out1, out2, TDES_TEST_SIZE) != 0) {
 754        printf("mcapi tdes cbc decrypt cmp failed\n");
 755        return -1;
 756    }
 757
 758    if (memcmp(out1, ourData, TDES_TEST_SIZE) != 0) {
 759        printf("mcapi tdes cbc decrypt orig cmp failed\n");
 760        return -1;
 761    }
 762
 763    printf("tdes        mcapi test passed\n");
 764
 765    return 0;
 766}
 767
 768
 769#define AES_TEST_SIZE 32
 770
 771/* check mcapi aes cbc */
 772static int check_aescbc(void)
 773{
 774    CRYPT_AES_CTX mcAes;
 775    Aes           defAes;
 776    int           ret;
 777    byte          out1[AES_TEST_SIZE];
 778    byte          out2[AES_TEST_SIZE];
 779
 780    memcpy((char*)key, "1234567890abcdefghijklmnopqrstuv", 32);
 781    memcpy((char*)iv,  "1234567890abcdef", 16);
 782
 783    /* 128 cbc encrypt */
 784    ret = CRYPT_AES_KeySet(&mcAes, key, 16, iv, CRYPT_AES_ENCRYPTION);
 785    if (ret != 0) {
 786        printf("mcapi aes-128 key set failed\n");
 787        return -1;
 788    }
 789    ret = wc_AesSetKey(&defAes, key, 16, iv, AES_ENCRYPTION);
 790    if (ret != 0) {
 791        printf("default aes-128 key set failed\n");
 792        return -1;
 793    }
 794
 795    ret = CRYPT_AES_CBC_Encrypt(&mcAes, out1, ourData, AES_TEST_SIZE);
 796    if (ret != 0) {
 797        printf("mcapi aes-128 cbc encrypt failed\n");
 798        return -1;
 799    }
 800    wc_AesCbcEncrypt(&defAes, out2, ourData, AES_TEST_SIZE);
 801
 802    if (memcmp(out1, out2, AES_TEST_SIZE) != 0) {
 803        printf("mcapi aes-128 cbc encrypt cmp failed\n");
 804        return -1;
 805    }
 806
 807    /* 128 cbc decrypt */
 808    ret = CRYPT_AES_KeySet(&mcAes, key, 16, iv, CRYPT_AES_DECRYPTION);
 809    if (ret != 0) {
 810        printf("mcapi aes-128 key set failed\n");
 811        return -1;
 812    }
 813    ret = wc_AesSetKey(&defAes, key, 16, iv, AES_DECRYPTION);
 814    if (ret != 0) {
 815        printf("default aes-128 key set failed\n");
 816        return -1;
 817    }
 818
 819    ret = CRYPT_AES_CBC_Decrypt(&mcAes, out2, out1, AES_TEST_SIZE);
 820    if (ret != 0) {
 821        printf("mcapi aes-128 cbc decrypt failed\n");
 822        return -1;
 823    }
 824    wc_AesCbcDecrypt(&defAes, out1, out1, AES_TEST_SIZE);
 825
 826    if (memcmp(out1, out2, AES_TEST_SIZE) != 0) {
 827        printf("mcapi aes-128 cbc decrypt cmp failed\n");
 828        return -1;
 829    }
 830
 831    if (memcmp(out1, ourData, AES_TEST_SIZE) != 0) {
 832        printf("mcapi aes-128 cbc decrypt orig cmp failed\n");
 833        return -1;
 834    }
 835
 836    /* 192 cbc encrypt */
 837    ret = CRYPT_AES_KeySet(&mcAes, key, 24, iv, CRYPT_AES_ENCRYPTION);
 838    if (ret != 0) {
 839        printf("mcapi aes-192 key set failed\n");
 840        return -1;
 841    }
 842    ret = wc_AesSetKey(&defAes, key, 24, iv, AES_ENCRYPTION);
 843    if (ret != 0) {
 844        printf("default aes-192 key set failed\n");
 845        return -1;
 846    }
 847
 848    ret = CRYPT_AES_CBC_Encrypt(&mcAes, out1, ourData, AES_TEST_SIZE);
 849    if (ret != 0) {
 850        printf("mcapi aes-192 cbc encrypt failed\n");
 851        return -1;
 852    }
 853    wc_AesCbcEncrypt(&defAes, out2, ourData, AES_TEST_SIZE);
 854
 855    if (memcmp(out1, out2, AES_TEST_SIZE) != 0) {
 856        printf("mcapi aes-192 cbc encrypt cmp failed\n");
 857        return -1;
 858    }
 859
 860    /* 192 cbc decrypt */
 861    ret = CRYPT_AES_KeySet(&mcAes, key, 24, iv, CRYPT_AES_DECRYPTION);
 862    if (ret != 0) {
 863        printf("mcapi aes-192 key set failed\n");
 864        return -1;
 865    }
 866    ret = wc_AesSetKey(&defAes, key, 24, iv, AES_DECRYPTION);
 867    if (ret != 0) {
 868        printf("default aes-192 key set failed\n");
 869        return -1;
 870    }
 871
 872    ret = CRYPT_AES_CBC_Decrypt(&mcAes, out2, out1, AES_TEST_SIZE);
 873    if (ret != 0) {
 874        printf("mcapi aes-192 cbc decrypt failed\n");
 875        return -1;
 876    }
 877    wc_AesCbcDecrypt(&defAes, out1, out1, AES_TEST_SIZE);
 878
 879    if (memcmp(out1, out2, AES_TEST_SIZE) != 0) {
 880        printf("mcapi aes-192 cbc decrypt cmp failed\n");
 881        return -1;
 882    }
 883
 884    if (memcmp(out1, ourData, AES_TEST_SIZE) != 0) {
 885        printf("mcapi aes-192 cbc decrypt orig cmp failed\n");
 886        return -1;
 887    }
 888
 889    /* 256 cbc encrypt */
 890    ret = CRYPT_AES_KeySet(&mcAes, key, 32, iv, CRYPT_AES_ENCRYPTION);
 891    if (ret != 0) {
 892        printf("mcapi aes-256 key set failed\n");
 893        return -1;
 894    }
 895    ret = wc_AesSetKey(&defAes, key, 32, iv, AES_ENCRYPTION);
 896    if (ret != 0) {
 897        printf("default aes-256 key set failed\n");
 898        return -1;
 899    }
 900
 901    ret = CRYPT_AES_CBC_Encrypt(&mcAes, out1, ourData, AES_TEST_SIZE);
 902    if (ret != 0) {
 903        printf("mcapi aes-256 cbc encrypt failed\n");
 904        return -1;
 905    }
 906    wc_AesCbcEncrypt(&defAes, out2, ourData, AES_TEST_SIZE);
 907
 908    if (memcmp(out1, out2, AES_TEST_SIZE) != 0) {
 909        printf("mcapi aes-256 cbc encrypt cmp failed\n");
 910        return -1;
 911    }
 912
 913    /* 256 cbc decrypt */
 914    ret = CRYPT_AES_KeySet(&mcAes, key, 32, iv, CRYPT_AES_DECRYPTION);
 915    if (ret != 0) {
 916        printf("mcapi aes-256 key set failed\n");
 917        return -1;
 918    }
 919    ret = wc_AesSetKey(&defAes, key, 32, iv, AES_DECRYPTION);
 920    if (ret != 0) {
 921        printf("default aes-256 key set failed\n");
 922        return -1;
 923    }
 924
 925    ret = CRYPT_AES_CBC_Decrypt(&mcAes, out2, out1, AES_TEST_SIZE);
 926    if (ret != 0) {
 927        printf("mcapi aes-256 cbc decrypt failed\n");
 928        return -1;
 929    }
 930    wc_AesCbcDecrypt(&defAes, out1, out1, AES_TEST_SIZE);
 931
 932    if (memcmp(out1, out2, AES_TEST_SIZE) != 0) {
 933        printf("mcapi aes-256 cbc decrypt cmp failed\n");
 934        return -1;
 935    }
 936
 937    if (memcmp(out1, ourData, AES_TEST_SIZE) != 0) {
 938        printf("mcapi aes-256 cbc decrypt orig cmp failed\n");
 939        return -1;
 940    }
 941
 942    printf("aes-cbc     mcapi test passed\n");
 943
 944    return 0;
 945}
 946
 947
 948/* check mcapi aes ctr */
 949static int check_aesctr(void)
 950{
 951    CRYPT_AES_CTX mcAes;
 952    Aes           defAes;
 953    int           ret;
 954    byte          out1[AES_TEST_SIZE];
 955    byte          out2[AES_TEST_SIZE];
 956
 957    memcpy((char*)key, "1234567890abcdefghijklmnopqrstuv", 32);
 958    memcpy((char*)iv,  "1234567890abcdef", 16);
 959
 960    /* 128 ctr encrypt */
 961    ret = CRYPT_AES_KeySet(&mcAes, key, 16, iv, CRYPT_AES_ENCRYPTION);
 962    if (ret != 0) {
 963        printf("mcapi aes-128 key set failed\n");
 964        return -1;
 965    }
 966    ret = wc_AesSetKey(&defAes, key, 16, iv, AES_ENCRYPTION);
 967    if (ret != 0) {
 968        printf("default aes-128 key set failed\n");
 969        return -1;
 970    }
 971
 972    ret = CRYPT_AES_CTR_Encrypt(&mcAes, out1, ourData, AES_TEST_SIZE);
 973    if (ret != 0) {
 974        printf("mcapi aes-128 ctr encrypt failed\n");
 975        return -1;
 976    }
 977    ret = wc_AesCtrEncrypt(&defAes, out2, ourData, AES_TEST_SIZE);
 978    if (ret != 0) {
 979        printf("mcapi aes-128 ctr encrypt set failed\n");
 980        return -1;
 981    }
 982    if (memcmp(out1, out2, AES_TEST_SIZE) != 0) {
 983        printf("mcapi aes-128 ctr encrypt cmp failed\n");
 984        return -1;
 985    }
 986
 987    /* 128 ctr decrypt */
 988    ret = CRYPT_AES_KeySet(&mcAes, key, 16, iv, CRYPT_AES_ENCRYPTION);
 989    if (ret != 0) {
 990        printf("mcapi aes-128 key set failed\n");
 991        return -1;
 992    }
 993    ret = wc_AesSetKey(&defAes, key, 16, iv, AES_ENCRYPTION);
 994    if (ret != 0) {
 995        printf("default aes-128 key set failed\n");
 996        return -1;
 997    }
 998
 999    ret = CRYPT_AES_CTR_Encrypt(&mcAes, out2, out1, AES_TEST_SIZE);
1000    if (ret != 0) {
1001        printf("mcapi aes-128 ctr decrypt failed\n");
1002        return -1;
1003    }
1004
1005    if (memcmp(out2, ourData, AES_TEST_SIZE) != 0) {
1006        printf("mcapi aes-128 ctr decrypt orig cmp failed\n");
1007        return -1;
1008    }
1009
1010    /* 192 ctr encrypt */
1011    ret = CRYPT_AES_KeySet(&mcAes, key, 24, iv, CRYPT_AES_ENCRYPTION);
1012    if (ret != 0) {
1013        printf("mcapi aes-192 key set failed\n");
1014        return -1;
1015    }
1016    ret = wc_AesSetKey(&defAes, key, 24, iv, AES_ENCRYPTION);
1017    if (ret != 0) {
1018        printf("default aes-192 key set failed\n");
1019        return -1;
1020    }
1021
1022    ret = CRYPT_AES_CTR_Encrypt(&mcAes, out1, ourData, AES_TEST_SIZE);
1023    if (ret != 0) {
1024        printf("mcapi aes-192 ctr encrypt failed\n");
1025        return -1;
1026    }
1027    ret = wc_AesCtrEncrypt(&defAes, out2, ourData, AES_TEST_SIZE);
1028    if (ret != 0) {
1029        printf("mcapi aes-192 ctr encrypt set failed\n");
1030        return -1;
1031    }
1032    if (memcmp(out1, out2, AES_TEST_SIZE) != 0) {
1033        printf("mcapi aes-192 ctr encrypt cmp failed\n");
1034        return -1;
1035    }
1036
1037    /* 192 ctr decrypt */
1038    ret = CRYPT_AES_KeySet(&mcAes, key, 24, iv, CRYPT_AES_ENCRYPTION);
1039    if (ret != 0) {
1040        printf("mcapi aes-192 key set failed\n");
1041        return -1;
1042    }
1043    ret = wc_AesSetKey(&defAes, key, 24, iv, AES_DECRYPTION);
1044    if (ret != 0) {
1045        printf("default aes-192 key set failed\n");
1046        return -1;
1047    }
1048
1049    ret = CRYPT_AES_CTR_Encrypt(&mcAes, out2, out1, AES_TEST_SIZE);
1050    if (ret != 0) {
1051        printf("mcapi aes-192 ctr decrypt failed\n");
1052        return -1;
1053    }
1054
1055    if (memcmp(out2, ourData, AES_TEST_SIZE) != 0) {
1056        printf("mcapi aes-192 ctr decrypt orig cmp failed\n");
1057        return -1;
1058    }
1059
1060    /* 256 ctr encrypt */
1061    ret = CRYPT_AES_KeySet(&mcAes, key, 32, iv, CRYPT_AES_ENCRYPTION);
1062    if (ret != 0) {
1063        printf("mcapi aes-256 key set failed\n");
1064        return -1;
1065    }
1066    ret = wc_AesSetKey(&defAes, key, 32, iv, AES_ENCRYPTION);
1067    if (ret != 0) {
1068        printf("default aes-256 key set failed\n");
1069        return -1;
1070    }
1071
1072    ret = CRYPT_AES_CTR_Encrypt(&mcAes, out1, ourData, AES_TEST_SIZE);
1073    if (ret != 0) {
1074        printf("mcapi aes-256 ctr encrypt failed\n");
1075        return -1;
1076    }
1077    ret = wc_AesCtrEncrypt(&defAes, out2, ourData, AES_TEST_SIZE);
1078    if (ret != 0) {
1079        printf("mcapi aes-256 ctr encrypt set failed\n");
1080        return -1;
1081    }
1082    if (memcmp(out1, out2, AES_TEST_SIZE) != 0) {
1083        printf("mcapi aes-256 ctr encrypt cmp failed\n");
1084        return -1;
1085    }
1086
1087    /* 256 ctr decrypt */
1088    ret = CRYPT_AES_KeySet(&mcAes, key, 32, iv, CRYPT_AES_ENCRYPTION);
1089    if (ret != 0) {
1090        printf("mcapi aes-256 key set failed\n");
1091        return -1;
1092    }
1093    ret = wc_AesSetKey(&defAes, key, 32, iv, AES_ENCRYPTION);
1094    if (ret != 0) {
1095        printf("default aes-256 key set failed\n");
1096        return -1;
1097    }
1098
1099    ret = CRYPT_AES_CTR_Encrypt(&mcAes, out2, out1, AES_TEST_SIZE);
1100    if (ret != 0) {
1101        printf("mcapi aes-256 ctr decrypt failed\n");
1102        return -1;
1103    }
1104
1105    if (memcmp(out2, ourData, AES_TEST_SIZE) != 0) {
1106        printf("mcapi aes-256 ctr decrypt orig cmp failed\n");
1107        return -1;
1108    }
1109
1110    printf("aes-ctr     mcapi test passed\n");
1111
1112    return 0;
1113}
1114
1115
1116/* check mcapi aes direct */
1117static int check_aesdirect(void)
1118{
1119    CRYPT_AES_CTX mcAes;
1120    Aes           defAes;
1121    int           ret;
1122    byte          out1[CRYPT_AES_BLOCK_SIZE];
1123    byte          out2[16];  /* one block at a time */
1124
1125    memcpy((char*)key, "1234567890abcdefghijklmnopqrstuv", 32);
1126    memcpy((char*)iv,  "1234567890abcdef", 16);
1127
1128    /* 128 direct encrypt */
1129    ret = CRYPT_AES_KeySet(&mcAes, key, 16, iv, CRYPT_AES_ENCRYPTION);
1130    if (ret != 0) {
1131        printf("mcapi aes-128 key set failed\n");
1132        return -1;
1133    }
1134    ret = wc_AesSetKey(&defAes, key, 16, iv, AES_ENCRYPTION);
1135    if (ret != 0) {
1136        printf("default aes-128 key set failed\n");
1137        return -1;
1138    }
1139
1140    ret = CRYPT_AES_DIRECT_Encrypt(&mcAes, out1, ourData);
1141    if (ret != 0) {
1142        printf("mcapi aes-128 direct encrypt failed\n");
1143        return -1;
1144    }
1145    wc_AesEncryptDirect(&defAes, out2, ourData);
1146
1147    if (memcmp(out1, out2, CRYPT_AES_BLOCK_SIZE) != 0) {
1148        printf("mcapi aes-128 direct encrypt cmp failed\n");
1149        return -1;
1150    }
1151
1152    /* 128 direct decrypt */
1153    ret = CRYPT_AES_KeySet(&mcAes, key, 16, iv, CRYPT_AES_DECRYPTION);
1154    if (ret != 0) {
1155        printf("mcapi aes-128 key set failed\n");
1156        return -1;
1157    }
1158    ret = wc_AesSetKey(&defAes, key, 16, iv, AES_DECRYPTION);
1159    if (ret != 0) {
1160        printf("default aes-128 key set failed\n");
1161        return -1;
1162    }
1163
1164    ret = CRYPT_AES_DIRECT_Decrypt(&mcAes, out2, out1);
1165    if (ret != 0) {
1166        printf("mcapi aes-128 direct decrypt failed\n");
1167        return -1;
1168    }
1169    wc_AesDecryptDirect(&defAes, out1, out1);
1170
1171    if (memcmp(out1, out2, CRYPT_AES_BLOCK_SIZE) != 0) {
1172        printf("mcapi aes-128 direct decrypt cmp failed\n");
1173        return -1;
1174    }
1175
1176    if (memcmp(out1, ourData, CRYPT_AES_BLOCK_SIZE) != 0) {
1177        printf("mcapi aes-128 direct decrypt orig cmp failed\n");
1178        return -1;
1179    }
1180
1181    /* 192 direct encrypt */
1182    ret = CRYPT_AES_KeySet(&mcAes, key, 24, iv, CRYPT_AES_ENCRYPTION);
1183    if (ret != 0) {
1184        printf("mcapi aes-192 key set failed\n");
1185        return -1;
1186    }
1187    ret = wc_AesSetKey(&defAes, key, 24, iv, AES_ENCRYPTION);
1188    if (ret != 0) {
1189        printf("default aes-192 key set failed\n");
1190        return -1;
1191    }
1192
1193    ret = CRYPT_AES_DIRECT_Encrypt(&mcAes, out1, ourData);
1194    if (ret != 0) {
1195        printf("mcapi aes-192 direct encrypt failed\n");
1196        return -1;
1197    }
1198    wc_AesEncryptDirect(&defAes, out2, ourData);
1199
1200    if (memcmp(out1, out2, CRYPT_AES_BLOCK_SIZE) != 0) {
1201        printf("mcapi aes-192 direct encrypt cmp failed\n");
1202        return -1;
1203    }
1204
1205    /* 192 direct decrypt */
1206    ret = CRYPT_AES_KeySet(&mcAes, key, 24, iv, CRYPT_AES_DECRYPTION);
1207    if (ret != 0) {
1208        printf("mcapi aes-192 key set failed\n");
1209        return -1;
1210    }
1211    ret = wc_AesSetKey(&defAes, key, 24, iv, AES_DECRYPTION);
1212    if (ret != 0) {
1213        printf("default aes-192 key set failed\n");
1214        return -1;
1215    }
1216
1217    ret = CRYPT_AES_DIRECT_Decrypt(&mcAes, out2, out1);
1218    if (ret != 0) {
1219        printf("mcapi aes-192 direct decrypt failed\n");
1220        return -1;
1221    }
1222    wc_AesDecryptDirect(&defAes, out1, out1);
1223
1224    if (memcmp(out1, out2, CRYPT_AES_BLOCK_SIZE) != 0) {
1225        printf("mcapi aes-192 direct decrypt cmp failed\n");
1226        return -1;
1227    }
1228
1229    if (memcmp(out1, ourData, CRYPT_AES_BLOCK_SIZE) != 0) {
1230        printf("mcapi aes-192 direct decrypt orig cmp failed\n");
1231        return -1;
1232    }
1233
1234    /* 256 direct encrypt */
1235    ret = CRYPT_AES_KeySet(&mcAes, key, 32, iv, CRYPT_AES_ENCRYPTION);
1236    if (ret != 0) {
1237        printf("mcapi aes-256 key set failed\n");
1238        return -1;
1239    }
1240    ret = wc_AesSetKey(&defAes, key, 32, iv, AES_ENCRYPTION);
1241    if (ret != 0) {
1242        printf("default aes-256 key set failed\n");
1243        return -1;
1244    }
1245
1246    ret = CRYPT_AES_DIRECT_Encrypt(&mcAes, out1, ourData);
1247    if (ret != 0) {
1248        printf("mcapi aes-256 direct encrypt failed\n");
1249        return -1;
1250    }
1251    wc_AesEncryptDirect(&defAes, out2, ourData);
1252
1253    if (memcmp(out1, out2, CRYPT_AES_BLOCK_SIZE) != 0) {
1254        printf("mcapi aes-256 direct encrypt cmp failed\n");
1255        return -1;
1256    }
1257
1258    /* 256 direct decrypt */
1259    ret = CRYPT_AES_KeySet(&mcAes, key, 32, iv, CRYPT_AES_DECRYPTION);
1260    if (ret != 0) {
1261        printf("mcapi aes-256 key set failed\n");
1262        return -1;
1263    }
1264    ret = wc_AesSetKey(&defAes, key, 32, iv, AES_DECRYPTION);
1265    if (ret != 0) {
1266        printf("default aes-256 key set failed\n");
1267        return -1;
1268    }
1269
1270    ret = CRYPT_AES_DIRECT_Decrypt(&mcAes, out2, out1);
1271    if (ret != 0) {
1272        printf("mcapi aes-256 direct decrypt failed\n");
1273        return -1;
1274    }
1275    wc_AesDecryptDirect(&defAes, out1, out1);
1276
1277    if (memcmp(out1, out2, CRYPT_AES_BLOCK_SIZE) != 0) {
1278        printf("mcapi aes-256 direct decrypt cmp failed\n");
1279        return -1;
1280    }
1281
1282    if (memcmp(out1, ourData, CRYPT_AES_BLOCK_SIZE) != 0) {
1283        printf("mcapi aes-256 direct decrypt orig cmp failed\n");
1284        return -1;
1285    }
1286
1287    printf("aes-direct  mcapi test passed\n");
1288
1289    return 0;
1290}
1291
1292
1293#define RSA_TEST_SIZE 64
1294
1295/* check mcapi rsa */
1296static int check_rsa(void)
1297{
1298    CRYPT_RSA_CTX mcRsa;
1299    RsaKey        defRsa;
1300    int           ret;
1301    int           ret2;
1302    unsigned int  keySz = (unsigned int)sizeof(client_key_der_1024);
1303    unsigned int  idx   = 0;
1304    byte          out1[256];
1305    byte          out2[256];
1306
1307    ret = wc_InitRsaKey(&defRsa, NULL);
1308    if (ret == 0)
1309        ret = CRYPT_RSA_Initialize(&mcRsa);
1310    if (ret != 0) {
1311        printf("mcapi rsa init failed\n");
1312        return -1;
1313    }
1314
1315    ret = CRYPT_RSA_PrivateKeyDecode(&mcRsa, client_key_der_1024, keySz);
1316    if (ret != 0) {
1317        printf("mcapi rsa private key decode failed\n");
1318        return -1;
1319    }
1320
1321    ret = wc_RsaPrivateKeyDecode(client_key_der_1024, &idx, &defRsa, keySz);
1322    if (ret != 0) {
1323        printf("default rsa private key decode failed\n");
1324        return -1;
1325    }
1326
1327    ret = CRYPT_RSA_SetRng(&mcRsa, &mcRng);
1328    if (ret != 0) {
1329        printf("mcapi rsa set rng failed\n");
1330        return -1;
1331    }
1332
1333    ret = CRYPT_RSA_PublicEncrypt(&mcRsa, out1, sizeof(out1), ourData,
1334                                  RSA_TEST_SIZE, &mcRng);
1335    if (ret < 0) {
1336        printf("mcapi rsa public encrypt failed\n");
1337        return -1;
1338    }
1339
1340    ret2 = wc_RsaPublicEncrypt(ourData, RSA_TEST_SIZE, out2, sizeof(out2),
1341                            &defRsa, &defRng);
1342    if (ret2 < 0) {
1343        printf("default rsa public encrypt failed\n");
1344        return -1;
1345    }
1346
1347    if (ret != ret2) {
1348        printf("default rsa public encrypt sz != mcapi sz\n");
1349        return -1;
1350    }
1351
1352    if (ret != CRYPT_RSA_EncryptSizeGet(&mcRsa)) {
1353        printf("mcapi encrypt sz get != mcapi sz\n");
1354        return -1;
1355    }
1356
1357    ret = CRYPT_RSA_PrivateDecrypt(&mcRsa, out2, sizeof(out2), out1, ret);
1358    if (ret < 0) {
1359        printf("mcapi rsa private derypt failed\n");
1360        return -1;
1361    }
1362
1363    if (ret != RSA_TEST_SIZE) {
1364        printf("mcapi rsa private derypt plain size wrong\n");
1365        return -1;
1366    }
1367
1368    if (memcmp(out2, ourData, ret) != 0) {
1369        printf("mcapi rsa private derypt plain text bad\n");
1370        return -1;
1371    }
1372
1373    wc_FreeRsaKey(&defRsa);
1374    ret = CRYPT_RSA_Free(&mcRsa);
1375    if (ret != 0) {
1376        printf("mcapi rsa free failed\n");
1377        return -1;
1378    }
1379
1380    printf("rsa         mcapi test passed\n");
1381
1382    return 0;
1383}
1384
1385
1386/* check mcapi ecc */
1387static int check_ecc(void)
1388{
1389    CRYPT_ECC_CTX userA;
1390    CRYPT_ECC_CTX userB;
1391    int           ret;
1392    byte          sharedA[100];
1393    byte          sharedB[100];
1394    byte          sig[100];
1395    unsigned int  aSz   = (unsigned int)sizeof(sharedA);
1396    unsigned int  bSz   = (unsigned int)sizeof(sharedB);
1397    unsigned int  sigSz = (unsigned int)sizeof(sig);
1398    unsigned int  usedA = 0;
1399    unsigned int  usedB = 0;
1400    int verifyStatus = 0;
1401
1402    /* init */
1403    ret = CRYPT_ECC_Initialize(&userA);
1404    if (ret != 0) {
1405        printf("mcapi ecc init failed\n");
1406        return -1;
1407    }
1408
1409    ret = CRYPT_ECC_Initialize(&userB);
1410    if (ret != 0) {
1411        printf("mcapi ecc init b failed\n");
1412        return -1;
1413    }
1414
1415    /* dhe + helpers */
1416    ret = CRYPT_ECC_DHE_KeyMake(&userA, &mcRng, 32);
1417    if (ret != 0) {
1418        printf("mcapi ecc make key failed\n");
1419        return -1;
1420    }
1421
1422    ret = CRYPT_ECC_DHE_KeyMake(&userB, &mcRng, 32);
1423    if (ret != 0) {
1424        printf("mcapi ecc make key b failed\n");
1425        return -1;
1426    }
1427
1428    ret = CRYPT_ECC_KeySizeGet(&userA);
1429    if (ret <= 0) {
1430        printf("mcapi ecc key size get failed\n");
1431        return -1;
1432    }
1433
1434    ret = CRYPT_ECC_SignatureSizeGet(&userA);
1435    if (ret <= 0) {
1436        printf("mcapi ecc signature size get failed\n");
1437        return -1;
1438    }
1439
1440    ret = CRYPT_ECC_DHE_SharedSecretMake(&userA, &userB, sharedA, aSz, &usedA);
1441    if (ret != 0) {
1442        printf("mcapi ecc make shared secret failed\n");
1443        return -1;
1444    }
1445
1446    ret = CRYPT_ECC_DHE_SharedSecretMake(&userB, &userA, sharedB, bSz, &usedB);
1447    if (ret != 0) {
1448        printf("mcapi ecc make shared secret failed\n");
1449        return -1;
1450    }
1451
1452    if (usedA != usedB || usedA == 0) {
1453        printf("mcapi ecc make shared secret output size match failed\n");
1454        return -1;
1455    }
1456
1457    if (memcmp(sharedA, sharedB, usedA) != 0) {
1458        printf("mcapi ecc make shared secret output match cmp failed\n");
1459        return -1;
1460    }
1461
1462    /* dsa */
1463    ret = CRYPT_ECC_DSA_HashSign(&userA, &mcRng, sig, sigSz, &usedA, ourData,
1464                                 CRYPT_SHA_DIGEST_SIZE);
1465    if (ret != 0) {
1466        printf("mcapi ecc sign hash failed\n");
1467        return -1;
1468    }
1469
1470    sigSz = usedA;
1471    if (sigSz == 0) {
1472        printf("mcapi ecc sign hash bad sig size\n");
1473        return -1;
1474    }
1475
1476    ret = CRYPT_ECC_DSA_HashVerify(&userA, sig, sigSz, ourData,
1477                                   CRYPT_SHA_DIGEST_SIZE, &verifyStatus);
1478    if (ret != 0) {
1479        printf("mcapi ecc verify hash failed\n");
1480        return -1;
1481    }
1482    if (verifyStatus != 1) {
1483        printf("mcapi ecc verify hash status failed\n");
1484        return -1;
1485    }
1486
1487    /* import / export */
1488    usedA = 0;
1489    ret = CRYPT_ECC_PublicExport(&userA, sharedA, aSz, &usedA);
1490    if (ret != 0) {
1491        printf("mcapi ecc public export failed\n");
1492        return -1;
1493    }
1494
1495    ret = CRYPT_ECC_PublicImport(&userB, sharedA, usedA);
1496    if (ret != 0) {
1497        printf("mcapi ecc public import failed\n");
1498        return -1;
1499    }
1500
1501    ret = CRYPT_ECC_Free(&userA);
1502    if (ret != 0) {
1503        printf("mcapi ecc free failed\n");
1504        return -1;
1505    }
1506
1507    ret = CRYPT_ECC_Free(&userB);
1508    if (ret != 0) {
1509        printf("mcapi ecc free b failed\n");
1510        return -1;
1511    }
1512
1513    printf("ecc         mcapi test passed\n");
1514
1515    return 0;
1516}
1517