test/SaUnitTest/src/tests/test5_3.c

   1 /*
   2  *
   3  * Copyright (C) 2012-2020 Texas Instruments Incorporated - http://www.ti.com/
   4  *
   5  *
   6  *  Redistribution and use in source and binary forms, with or without
   7  *  modification, are permitted provided that the following conditions
   8  *  are met:
   9  *
  10  *    Redistributions of source code must retain the above copyright
  11  *    notice, this list of conditions and the following disclaimer.
  12  *
  13  *    Redistributions in binary form must reproduce the above copyright
  14  *    notice, this list of conditions and the following disclaimer in the
  15  *    documentation and/or other materials provided with the
  16  *    distribution.
  17  *
  18  *    Neither the name of Texas Instruments Incorporated nor the names of
  19  *    its contributors may be used to endorse or promote products derived
  20  *    from this software without specific prior written permission.
  21  *
  22  *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  23  *  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  24  *  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  25  *  A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  26  *  OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  27  *  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  28  *  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  29  *  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  30  *  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  31  *  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  32  *  OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  33  *
  34 */
  35
  36 #include "../unittest.h"
  37 #include "../salldsim/salldsim.h"
  38 #include "test5_3.h"
  39
  40 /* PKA (Public Key Accelerator) Complex Operation test.
  41  * This test is designed to verify the complex opertions of the Public Key Accelerator
  42  * (PKA) within SASS.
  43  *
  44  * Test Procedures:
  45  *
  46  * - Enable PKA by invoking API Sa_pkaInit()
  47  * - Run through the PKA test vectors of all supported operations by invoking API Sa_pkaOperation2()
  48  * - Close PKA by invoking API Sa_pkaClose()
  49  *
  50  * a0 is a pointer to the test framework structure
  51  * a1 is a pointer to the saTest_t structure for this test, as initialized in testMain.
  52  *
  53  */
  54 #define SA_PKA_MAX_IN_VECTORS     16    /* Maximum number of input arrays */
  55 #define SA_PAK_MAX_OUT_VECTORS     5    /* Maximum number of output arrays */
  56
  57 typedef struct saPkaTestEntry2_s
  58 {
  59     char            opDesc[40];         /* Operation description */
  60     Sa_PkaOpTypes_t operation;      /* PKA operation */
  61     Sa_PkaOpModes_t mode;           /* PKA I/O mode */
  62     uint16_t        aLen;           /* A length */
  63     uint16_t        bLen;           /* B Length */
  64     uint32_t        numOddPowers;   /* Number of pre-calculated odd powers to use */
  65     int             statusCode;     /* Expected status code of opertaion */
  66     uint32_t*       pIn[SA_PKA_MAX_IN_VECTORS];    /* Pointers to the input arrays */
  67     uint32_t*       pOut[SA_PAK_MAX_OUT_VECTORS];  /* Pointers to the output arrays */
  68 } saPkaTestEntry2_t;
  69
  70 static uint32_t  pkaOutput[SA_PAK_MAX_OUT_VECTORS][sa_MAX_PKA_OPERAND_SIZE];  /* actual output */
  71
  72 static saPkaTestEntry2_t  saPkaTestEntry[] =
  73 {
  74
  75     /* test entry 1 */
  76     {
  77         "ModExp 4096bits",         /* Operation description */
  78         sa_PKA_OP_MODEXP,          /* PKA operation */
  79         sa_PKA_MODE_WAIT,          /* PKA I/O mode */
  80         1,                         /* A length */
  81         128,                       /* B Length*/
  82         2,                         /* Number of pre-calculated odd powers to use */
  83         sa_PKA_OP_STATUS_SUCCESS,  /* Expected status code of opertaion */
  84         {                          /*  Pointers to the input arrays */
  85             pka_modExp_n4096,
  86             pka_modExp_e4096,
  87             pka_modExp_m4096,
  88             0
  89
  90         },
  91         {                          /* Pointers to the output arrays */
  92             pka_modExp_r4096,
  93             0,
  94
  95         }
  96     },
  97
  98     /* test entry 2 */
  99     {
 100         "ModExpCRT 4096bits",      /* Operation description */
 101         sa_PKA_OP_MODEXP_CRT,      /* PKA operation */
 102         sa_PKA_MODE_WAIT,          /* PKA I/O mode */
 103         64,                        /* A length */
 104         64,                       /* B Length*/
 105         1,                         /* Number of pre-calculated odd powers to use */
 106         sa_PKA_OP_STATUS_SUCCESS,  /* Expected status code of opertaion */
 107         {                          /*  Pointers to the input arrays */
 108             pka_modExpCRT_p4096,
 109             pka_modExpCRT_q4096,
 110             pka_modExpCRT_Dp4096,
 111             pka_modExpCRT_Dq4096,
 112             pka_modExpCRT_qInv4096,
 113             pka_modExpCRT_m4096,
 114             0
 115
 116         },
 117         {                          /* Pointers to the output arrays */
 118             pka_modExpCRT_r4096,
 119             0,
 120
 121         }
 122     },
 123
 124     /* test entry 3 */
 125     {
 126         "ModInv_p P_521",          /* Operation description */
 127         sa_PKA_OP_MODINVp,         /* PKA operation */
 128         sa_PKA_MODE_WAIT,          /* PKA I/O mode */
 129         17,                        /* A length */
 130         17,                       /* B Length*/
 131         0,                         /* Number of pre-calculated odd powers to use */
 132         sa_PKA_OP_STATUS_SUCCESS,  /* Expected status code of opertaion */
 133         {                          /*  Pointers to the input arrays */
 134             pka_modINVp_n521,
 135             pka_modINVp_z521,
 136             0
 137
 138         },
 139         {                          /* Pointers to the output arrays */
 140             pka_modINVp_r521,
 141             0,
 142         }
 143     },
 144
 145     /* test entry 4 */
 146     {
 147         "ModInv_2m curve B_571",   /* Operation description */
 148         sa_PKA_OP_MODINV2m,        /* PKA operation */
 149         sa_PKA_MODE_WAIT,          /* PKA I/O mode */
 150         18,                        /* A length */
 151         18,                       /* B Length*/
 152         0,                         /* Number of pre-calculated odd powers to use */
 153         sa_PKA_OP_STATUS_SUCCESS,  /* Expected status code of opertaion */
 154         {                          /*  Pointers to the input arrays */
 155             pka_modINV2m_p571,
 156             pka_modINV2m_z571,
 157             0
 158
 159         },
 160         {                          /* Pointers to the output arrays */
 161             pka_modINV2m_r571,
 162             0,
 163         }
 164     },
 165
 166     /* test entry 5 */
 167     {
 168         "ECpADDxyz curve P_521",    /* Operation description */
 169         sa_PKA_OP_ECp_ADD,          /* PKA operation */
 170         sa_PKA_MODE_WAIT,           /* PKA I/O mode */
 171         17,                         /* A length */
 172         17,                         /* B Length*/
 173         0,                          /* Number of pre-calculated odd powers to use */
 174         sa_PKA_OP_STATUS_SUCCESS,   /* Expected status code of opertaion */
 175         {                           /*  Pointers to the input arrays */
 176             pka_ecAddp_p521,
 177             pka_ecAddp_a521,
 178             pka_ecAddp_b521,
 179             pka_ecAddp_p1x521,
 180             pka_ecAddp_p1y521,
 181             pka_ecAddp_p1z521,
 182             pka_ecAddp_p2x521,
 183             pka_ecAddp_p2y521,
 184             pka_ecAddp_p2z521,
 185             0
 186
 187         },
 188         {                          /* Pointers to the output arrays */
 189             pka_ecAddp_p0x521,
 190             pka_ecAddp_p0y521,
 191             pka_ecAddp_p0z521,
 192             0,
 193         }
 194     },
 195
 196     /* test entry 6 */
 197     {
 198         "EC2mADDxyz curve B_571",   /* Operation description */
 199         sa_PKA_OP_EC2m_ADD,         /* PKA operation */
 200         sa_PKA_MODE_WAIT,           /* PKA I/O mode */
 201         18,                         /* A length */
 202         18,                         /* B Length*/
 203         0,                          /* Number of pre-calculated odd powers to use */
 204         sa_PKA_OP_STATUS_SUCCESS,   /* Expected status code of opertaion */
 205         {                           /*  Pointers to the input arrays */
 206             pka_ecAdd2m_p571,
 207             pka_ecAdd2m_a571,
 208             pka_ecAdd2m_b571,
 209             pka_ecAdd2m_p1x571,
 210             pka_ecAdd2m_p1y571,
 211             pka_ecAdd2m_p1z571,
 212             pka_ecAdd2m_p2x571,
 213             pka_ecAdd2m_p2y571,
 214             pka_ecAdd2m_p2z571,
 215             0
 216
 217         },
 218         {                          /* Pointers to the output arrays */
 219             pka_ecAdd2m_p0x571,
 220             pka_ecAdd2m_p0y571,
 221             pka_ecAdd2m_p0z571,
 222             0,
 223         }
 224     },
 225
 226     /* test entry 7 */
 227     {
 228         "ECpMULxyz curve SEC_P_224_R1",    /* Operation description */
 229         sa_PKA_OP_ECp_MUL,          /* PKA operation */
 230         sa_PKA_MODE_WAIT,           /* PKA I/O mode */
 231         1,                          /* A length */
 232         7,                          /* B Length*/
 233         0,                          /* Number of pre-calculated odd powers to use */
 234         sa_PKA_OP_STATUS_SUCCESS,   /* Expected status code of opertaion */
 235         {                           /*  Pointers to the input arrays */
 236             pka_ecMulp_p224,
 237             pka_ecMulp_a224,
 238             pka_ecMulp_b224,
 239             pka_ecMulp_k224,
 240             pka_ecMulp_p1x224,
 241             pka_ecMulp_p1y224,
 242             pka_ecMulp_p1z224,
 243             0
 244
 245         },
 246         {                          /* Pointers to the output arrays */
 247             pka_ecMulp_p0x224,
 248             pka_ecMulp_p0y224,
 249             pka_ecMulp_p0z224,
 250             0,
 251         }
 252     },
 253
 254     /* test entry 8 */
 255     {
 256         "EC2mMULxyz curve B_409",   /* Operation description */
 257         sa_PKA_OP_EC2m_MUL,         /* PKA operation */
 258         sa_PKA_MODE_WAIT,           /* PKA I/O mode */
 259         13,                          /* A length */
 260         13,                          /* B Length*/
 261         0,                          /* Number of pre-calculated odd powers to use */
 262         sa_PKA_OP_STATUS_SUCCESS,   /* Expected status code of opertaion */
 263         {                           /*  Pointers to the input arrays */
 264             pka_ecMul2m_p409,
 265             pka_ecMul2m_a409,
 266             pka_ecMul2m_c409,
 267             pka_ecMul2m_k409,
 268             pka_ecMul2m_p1x409,
 269             pka_ecMul2m_p1y409,
 270             pka_ecMul2m_p1z409,
 271             0
 272
 273         },
 274         {                          /* Pointers to the output arrays */
 275             pka_ecMul2m_p0x409,
 276             pka_ecMul2m_p0y409,
 277             pka_ecMul2m_p0z409,
 278             0,
 279         }
 280     },
 281
 282     /* test entry 9 */
 283     {
 284         "ECpMUL_SCALExyz curve NIST_P_384",  /* Operation description */
 285         sa_PKA_OP_ECp_MUL_SACLE,    /* PKA operation */
 286         sa_PKA_MODE_WAIT,           /* PKA I/O mode */
 287         1,                          /* A length */
 288         12,                         /* B Length*/
 289         0,                          /* Number of pre-calculated odd powers to use */
 290         sa_PKA_OP_STATUS_SUCCESS,   /* Expected status code of opertaion */
 291         {                           /*  Pointers to the input arrays */
 292             pka_ecMulSp_p384,
 293             pka_ecMulSp_a384,
 294             pka_ecMulSp_b384,
 295             pka_ecMulSp_k384,
 296             pka_ecMulSp_p1x384,
 297             pka_ecMulSp_p1y384,
 298             pka_ecMulSp_p1z384,
 299             0
 300
 301         },
 302         {                          /* Pointers to the output arrays */
 303             pka_ecMulSp_p0x384,
 304             pka_ecMulSp_p0y384,
 305             pka_ecMulSp_p0z384,
 306             0,
 307         }
 308     },
 309
 310     /* test entry 10 */
 311     {
 312         "EC2mMUL_SCALExyz curve K571",  /* Operation description */
 313         sa_PKA_OP_EC2m_MUL_SACLE,   /* PKA operation */
 314         sa_PKA_MODE_WAIT,           /* PKA I/O mode */
 315         1,                          /* A length */
 316         18,                         /* B Length*/
 317         0,                          /* Number of pre-calculated odd powers to use */
 318         sa_PKA_OP_STATUS_SUCCESS,   /* Expected status code of opertaion */
 319         {                           /*  Pointers to the input arrays */
 320             pka_ecMulS2m_p571,
 321             pka_ecMulS2m_a571,
 322             pka_ecMulS2m_c571,
 323             pka_ecMulS2m_k571,
 324             pka_ecMulS2m_p1x571,
 325             pka_ecMulS2m_p1y571,
 326             pka_ecMulS2m_p1z571,
 327             0
 328
 329         },
 330         {                          /* Pointers to the output arrays */
 331             pka_ecMulS2m_p0x571,
 332             pka_ecMulS2m_p0y571,
 333             pka_ecMulS2m_p0z571,
 334             0,
 335         }
 336     },
 337
 338     /* test entry 11 */
 339     {
 340         "ECDSAp Sign curve P521",   /* Operation description */
 341         sa_PKA_OP_ECp_DSA_SIGN,     /* PKA operation */
 342         sa_PKA_MODE_WAIT,           /* PKA I/O mode */
 343         17,                         /* A length */
 344         17,                         /* B Length*/
 345         0,                          /* Number of pre-calculated odd powers to use */
 346         sa_PKA_OP_STATUS_SUCCESS,   /* Expected status code of opertaion */
 347         {                           /*  Pointers to the input arrays */
 348             pka_ecdsap_sign_p521,
 349             pka_ecdsap_sign_a521,
 350             pka_ecdsap_sign_b521,
 351             pka_ecdsap_sign_k521,
 352             pka_ecdsap_sign_p1x521,
 353             pka_ecdsap_sign_p1y521,
 354             pka_ecdsap_sign_p1z521,
 355             pka_ecdsap_sign_n521,
 356             pka_ecdsap_sign_h521,
 357             pka_ecdsap_sign_d521,
 358             0
 359
 360         },
 361         {                          /* Pointers to the output arrays */
 362             pka_ecdsap_sign_r521,
 363             pka_ecdsap_sign_s521,
 364             0,
 365         }
 366     },
 367
 368     /* test entry 12 */
 369     {
 370         "ECDSAp Verify curve P160", /* Operation description */
 371         sa_PKA_OP_ECp_DSA_VERIFY,   /* PKA operation */
 372         sa_PKA_MODE_WAIT,           /* PKA I/O mode */
 373         5,                          /* A length */
 374         5,                          /* B Length*/
 375         0,                          /* Number of pre-calculated odd powers to use */
 376         sa_PKA_OP_STATUS_SUCCESS,   /* Expected status code of opertaion */
 377         {                           /*  Pointers to the input arrays */
 378             pka_ecdsap_verify_p160,
 379             pka_ecdsap_verify_a160,
 380             pka_ecdsap_verify_b160,
 381             pka_ecdsap_verify_p1x160,
 382             pka_ecdsap_verify_p1y160,
 383             pka_ecdsap_verify_p1z160,
 384             pka_ecdsap_verify_n160,
 385             pka_ecdsap_verify_h160,
 386             pka_ecdsap_verify_yx160,
 387             pka_ecdsap_verify_yy160,
 388             pka_ecdsap_verify_yz160,
 389             pka_ecdsap_verify_r160,
 390             pka_ecdsap_verify_s160,
 391             0
 392         },
 393         {                          /* Pointers to the output arrays */
 394             pka_ecdsap_verify_res160,
 395             0,
 396         }
 397     }
 398
 399 };
 400
 401 /*******************************************************************************
 402  *  Function: Construct the PKA Operation Request Information
 403  *******************************************************************************
 404  *  DESCRIPTION: Construct the PKA operation request information
 405  *  (Sa_PkaReqInfo2_t) from the test entry
 406  *
 407  ******************************************************************************/
 408 void saConvPkaInputs(saPkaTestEntry2_t *pPkaEntry, Sa_PkaReqInfo2_t *pPkaReq)
 409 {
 410     memset(pPkaReq, 0, sizeof(Sa_PkaReqInfo2_t));
 411
 412     /* Construct the common portion of PKA request structure */
 413     pPkaReq->operation = pPkaEntry->operation;
 414     pPkaReq->mode = pPkaEntry->mode;
 415     pPkaReq->aLen = pPkaEntry->aLen;
 416     pPkaReq->bLen = pPkaEntry->bLen;
 417
 418     /* Construct the operation-specific parameters */
 419     switch (pPkaReq->operation)
 420     {
 421         case sa_PKA_OP_MODEXP:
 422             {
 423                 Sa_PkaModExpParams_t *pPkaOp = &pPkaReq->params.modExp;
 424
 425                 pPkaOp->numOddPowers =  pPkaEntry->numOddPowers;
 426                 pPkaOp->pN           =  pPkaEntry->pIn[0];
 427                 pPkaOp->pE           =  pPkaEntry->pIn[1];
 428                 pPkaOp->pM           =  pPkaEntry->pIn[2];
 429                 pPkaOp->pResult       =  pkaOutput[0];
 430             }
 431             break;
 432
 433         case sa_PKA_OP_MODEXP_CRT:
 434             {
 435                 Sa_PkaModExpCRTParams_t *pPkaOp = &pPkaReq->params.modExpCRT;
 436
 437                 pPkaOp->numOddPowers =  pPkaEntry->numOddPowers;
 438                 pPkaOp->pModP        =  pPkaEntry->pIn[0];
 439                 pPkaOp->pModQ        =  pPkaEntry->pIn[1];
 440                 pPkaOp->pDp          =  pPkaEntry->pIn[2];
 441                 pPkaOp->pDq          =  pPkaEntry->pIn[3];
 442                 pPkaOp->pQInv        =  pPkaEntry->pIn[4];
 443                 pPkaOp->pM           =  pPkaEntry->pIn[5];
 444                 pPkaOp->pResult       =  pkaOutput[0];
 445             }
 446             break;
 447
 448         case sa_PKA_OP_MODINVp:
 449         case sa_PKA_OP_MODINV2m:
 450             {
 451                 Sa_PkaModInvParams_t *pPkaOp = &pPkaReq->params.modInv;
 452
 453                 pPkaOp->pN           =  pPkaEntry->pIn[0];
 454                 pPkaOp->pZ           =  pPkaEntry->pIn[1];
 455                 pPkaOp->pResult       =  pkaOutput[0];
 456             }
 457             break;
 458
 459         case sa_PKA_OP_ECp_ADD:
 460         case sa_PKA_OP_EC2m_ADD:
 461             {
 462                 Sa_PkaECAddParams_t *pPkaOp = &pPkaReq->params.ecAdd;
 463
 464                 pPkaOp->pModP        =  pPkaEntry->pIn[0];
 465                 pPkaOp->pEcA         =  pPkaEntry->pIn[1];
 466                 pPkaOp->pEcB         =  pPkaEntry->pIn[2];
 467                 pPkaOp->point1.pX    =  pPkaEntry->pIn[3];
 468                 pPkaOp->point1.pY    =  pPkaEntry->pIn[4];
 469                 pPkaOp->point1.pZ    =  pPkaEntry->pIn[5];
 470                 pPkaOp->point2.pX    =  pPkaEntry->pIn[6];
 471                 pPkaOp->point2.pY    =  pPkaEntry->pIn[7];
 472                 pPkaOp->point2.pZ    =  pPkaEntry->pIn[8];
 473                 pPkaOp->point0.pX    =  pkaOutput[0];
 474                 pPkaOp->point0.pY    =  pkaOutput[1];
 475                 pPkaOp->point0.pZ    =  pkaOutput[2];
 476             }
 477             break;
 478
 479         case sa_PKA_OP_ECp_MUL:
 480         case sa_PKA_OP_EC2m_MUL:
 481         case sa_PKA_OP_ECp_MUL_SACLE:
 482         case sa_PKA_OP_EC2m_MUL_SACLE:
 483
 484             {
 485                 Sa_PkaECMulParams_t *pPkaOp = &pPkaReq->params.ecMul;
 486
 487                 pPkaOp->pModP        =  pPkaEntry->pIn[0];
 488                 pPkaOp->pEcA         =  pPkaEntry->pIn[1];
 489                 pPkaOp->pEcBC        =  pPkaEntry->pIn[2];
 490                 pPkaOp->pK           =  pPkaEntry->pIn[3];
 491                 pPkaOp->point1.pX    =  pPkaEntry->pIn[4];
 492                 pPkaOp->point1.pY    =  pPkaEntry->pIn[5];
 493                 pPkaOp->point1.pZ    =  pPkaEntry->pIn[6];
 494                 pPkaOp->point0.pX    =  pkaOutput[0];
 495                 pPkaOp->point0.pY    =  pkaOutput[1];
 496                 pPkaOp->point0.pZ    =  pkaOutput[2];
 497             }
 498             break;
 499
 500         case sa_PKA_OP_ECp_SCALE:
 501         case sa_PKA_OP_EC2m_SCALE:
 502             {
 503                 Sa_PkaECScaleParams_t *pPkaOp = &pPkaReq->params.ecScale;
 504
 505                 pPkaOp->pModP        =  pPkaEntry->pIn[0];
 506                 pPkaOp->pEcA         =  pPkaEntry->pIn[1];
 507                 pPkaOp->pEcB         =  pPkaEntry->pIn[2];
 508                 pPkaOp->point1.pX    =  pPkaEntry->pIn[3];
 509                 pPkaOp->point1.pY    =  pPkaEntry->pIn[4];
 510                 pPkaOp->point1.pZ    =  pPkaEntry->pIn[5];
 511                 pPkaOp->point0.pX    =  pkaOutput[0];
 512                 pPkaOp->point0.pY    =  pkaOutput[1];
 513                 pPkaOp->point0.pZ    =  pkaOutput[2];
 514             }
 515             break;
 516
 517         case sa_PKA_OP_ECp_DSA_SIGN:
 518             {
 519                 Sa_PkaECDSASignParams_t *pPkaOp = &pPkaReq->params.ecDSASign;
 520
 521                 pPkaOp->pModP        =  pPkaEntry->pIn[0];
 522                 pPkaOp->pEcA         =  pPkaEntry->pIn[1];
 523                 pPkaOp->pEcBC        =  pPkaEntry->pIn[2];
 524                 pPkaOp->pK           =  pPkaEntry->pIn[3];
 525                 pPkaOp->point1.pX    =  pPkaEntry->pIn[4];
 526                 pPkaOp->point1.pY    =  pPkaEntry->pIn[5];
 527                 pPkaOp->point1.pZ    =  pPkaEntry->pIn[6];
 528                 pPkaOp->pN           =  pPkaEntry->pIn[7];
 529                 pPkaOp->pH           =  pPkaEntry->pIn[8];
 530                 pPkaOp->pD           =  pPkaEntry->pIn[9];
 531                 pPkaOp->pR           =  pkaOutput[0];
 532                 pPkaOp->pS           =  pkaOutput[1];
 533             }
 534             break;
 535
 536         case sa_PKA_OP_ECp_DSA_VERIFY:
 537             {
 538                 Sa_PkaECDSAVerifyParams_t *pPkaOp = &pPkaReq->params.ecDSAVerify;
 539
 540                 pPkaOp->pModP        =  pPkaEntry->pIn[0];
 541                 pPkaOp->pEcA         =  pPkaEntry->pIn[1];
 542                 pPkaOp->pEcBC        =  pPkaEntry->pIn[2];
 543                 pPkaOp->point1.pX    =  pPkaEntry->pIn[3];
 544                 pPkaOp->point1.pY    =  pPkaEntry->pIn[4];
 545                 pPkaOp->point1.pZ    =  pPkaEntry->pIn[5];
 546                 pPkaOp->pN           =  pPkaEntry->pIn[6];
 547                 pPkaOp->pH           =  pPkaEntry->pIn[7];
 548                 pPkaOp->pY.pX        =  pPkaEntry->pIn[8];
 549                 pPkaOp->pY.pY        =  pPkaEntry->pIn[9];
 550                 pPkaOp->pY.pZ        =  pPkaEntry->pIn[10];
 551                 pPkaOp->pR           =  pPkaEntry->pIn[11];
 552                 pPkaOp->pS           =  pPkaEntry->pIn[12];
 553                 pPkaOp->pRes         =  pkaOutput[0];
 554             }
 555             break;
 556
 557         default:
 558             break;
 559
 560     }
 561 }
 562
 563 /*******************************************************************************
 564  *  Function: Verify PKA Operation Results
 565  *******************************************************************************
 566  *  DESCRIPTION: Compare PKA operation results against expected values
 567  *
 568  *  Return: 0 : Test outputs match expected values
 569  *          -1: Test outputs does not match
 570  ******************************************************************************/
 571 int32_t saVerifyPkaResults(saPkaTestEntry2_t *pPkaEntry, Sa_PkaReqInfo2_t *pPkaReq)
 572 {
 573     /* Verify operation-specific results */
 574     switch (pPkaReq->operation)
 575     {
 576         case sa_PKA_OP_MODEXP:
 577         case sa_PKA_OP_MODINVp:
 578         case sa_PKA_OP_MODINV2m:
 579             {
 580                 if (memcmp(pPkaEntry->pOut[0], pkaOutput[0], pPkaReq->bLen*4))
 581                 {
 582                     return (-1);
 583                 }
 584             }
 585             break;
 586
 587         case sa_PKA_OP_MODEXP_CRT:
 588             {
 589                 if (memcmp(pPkaEntry->pOut[0], pkaOutput[0], pPkaReq->bLen*8))
 590                 {
 591                     return (-1);
 592                 }
 593             }
 594             break;
 595
 596         case sa_PKA_OP_ECp_ADD:
 597         case sa_PKA_OP_EC2m_ADD:
 598         case sa_PKA_OP_ECp_MUL:
 599         case sa_PKA_OP_EC2m_MUL:
 600         case sa_PKA_OP_ECp_MUL_SACLE:
 601         case sa_PKA_OP_EC2m_MUL_SACLE:
 602             {
 603                 if (memcmp(pPkaEntry->pOut[0], pkaOutput[0], pPkaReq->bLen*4) ||
 604                     memcmp(pPkaEntry->pOut[1], pkaOutput[1], pPkaReq->bLen*4) ||
 605                     memcmp(pPkaEntry->pOut[2], pkaOutput[2], pPkaReq->bLen*4))
 606                 {
 607                     return (-1);
 608                 }
 609             }
 610             break;
 611
 612         case sa_PKA_OP_ECp_DSA_SIGN:
 613             {
 614                 if (memcmp(pPkaEntry->pOut[0], pkaOutput[0], pPkaReq->bLen*4) ||
 615                     memcmp(pPkaEntry->pOut[1], pkaOutput[1], pPkaReq->bLen*4))
 616                 {
 617                     return (-1);
 618                 }
 619             }
 620             break;
 621
 622         case sa_PKA_OP_ECp_DSA_VERIFY:
 623             {
 624               if (memcmp(pPkaEntry->pOut[0], pkaOutput[0], 4))
 625               {
 626                    return (-1);
 627               }
 628             }
 629             break;
 630
 631         default:
 632             return (-1);
 633     }
 634
 635     return (0);
 636 }
 637
 638 /*******************************************************************************
 639  *  Function: PKA Test Program #2
 640  *******************************************************************************
 641  *  DESCRIPTION: Perform vector-based tests of PKA complex operations
 642  *
 643  ******************************************************************************/
 644 void saPkaTest2 (UArg a0, UArg a1)
 645 {
 646         tFramework_t  *tf  = (tFramework_t *)(uintptr_t)a0;
 647         saTest_t      *pat = (saTest_t *)(uintptr_t)a1;
 648         saPkaTestEntry2_t *pPkaEntry;
 649     Sa_PkaReqInfo2_t   pkaReq;
 650         int  i;
 651     int16_t retCode;
 652     uint32_t           opStartTime;
 653     uint32_t           opDuration;
 654
 655     /* Enable Error logging */
 656     salld_sim_disp_control(TRUE);
 657
 658     /* Initialize the PKA module to be ready for large number arithmetic */
 659     retCode = Sa_pkaInit(tf->salld_handle);
 660
 661     if (retCode != sa_ERR_OK)
 662     {
 663         salld_sim_print("saPkaTest2: Sa_pkaInit() returns error code = %d!\n", retCode);
 664         salld_sim_disp_control(FALSE);
 665
 666         saTestRecoverAndExit (tf, pat, SA_TEST_FAILED);  /* no return */
 667     }
 668
 669     /* Wait for the Module to be ready */
 670         utilCycleDelay (1000);
 671
 672     /* PKA Test */
 673     for (i = 0; i < sizeof(saPkaTestEntry)/sizeof(saPkaTestEntry2_t); i++)
 674     {
 675         pPkaEntry = &saPkaTestEntry[i];
 676         /* Prepare the PKA request Info */
 677         saConvPkaInputs(pPkaEntry, &pkaReq);
 678
 679         opStartTime = TimerP_getTimeInUsecs();
 680
 681         retCode = Sa_pkaOperation2(tf->salld_handle, &pkaReq);
 682
 683         opDuration = TimerP_getTimeInUsecs() - opStartTime;
 684
 685         salld_sim_print("saPkaTest2: Test %d (%s) takes %d micro seconds!\n", i, pPkaEntry->opDesc, opDuration);
 686
 687         if (retCode != sa_ERR_OK)
 688         {
 689             salld_sim_print("saPkaTest2: Sa_pkaOperation2() returns error code = %d!\n", retCode);
 690             salld_sim_disp_control(FALSE);
 691
 692             saTestRecoverAndExit (tf, pat, SA_TEST_FAILED);  /* no return */
 693         }
 694
 695         /* Check operation results */
 696         if (pkaReq.statusCode != pPkaEntry->statusCode)
 697         {
 698             salld_sim_print("saPkaTest2: test %d fails! statusCode (%d) is not expected, should be (%d)\n",
 699                              i, pkaReq.statusCode, pPkaEntry->statusCode);
 700         }
 701
 702         if (saVerifyPkaResults(pPkaEntry, &pkaReq))
 703         {
 704             salld_sim_print("saPkaTest2: test %d fails! output data mismatches\n", i);
 705             salld_sim_disp_control(FALSE);
 706                 saTestRecoverAndExit (tf, pat, SA_TEST_FAILED);  /* no return */
 707         }
 708     }
 709
 710     /* Close the PKA module */
 711     retCode = Sa_pkaClose(tf->salld_handle);
 712
 713     if (retCode != sa_ERR_OK)
 714     {
 715         salld_sim_print("saPkaTest2: Sa_pkaClose() returns error code = %d!\n", retCode);
 716         salld_sim_disp_control(FALSE);
 717
 718         saTestRecoverAndExit (tf, pat, SA_TEST_FAILED);  /* no return */
 719     }
 720
 721     salld_sim_print("saPkaTest2: %d tests complete successfully!\n", sizeof(saPkaTestEntry)/sizeof(saPkaTestEntry2_t));
 722     salld_sim_disp_control(FALSE);
 723
 724         saTestRecoverAndExit (tf, pat, SA_TEST_PASSED);  /* no return */
 725 }
 726
 727
 728
 729
 730
 731
 732
 733