git.sur5r.net Git - freertos/blob - FreeRTOS-Plus/Source/CyaSSL/mcapi/mcapi_test.c

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