git.sur5r.net Git - freertos/blob - FreeRTOS/Demo/T-HEAD_CB2201_CDK/csi/csi_driver/csky/common/rsa/ck_rsa.c

   1 /*
   2  * Copyright (C) 2017 C-SKY Microsystems Co., Ltd. All rights reserved.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *   http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 /******************************************************************************
  18  * @file     ck_rsa.c
  19  * @brief    CSI Source File for RSA Driver
  20  * @version  V1.0
  21  * @date     02. June 2017
  22  ******************************************************************************/
  23 #include <stdio.h>
  24 #include <string.h>
  25 #include "drv_rsa.h"
  26 #include "ck_rsa.h"
  27 #include "irq.h"
  28
  29 #define ERR_RSA(errno) (CSI_DRV_ERRNO_RSA_BASE | errno)
  30 #define RSA_NULL_PARAM_CHK(para)                         \
  31     do {                                        \
  32         if (para == NULL) {                     \
  33             return ERR_RSA(EDRV_PARAMETER);   \
  34         }                                       \
  35     } while (0)
  36
  37
  38 typedef struct {
  39     uint32_t base;
  40     uint32_t irq;
  41     rsa_event_cb_t cb;
  42     rsa_data_bits_e data_bit;
  43     rsa_endian_mode_e endian;
  44     rsa_padding_t padding;
  45     rsa_status_t status;
  46 } ck_rsa_priv_t;
  47
  48 extern int32_t target_get_rsa_count(void);
  49 extern int32_t target_get_rsa(int32_t idx, uint32_t *base, uint32_t *irq);
  50
  51 static ck_rsa_priv_t rsa_handle[CONFIG_RSA_NUM];
  52
  53 extern uint8_t modulus[];
  54 static ck_rsa_reg_t *rsa_reg = NULL;
  55 /* Driver Capabilities */
  56 static const rsa_capabilities_t driver_capabilities = {
  57     .bits_192 = 1, /* 192bits modular mode */
  58     .bits_256 = 1, /* 256bits modular mode */
  59     .bits_512 = 1, /* 512bits modular mode */
  60     .bits_1024 = 1, /* 1024bits modular mode */
  61     .bits_2048 = 1  /* 2048bits modular mode */
  62 };
  63
  64 extern int32_t target_get_rsa(int32_t idx, uint32_t *base, uint32_t *irq);
  65 extern int32_t target_get_rsa_count(void);
  66 //
  67 // Functions
  68 //
  69
  70 static uint32_t sw_exptmod_2_2m(const uint32_t *modulus, uint32_t words, uint32_t *tmp_c);
  71 static uint32_t get_valid_bits(const uint32_t *addr, uint32_t wordsize, uint32_t keywords);
  72
  73 #ifdef RSA_USING_ID2KEY
  74 static uint32_t g_acc[RSA_KEY_WORD];
  75 #endif
  76
  77 static inline void rsa_clear_int(void)
  78 {
  79     rsa_reg->rsa_isr = 0xffff;
  80     rsa_reg->rsa_imr = 0x0000;
  81 }
  82
  83 static inline void rsa_setm_width(uint32_t width)
  84 {
  85     rsa_reg->rsa_mwid = width;
  86 }
  87
  88 static inline void rsa_setd_width(uint32_t width)
  89 {
  90     rsa_reg->rsa_ckid = width;
  91 }
  92
  93 static inline void rsa_setb_width(uint32_t width)
  94 {
  95     rsa_reg->rsa_bwid = width;
  96 }
  97
  98 static inline void rsa_cal_q(void)
  99 {
 100     rsa_reg->rsa_ctrl = RAS_CALCULATE_Q;
 101 }
 102
 103 static inline void rsa_opr_start(void)
 104 {
 105     rsa_reg->rsa_ctrl = RSA_ENABLE_MODULE;
 106 }
 107
 108 static inline void rsa_opr_reset(void)
 109 {
 110     rsa_reg->rsa_ctrl = RSA_ENDIAN_MODE;
 111     rsa_reg->rsa_rst |= RSA_RESET;
 112
 113     while (rsa_reg->rsa_rst);
 114 }
 115
 116 static inline uint32_t rsa_loop_cnt(void)
 117 {
 118     return rsa_reg->rsa_lp_cnt;
 119 }
 120
 121 static inline uint32_t rsa_cal_q_done(void)
 122 {
 123     return (rsa_reg->rsa_isr >> RSA_CAL_Q_DONE_OFFSET) & 0x1;
 124 }
 125
 126 static inline uint32_t rsa_opr_done(void)
 127 {
 128     return (rsa_reg->rsa_isr) & 0x1;
 129 }
 130
 131 static inline uint32_t rsa_raise_exception(void)
 132 {
 133     return (rsa_reg->rsa_isr) & 0x1E;
 134 }
 135
 136 static inline uint32_t rsa_loadm(uint32_t *data, uint32_t length)
 137 {
 138     uint32_t i;
 139     uint32_t baseaddr = (uint32_t)&rsa_reg->rsa_rfm;
 140
 141     for (i = 0; i < length; i++) {
 142         *(volatile uint32_t *)baseaddr = data[i];
 143         baseaddr = baseaddr + 4;
 144     }
 145
 146     return 0;
 147 }
 148
 149 static void rsa_loadd(uint32_t *data, uint32_t length)
 150 {
 151     uint32_t i;
 152     uint32_t baseaddr = (uint32_t)&rsa_reg->rsa_rfd;
 153
 154     for (i = 0;  i < length; i++) {
 155         *(volatile uint32_t *)baseaddr = data[i];
 156         baseaddr = baseaddr + 4;
 157     }
 158 }
 159
 160 static void rsa_loadc(uint32_t *data, uint32_t length)
 161 {
 162     uint32_t i;
 163     uint32_t baseaddr = (uint32_t)&rsa_reg->rsa_rfc;
 164
 165     for (i = 1; i < length + 1; i++) {
 166         *(volatile uint32_t *)baseaddr = data[i - 1];
 167         baseaddr = baseaddr + 4;
 168     }
 169 }
 170
 171 static void rsa_loadb(uint32_t *data, uint32_t length)
 172 {
 173     uint32_t i;
 174     uint32_t baseaddr = (uint32_t)&rsa_reg->rsa_rfb;
 175
 176     for (i = 0; i < length; i++) {
 177         *(volatile uint32_t *)baseaddr = data[i];
 178         baseaddr = baseaddr + 4;
 179     }
 180 }
 181
 182 static void rsa_read_r(uint32_t data[], uint32_t length)
 183 {
 184     uint32_t i;
 185     uint32_t baseaddr = (uint32_t)&rsa_reg->rsa_rfr;
 186
 187     for (i = 0; i < length; i++) {
 188         data[i] = *(uint32_t *)baseaddr;
 189         baseaddr = baseaddr + 4;
 190     }
 191 }
 192
 193 #if (CONFIG_PLATFORM_HOBBIT1_2 > 0)
 194 // FIXME
 195 // Since there is a piece of memory hole in RSA engine. we should
 196 // jump the hold to continue run without disable interrupt
 197 #define RSA_SP_HOLE_DOWN    0x60000900
 198 #define RSA_SP_HOLE_UP      0x600009FF
 199 #define TEE_CONEXT_SIZE     128
 200 static uint32_t rsa_run_adjust_sp_if_need(uint32_t sp)
 201 {
 202     uint32_t sp_chg;
 203
 204     // if current sp is in hole, adjust new sp
 205     if ((sp < (RSA_SP_HOLE_UP + TEE_CONEXT_SIZE)) && (sp > RSA_SP_HOLE_DOWN))
 206         sp_chg = 1;
 207     else
 208         sp_chg = 0;
 209
 210     return sp_chg;
 211 }
 212
 213 static void rsa_run_by_assemble(void)
 214 {
 215     __asm__ __volatile__ (
 216                 "subi   sp, 0x10   \n"
 217                 "stm    r4-r7, (sp) \n"
 218
 219                 // update sp
 220                 "mov    r4, sp  \n"
 221                 "subi   r4, 0x180  \n"
 222                 "mov    sp, r4 \n"
 223
 224                 // enable rsa engine
 225                 "lrw    r5, 0x4000a00c \n"
 226                 "movi   r6, 3 \n"
 227                 "stw    r6, (r5) \n"
 228                 // check rsa end
 229                 "__chk_loop:    \n"
 230                 "lrw    r5, 0x4000a020 \n"
 231                 "ldw    r6, (r5) \n"
 232                 "btsti  r6, 0 \n"
 233                 "bt     __chk_end \n"
 234
 235                 "lrw    r5, 0x4000a020 \n"
 236                 "ldw    r6, (r5) \n"
 237                 "movi   r7, 0x1e \n"
 238                 "and    r6, r7 \n"
 239                 "cmpnei  r6, 0 \n"
 240                 "bf     __chk_loop  \n"
 241
 242                 "lrw    r5, 0x4000a014 \n"
 243                 "ldw    r6, (r5) \n"
 244                 "cmplti r6, 0x40  \n"
 245                 "bt     __chk_loop  \n"
 246
 247                 "__chk_end: \n"
 248
 249                 // update sp
 250                 "mov    r4, sp  \n"
 251                 "addi   r4, 0x180  \n"
 252                 "mov    sp, r4 \n"
 253
 254                 "ldm    r4-r7, (sp) \n"
 255                 "addi   sp, 0x10   \n"
 256             );
 257 }
 258 #endif
 259
 260 static uint32_t rsa_exptmod(const uint32_t *modulus, const uint32_t *exponent,
 261                             const uint32_t *base, uint32_t *out, uint32_t keywords,
 262                             uint32_t *tmp_c)
 263 {
 264     uint32_t ret = 0;
 265     if ((NULL == exponent) || (NULL == base) || (NULL == out)) {
 266         return 1;
 267     }
 268
 269 #ifdef RSA_USING_ID2KEY
 270     memcpy(tmp_c, g_acc, sizeof(g_acc));
 271 #endif
 272
 273     /* reset for safe */
 274     rsa_opr_reset();
 275     /* clear and disable int */
 276     rsa_clear_int();
 277     /* set m */
 278     rsa_setm_width(keywords >> 1);
 279     rsa_loadm((uint32_t *)modulus, keywords);
 280     /* set d */
 281     rsa_setd_width(get_valid_bits(exponent, keywords, keywords) - 1);
 282     rsa_loadd((uint32_t *)exponent, keywords);
 283     /* set b */
 284     rsa_setb_width(keywords >> 1);
 285     rsa_loadb((uint32_t *)base, keywords);
 286     /* set c */
 287 #ifndef RSA_USING_ID2KEY
 288     rsa_loadc(tmp_c, keywords);
 289 #else
 290     rsa_loadc(g_acc, keywords);
 291 #endif
 292
 293     rsa_cal_q();
 294
 295     while (!rsa_cal_q_done() && (!rsa_raise_exception()));
 296
 297     if (!rsa_raise_exception()) {
 298 #if (CONFIG_PLATFORM_HOBBIT1_2 > 0)
 299         ///////////////// FIXME ////////////////////////
 300         if (rsa_run_adjust_sp_if_need(get_old_sp())) {
 301             rsa_run_by_assemble();
 302         } else {
 303 #endif
 304             rsa_opr_start();
 305             while ((!rsa_opr_done()) && (rsa_loop_cnt() < MAX_RSA_LP_CNT) && (!rsa_raise_exception()));
 306 #if (CONFIG_PLATFORM_HOBBIT1_2 > 0)
 307         }
 308 #endif
 309         if ((rsa_loop_cnt() >= MAX_RSA_LP_CNT)
 310             || rsa_raise_exception()) {
 311             ret = 1;
 312         } else {
 313             rsa_read_r(out, keywords);
 314         }
 315     } else {
 316         ret = 1;
 317     }
 318
 319     rsa_opr_reset();
 320
 321     return ret;
 322
 323 }
 324
 325 static uint32_t get_valid_bits(const uint32_t *addr, uint32_t wordsize, uint32_t keywords)
 326 {
 327     uint32_t i = 0;
 328     uint32_t j = 0;
 329
 330     for (i = wordsize; i > 0; i--) {
 331         if (addr[i - 1]) {
 332             break;
 333         }
 334     }
 335
 336     for (j = keywords; j > 0; j--) {
 337         if (addr[i - 1] & (0x1 << (j - 1))) {
 338             break;
 339         }
 340     }
 341
 342     return ((i - 1) << 5) + j;
 343 }
 344
 345 static uint32_t get_first_nonzero_words(uint32_t *a, uint32_t max_words)
 346 {
 347     uint32_t i = 0;
 348
 349     for (i = max_words; i > 0; i--) {
 350         if (a[i - 1]) {
 351             return i;
 352         }
 353     }
 354
 355     return 0;
 356 }
 357
 358 static uint32_t word_array_left_shift(uint32_t *a, uint32_t words,
 359                                       uint32_t shift_bits, uint32_t *r)
 360 {
 361     uint32_t i = 0;
 362     uint32_t w = shift_bits >> 5;
 363     uint32_t b = shift_bits - (w << 5);
 364
 365     for (i = 0; i < w; i++) {
 366         r[i] = 0;
 367     }
 368
 369     uint32_t tmp = 0;
 370
 371     for (i = 0; i < words; i++) {
 372         r[w + i] = (tmp | ((a[i] << b) & (~((0x1 << b) - 1))));
 373         tmp = ((a[i] >> (32 - b)) & ((0x1 << b) - 1));
 374     }
 375
 376     r[w + i] = tmp;
 377
 378     return 0;
 379 }
 380
 381 /* r = a - b */
 382 static uint32_t _word_array_sub(uint32_t *a, uint32_t a_words,
 383                                 uint32_t *b, uint32_t b_words,
 384                                 uint32_t *r)
 385 {
 386     uint32_t i;
 387     uint64_t tmp = 0;
 388     uint32_t borrow = 0;
 389
 390     for (i = 0; i < b_words; i++) {
 391         tmp = UINT32_TO_UINT64(a[i]) - UINT32_TO_UINT64(b[i]) - UINT32_TO_UINT64(borrow);
 392         r[i] = UINT64L_TO_UINT32(tmp);
 393         borrow = ((UINT64H_TO_UINT32(tmp) == 0) ? (0) : (0xffffffff - UINT64H_TO_UINT32(tmp) + 1));
 394     }
 395
 396     for (i = b_words; i < a_words; i++) {
 397         tmp = UINT32_TO_UINT64(a[i]) - UINT32_TO_UINT64(borrow);
 398         r[i] = UINT64L_TO_UINT32(tmp);
 399         borrow = ((UINT64H_TO_UINT32(tmp) == 0) ? (0) : (0xffffffff - UINT64H_TO_UINT32(tmp) + 1));
 400     }
 401
 402     if (borrow) {
 403         return -1;
 404     }
 405
 406     return 0;
 407 }
 408
 409 static uint32_t word_array_mod(uint32_t *a, uint32_t a_words,
 410                                uint32_t *b, uint32_t b_words,
 411                                uint32_t *r, uint32_t keywords)
 412 {
 413     uint32_t ret;
 414     bignum_t tmpa;
 415     bignum_t tmpb;
 416
 417     memset(&tmpa, 0, sizeof(tmpa));
 418     memset(&tmpb, 0, sizeof(tmpa));
 419
 420     uint32_t b_valid_bits = get_valid_bits(b, b_words, keywords);
 421
 422     memcpy(tmpa.pdata, a, (a_words << 2));
 423
 424     do {
 425         uint32_t tmpa_words = get_first_nonzero_words(tmpa.pdata, a_words);
 426         uint32_t tmpa_valid_bits = get_valid_bits(tmpa.pdata, tmpa_words, keywords);
 427
 428         if (tmpa_valid_bits > b_valid_bits + 1) {
 429             memset(tmpb.pdata, 0, (a_words << 2));
 430             word_array_left_shift(b, b_words, tmpa_valid_bits - b_valid_bits - 1,
 431                                   tmpb.pdata);
 432             uint32_t tmpb_words = get_first_nonzero_words(tmpb.pdata, a_words);
 433             ret = _word_array_sub(tmpa.pdata, tmpa_words, tmpb.pdata, tmpb_words, tmpa.pdata);
 434         } else if (tmpa_words == b_words) {
 435             memcpy(r, tmpa.pdata, (tmpa_words << 2));
 436             ret = _word_array_sub(r, tmpa_words, b, b_words, tmpa.pdata);
 437         } else {
 438             ret = _word_array_sub(tmpa.pdata, tmpa_words, b, b_words, tmpa.pdata);
 439         }
 440     } while (ret == 0);
 441
 442     return 0;
 443 }
 444
 445 static uint32_t sw_exptmod_2_2m(const uint32_t *modulus, uint32_t words, uint32_t *tmp_c)
 446 {
 447     bignum_t tmp;
 448
 449     memset(&tmp, 0, sizeof(bignum_t));
 450
 451     uint32_t m_valid_bits = (words << 5);
 452
 453     uint32_t data1 = 0x1;
 454     word_array_left_shift(&data1, 1, (m_valid_bits << 1), tmp.pdata);
 455     tmp.words = get_first_nonzero_words(tmp.pdata, words * 2 + 1);
 456
 457     uint32_t ret = word_array_mod(tmp.pdata, tmp.words,
 458                                   (uint32_t *)modulus, words, tmp_c, words);
 459
 460     if (ret != 0) {
 461         return ret;
 462     }
 463
 464     return 0;
 465 }
 466
 467 static void convert_byte_array(uint8_t *in, uint8_t *out, uint32_t len)
 468 {
 469     uint32_t idx, round = len >> 1;
 470
 471     for (idx = 0; idx < round; idx++) {
 472         uint8_t tmp = *(in + idx);
 473         *(out + idx) = *(in + len - 1 - idx);
 474         *(out + len - 1 - idx) = tmp;
 475     }
 476
 477     if (len & 0x1) {
 478         *(out + round) = *(in + round);
 479     }
 480 }
 481
 482 static void convert_buf_to_bndata(const uint8_t *src, uint32_t src_bytes,
 483                                   uint32_t *dst, uint32_t dst_words)
 484 {
 485     memset(dst, 0, dst_words << 2);
 486     convert_byte_array((uint8_t *)src, (uint8_t *)dst, src_bytes);
 487 }
 488
 489 static void convert_bndata_to_buf(const uint32_t *src, uint32_t src_words,
 490                                   uint8_t *dst, uint32_t dst_bytes)
 491 {
 492     memset(dst, 0, dst_bytes);
 493     convert_byte_array((uint8_t *)src, (uint8_t *)dst, dst_bytes);
 494 }
 495
 496 static const uint8_t der_sha256_t[] = {
 497     0x30, 0x31,
 498     0x30, 0x0d,
 499     0x06, 0x09, 0x60, 0x86, 0x48, 0x01, 0x65, 0x03, 0x04, 0x02, 0x01, /* id-sha256 */
 500     0x05, 0x00,
 501     0x04, 0x20
 502 };
 503
 504 static const uint8_t der_sha1_t[] = {
 505     0x30, 0x21,
 506     0x30, 0x09,
 507     0x06, 0x05, 0x2b, 0x0e, 0x03, 0x02, 0x1a,
 508     0x05, 0x00,
 509     0x04, 0x14
 510 };
 511
 512 static const uint8_t der_md5_t[] = {
 513     0x30, 0x20, /* type Sequence, length 0x20 (32) */
 514     0x30, 0x0c, /* type Sequence, length 0x09 */
 515     0x06, 0x08, /* type OID, length 0x05 */
 516     0x2a, 0x86, 0x48, 0x86, 0xF7, 0x0D, 0x02, 0x05, /* id-md5 */
 517     0x05, 0x00, /* NULL */
 518     0x04, 0x10  /* Octet string, length 0x10 (16), followed by md5 hash */
 519 };
 520
 521 static uint32_t rsa_padding_pkcs(uint8_t  *dgst,
 522                                  uint8_t  *out,
 523                                  uint32_t  type,
 524                                  uint32_t  keybytes)
 525
 526 {
 527     uint32_t i;
 528     uint8_t *p;
 529     uint8_t *der;
 530     uint32_t der_len;
 531     uint32_t hashlen;
 532     uint32_t pslen;
 533
 534     if (type == MD5_PADDING) {
 535         der     = (uint8_t *)der_md5_t;
 536         der_len = sizeof(der_md5_t);
 537         hashlen = MD5_HASH_SZ;
 538     } else if (type == SHA256_PADDING) {
 539         der     = (uint8_t *)der_sha256_t;
 540         der_len = sizeof(der_sha256_t);
 541         hashlen = SHA256_HASH_SZ;
 542     } else {
 543         der     = (uint8_t *)der_sha1_t;
 544         der_len = sizeof(der_sha1_t);
 545         hashlen = SHA1_HASH_SZ;
 546     }
 547
 548     p = (uint8_t *)out;
 549
 550     *(p++) = 0x00;
 551     *(p++) = 0x01;
 552
 553     /* pad out with 0xff data */
 554     pslen = keybytes - 3 - der_len - hashlen;
 555
 556     for (i = 0; i < pslen; i++) {
 557         p[i] = 0xff; /* PS */
 558     }
 559
 560     p += pslen;
 561     *(p++) = 0x0;
 562
 563     for (i = 0; i < der_len; i++) {
 564         p[i] = der[i];
 565     }
 566
 567     p += der_len;
 568
 569     for (i = 0; i < hashlen; i++) {
 570         p[i] = dgst[i];
 571     }
 572
 573     return 0;
 574 }
 575
 576 static uint32_t rsa_checking_pkcs(uint8_t *dgst,
 577                                   uint8_t *in,
 578                                   uint32_t inlen,
 579                                   uint8_t *is_valid,
 580                                   uint32_t type,
 581                                   uint32_t keybytes)
 582 {
 583     uint32_t i;
 584     uint32_t ret;
 585     const uint8_t *p;
 586     uint8_t *der = NULL;
 587     uint32_t der_len = 0;
 588     uint32_t hashlen = 0;
 589     uint32_t pslen;
 590
 591     if (type == MD5_PADDING) {
 592         der     = (uint8_t *)der_md5_t;
 593         der_len = sizeof(der_md5_t);
 594         hashlen = MD5_HASH_SZ;
 595     } else if (type == SHA1_PADDING) {
 596         der     = (uint8_t *)der_sha1_t;
 597         der_len = sizeof(der_sha1_t);
 598         hashlen = SHA1_HASH_SZ;
 599     } else if (type == SHA256_PADDING) {
 600         der     = (uint8_t *)der_sha256_t;
 601         der_len = sizeof(der_sha256_t);
 602         hashlen = SHA256_HASH_SZ;
 603     }
 604
 605     *is_valid = 0;
 606
 607     pslen = keybytes - 3 - der_len - hashlen;
 608     p = in;
 609     p++;
 610
 611     if (*(p) != 0x01) {
 612         ret = -1;
 613         goto _verify_fail;
 614     }
 615
 616     p++;
 617
 618     /* scan PS */
 619     for (i = 0; i < pslen; i++) {
 620         if (*(p + i) != 0xff) {
 621             ret = -2;
 622             goto _verify_fail;
 623         }
 624     }
 625
 626     p += pslen;
 627
 628     if ((*p) != 0x00) {
 629         ret = -1;
 630         goto _verify_fail;
 631     }
 632
 633     p++;
 634
 635     /* scan t */
 636     for (i = 0; i < der_len; i++) {
 637         if (*(p + i) != der[i]) {
 638             ret = -3;
 639             goto _verify_fail;
 640         }
 641     }
 642
 643     p += der_len;
 644
 645     for (i = 0; i < hashlen; i++) {
 646         if (*(p + i) != dgst[i]) {
 647             ret = -4;
 648             goto _verify_fail;
 649         }
 650     }
 651
 652     *is_valid = 1;
 653     ret = 0;
 654
 655 _verify_fail:
 656
 657     return ret;
 658 }
 659
 660 static uint32_t rsa_padding_es_pkcs(uint8_t *dgst,
 661                                     uint32_t dgstlen,
 662                                     uint8_t *out,
 663                                     uint32_t padding,
 664                                     uint32_t keybytes)
 665
 666 {
 667     uint32_t i;
 668     uint8_t *p;
 669     uint32_t pslen;
 670
 671     p = (uint8_t *)out;
 672
 673     *(p++) = 0x00;
 674     *(p++) = 0x02;
 675
 676     /* pad out with 0xff data */
 677     pslen = keybytes - 3 - dgstlen;
 678
 679     for (i = 0; i < pslen; i++) {
 680         p[i] = 0xff; /* PS */
 681     }
 682
 683     p += pslen;
 684     *(p++) = 0x0;
 685
 686     for (i = 0; i < dgstlen; i++) {
 687         p[i] = dgst[i];
 688     }
 689
 690     return 0;
 691 }
 692
 693 static uint32_t rsa_checking_es_pkcs(uint8_t *out,
 694                                      uint32_t *out_size,
 695                                      uint8_t *src,
 696                                      uint32_t src_size,
 697                                      uint32_t padding,
 698                                      uint32_t keybytes)
 699 {
 700     uint32_t i;
 701     uint8_t *p;
 702     uint8_t *p_src;
 703     uint32_t pslen;
 704
 705     p = (uint8_t *)src;
 706     p_src = p;
 707     *(p++) = 0x00;
 708
 709     if (padding == PKCS1_PADDING) {
 710         if (*(p++) != 0x02) {
 711             return -1;
 712         }
 713     } else {
 714         if (*(p++) != 0x01) {
 715             return -2;
 716         }
 717     }
 718
 719     pslen = src_size - 2;
 720
 721     while (pslen--) {
 722         if (*(p++) == 0x0) {
 723             break;
 724         }
 725     }
 726
 727     if (padding == PKCS1_PADDING) {
 728         *out_size = pslen;
 729     } else {
 730         *out_size = keybytes;
 731     }
 732
 733     for (i = 0; i < *out_size; i++) {
 734         if (padding == PKCS1_PADDING) {
 735             out[i] = p[i];
 736         } else {
 737             out[i] = p_src[i];
 738         }
 739     }
 740
 741     return 0;
 742 }
 743
 744 int rsa_encrypt(uint8_t *n,         uint8_t *e,
 745                 uint8_t *src,       uint32_t src_size,
 746                 uint8_t *out,       uint32_t *out_size,
 747                 uint32_t padding,   uint32_t keybits_len,
 748                 uint32_t *tmp_c)
 749 {
 750     uint32_t ret;
 751     uint32_t tmp_n[RSA_KEY_WORD];
 752     uint32_t tmp_e[RSA_KEY_WORD];
 753     uint32_t tmp_in_out[RSA_KEY_WORD];
 754     uint32_t keywords = 0, keybytes = 0;
 755
 756     keywords = GET_KEY_WORD(keybits_len);
 757     keybytes = GET_KEY_BYTE(keybits_len);
 758
 759     convert_buf_to_bndata(n, keybytes, tmp_n, keywords);
 760     convert_buf_to_bndata(e, keybytes, tmp_e, keywords);
 761
 762     if (padding == PKCS1_PADDING) {
 763         ret = rsa_padding_es_pkcs(src,
 764                                   src_size,
 765                                   (uint8_t *)tmp_in_out,
 766                                   padding,
 767                                   keybytes);
 768
 769         if (ret != 0) {
 770             return ret;
 771         }
 772
 773         convert_byte_array((uint8_t *)tmp_in_out, (uint8_t *)tmp_in_out, keybytes);
 774     } else {
 775         convert_byte_array((uint8_t *)src, (uint8_t *)tmp_in_out, keybytes);
 776     }
 777
 778     ret = rsa_exptmod(tmp_n, tmp_e, tmp_in_out, tmp_in_out, keywords, tmp_c);
 779
 780     if (ret != 0) {
 781         return ret;
 782     }
 783
 784     convert_bndata_to_buf(tmp_in_out, keywords, out, keybytes);
 785     *out_size = keybytes;
 786     return ret;
 787 }
 788
 789 int rsa_decrypt(uint8_t *n,         uint8_t *d,
 790                 uint8_t *src,       uint32_t src_size,
 791                 uint8_t *out,       uint32_t *out_size,
 792                 uint32_t padding,   uint32_t keybits_len,
 793                 uint32_t *tmp_c)
 794 {
 795     uint32_t ret;
 796     uint32_t tmp_n[RSA_KEY_WORD];
 797     uint32_t tmp_d[RSA_KEY_WORD];
 798     uint32_t tmp_in_out[RSA_KEY_WORD];
 799     uint32_t keywords = 0, keybytes = 0;
 800
 801     keywords = GET_KEY_WORD(keybits_len);
 802     keybytes = GET_KEY_BYTE(keybits_len);
 803
 804     convert_buf_to_bndata(n, keybytes, tmp_n, keywords);
 805     convert_buf_to_bndata(d, keybytes, tmp_d, keywords);
 806     convert_buf_to_bndata(src, src_size, tmp_in_out, keywords);
 807
 808     ret = rsa_exptmod(tmp_n, tmp_d, tmp_in_out, tmp_in_out, keywords, tmp_c);
 809
 810     if (ret != 0) {
 811         return ret;
 812     }
 813
 814     convert_byte_array((uint8_t *)tmp_in_out, (uint8_t *)tmp_in_out, keybytes);
 815
 816     ret = rsa_checking_es_pkcs(out,
 817                                out_size,
 818                                (uint8_t *)tmp_in_out,
 819                                keybytes,
 820                                padding,
 821                                keybytes);
 822
 823     return ret;
 824 }
 825
 826 int rsa_sign(uint8_t *n,        uint8_t *d,
 827              uint8_t *src,      uint32_t src_size,
 828              uint8_t *signature, uint32_t *sig_size,
 829              uint32_t type,     uint32_t keybits_len,
 830              uint32_t *tmp_c)
 831 {
 832     uint32_t ret;
 833     uint32_t tmp_n[RSA_KEY_WORD];
 834     uint32_t tmp_d[RSA_KEY_WORD];
 835     uint32_t tmp_in_out[RSA_KEY_WORD];
 836
 837     uint32_t keywords = 0, keybytes = 0;
 838
 839     keywords = GET_KEY_WORD(keybits_len);
 840     keybytes = GET_KEY_BYTE(keybits_len);
 841
 842     convert_buf_to_bndata(n, keybytes, tmp_n, keywords);
 843     convert_buf_to_bndata(d, keybytes, tmp_d, keywords);
 844
 845     ret = rsa_padding_pkcs(src,
 846                            (uint8_t *)tmp_in_out,
 847                            type,
 848                            keybytes);
 849
 850     if (ret != 0) {
 851         return ret;
 852     }
 853
 854     convert_byte_array((uint8_t *)tmp_in_out, (uint8_t *)tmp_in_out, keybytes);
 855
 856     ret = rsa_exptmod(tmp_n, tmp_d, tmp_in_out, tmp_in_out, keywords, tmp_c);
 857
 858     if (ret != 0) {
 859         return ret;
 860     }
 861
 862     convert_bndata_to_buf(tmp_in_out, keywords, signature, keybytes);
 863     *sig_size = keybytes;
 864
 865     return 0;
 866 }
 867
 868 int rsa_verify(uint8_t *n,          uint8_t *e,
 869                uint8_t *src,        uint32_t src_size,
 870                uint8_t *signature,  uint32_t sig_size,
 871                uint32_t type,       uint32_t keybits_len,
 872                uint8_t *result,     uint32_t *tmp_c)
 873 {
 874     uint32_t ret;
 875     uint32_t tmp_n[RSA_KEY_WORD];
 876     uint32_t tmp_e[RSA_KEY_WORD];
 877     uint32_t tmp_in_out[RSA_KEY_WORD];
 878     uint32_t keywords = 0, keybytes = 0;
 879
 880     *result = 0;
 881
 882     keywords = GET_KEY_WORD(keybits_len);
 883     keybytes = GET_KEY_BYTE(keybits_len);
 884
 885     convert_buf_to_bndata(n, keybytes, tmp_n, keywords);
 886     convert_buf_to_bndata(e, keybytes, tmp_e, keywords);
 887     convert_buf_to_bndata(signature, sig_size, tmp_in_out, keywords);
 888
 889     ret = rsa_exptmod(tmp_n, tmp_e, tmp_in_out, tmp_in_out, keywords, tmp_c);
 890
 891     if (ret != 0) {
 892         return ret;
 893     }
 894
 895     convert_byte_array((uint8_t *)tmp_in_out, (uint8_t *)tmp_in_out, keybytes);
 896
 897     ret = rsa_checking_pkcs(src,
 898                             (uint8_t *)tmp_in_out,
 899                             keybytes,
 900                             result,
 901                             type,
 902                             keybytes);
 903
 904     return ret;
 905 }
 906
 907 static int rsa_sw_exptmod_2_2m(uint8_t *modulus, uint32_t keybits_len, uint32_t *tmp_c)
 908 {
 909     uint32_t keywords = 0, keybytes = 0;
 910     uint32_t tmp_n[RSA_KEY_WORD];
 911
 912     keywords = GET_KEY_WORD(keybits_len);
 913     keybytes = GET_KEY_BYTE(keybits_len);
 914
 915     convert_buf_to_bndata(modulus, keybytes, tmp_n, keywords);
 916
 917     sw_exptmod_2_2m(tmp_n, keywords, tmp_c);
 918     return 0;
 919 }
 920
 921 int rsa_sw_calc_modulus(uint8_t *modulus, uint32_t keybits_len)
 922 {
 923 #ifdef RSA_USING_ID2KEY
 924     static uint32_t current_keybits_len;
 925
 926     if (current_keybits_len != keybits_len) {
 927         rsa_sw_exptmod_2_2m((uint8_t *)modulus, keybits_len, g_acc);
 928         current_keybits_len = keybits_len;
 929     }
 930
 931 #endif
 932     return 0;
 933 }
 934
 935 /**
 936   \brief       get rsa handle count.
 937   \return      rsa handle count
 938 */
 939 int32_t csi_rsa_get_instance_count(void)
 940 {
 941     return target_get_rsa_count();
 942 }
 943
 944 /**
 945   \brief       Initialize RSA Interface. 1. Initializes the resources needed for the RSA interface 2.registers event callback function
 946   \param[in]   idx  must not exceed return value of csi_rsa_get_instance_count()
 947   \param[in]   cb_event  Pointer to \ref rsa_event_cb_t
 948   \return      pointer to rsa handle
 949 */
 950 rsa_handle_t csi_rsa_initialize(int32_t idx, rsa_event_cb_t cb_event)
 951 {
 952     if (idx < 0 || idx >= CONFIG_RSA_NUM) {
 953         return NULL;
 954     }
 955
 956     /* obtain the rsa information */
 957     uint32_t base = 0u;
 958     uint32_t irq;
 959     int32_t real_idx = target_get_rsa(idx, &base, &irq);
 960
 961     if (real_idx != idx) {
 962         return NULL;
 963     }
 964
 965     ck_rsa_priv_t *rsa_priv = &rsa_handle[idx];
 966
 967     rsa_priv->base = base;
 968     rsa_priv->irq  = irq;
 969
 970     /* initialize the rsa context */
 971     rsa_priv->cb = cb_event;
 972     rsa_priv->data_bit = RSA_DATA_BITS_1024;
 973     rsa_priv->endian = RSA_ENDIAN_MODE_LITTLE;
 974     rsa_priv->padding.padding_type = RSA_PADDING_MODE_PKCS1;
 975     rsa_priv->padding.hash_type = RSA_HASH_TYPE_SHA1;
 976     rsa_priv->status.busy = 0;
 977
 978 #ifdef RSA_USING_ID2KEY
 979     memset(g_acc, 0x0, sizeof(g_acc));
 980 #endif
 981
 982     return (rsa_handle_t)rsa_priv;
 983 }
 984
 985 /**
 986   \brief       De-initialize RSA Interface. stops operation and releases the software resources used by the interface
 987   \param[in]   handle  rsa handle to operate.
 988   \return      error code
 989 */
 990 int32_t csi_rsa_uninitialize(rsa_handle_t handle)
 991 {
 992     RSA_NULL_PARAM_CHK(handle);
 993
 994     ck_rsa_priv_t *rsa_priv = handle;
 995     rsa_priv->cb = NULL;
 996
 997     return 0;
 998 }
 999
1000 /**
1001   \brief       Get driver capabilities.
1002   \param[in]   handle rsa handle to operate.
1003   \return      \ref rsa_capabilities_t
1004 */
1005 rsa_capabilities_t csi_rsa_get_capabilities(rsa_handle_t handle)
1006 {
1007     return driver_capabilities;
1008 }
1009
1010 /**
1011   \brief       config rsa mode.
1012   \param[in]   handle  rsa handle to operate.
1013   \param[in]   data_bits \ref rsa_data_bits_e
1014   \param[in]   endian    \ref rsa_endian_mode_e
1015   \return      error code
1016 */
1017 int32_t csi_rsa_config(rsa_handle_t handle,
1018                        rsa_data_bits_e data_bits,
1019                        rsa_endian_mode_e endian,
1020                        void *arg
1021                       )
1022 {
1023     RSA_NULL_PARAM_CHK(handle);
1024
1025     ck_rsa_priv_t *rsa_priv = handle;
1026     rsa_reg = (ck_rsa_reg_t *)(rsa_priv->base);
1027
1028     /* config the data bits */
1029     switch (data_bits) {
1030         case RSA_DATA_BITS_192:
1031         case RSA_DATA_BITS_256:
1032         case RSA_DATA_BITS_512:
1033             return ERR_RSA(EDRV_UNSUPPORTED);
1034
1035         case RSA_DATA_BITS_1024:
1036         case RSA_DATA_BITS_2048:
1037             rsa_priv->data_bit = data_bits;
1038             break;
1039
1040         default:
1041             return ERR_RSA(EDRV_PARAMETER);
1042     }
1043
1044     /* config the endian mode */
1045     if (endian == RSA_ENDIAN_MODE_LITTLE) {
1046         rsa_priv->endian = endian;
1047     } else if (endian == RSA_ENDIAN_MODE_BIG) {
1048         return ERR_RSA(EDRV_UNSUPPORTED);
1049     } else {
1050         return ERR_RSA(EDRV_PARAMETER);
1051     }
1052
1053     if (arg != NULL) {
1054 #ifdef RSA_USING_ID2KEY
1055         uint32_t keybits_len = 1024;
1056
1057         if (data_bits == RSA_DATA_BITS_2048) {
1058             keybits_len = 2048;
1059         }
1060
1061         rsa_sw_calc_modulus(arg, keybits_len);
1062 #else
1063         //memcpy(g_acc, arg, sizeof(g_acc));
1064 #endif
1065     }
1066
1067     return 0;
1068 }
1069
1070 /**
1071   \brief       encrypt
1072   \param[in]   handle  rsa handle to operate.
1073   \param[in]   n         Pointer to the public modulus
1074   \param[in]   e         Pointer to the public exponent
1075   \param[in]   src       Pointer to the source data.
1076   \param[in]   src_size  the source data len
1077   \param[out]  out       Pointer to the result buffer
1078   \param[out]  out_size  the result size
1079   \param[in]   padding   \ref  rsa_padding_t
1080   \return      error code
1081 */
1082 int32_t csi_rsa_encrypt(rsa_handle_t handle, void *n, void *e, void *src, int32_t src_size, void *out, uint32_t *out_size, rsa_padding_t padding)
1083 {
1084 #ifndef RSA_USING_ID2KEY
1085     uint32_t tmp_c[RSA_KEY_WORD];
1086 #endif
1087     RSA_NULL_PARAM_CHK(handle);
1088     RSA_NULL_PARAM_CHK(n);
1089     RSA_NULL_PARAM_CHK(e);
1090     RSA_NULL_PARAM_CHK(src);
1091     RSA_NULL_PARAM_CHK(out);
1092     RSA_NULL_PARAM_CHK(out_size);
1093
1094     if (src_size <= 0 || (padding.padding_type != RSA_PADDING_MODE_PKCS1 && padding.padding_type != RSA_PADDING_MODE_NO)) {
1095         return ERR_RSA(EDRV_PARAMETER);
1096     }
1097
1098     ck_rsa_priv_t *rsa_priv = handle;
1099     rsa_priv->status.busy = 1U;
1100
1101     uint32_t bit_length = 1024;
1102
1103     if (rsa_priv->data_bit == RSA_DATA_BITS_2048) {
1104         bit_length = 2048;
1105     }
1106
1107 #ifndef RSA_USING_ID2KEY
1108     rsa_sw_exptmod_2_2m(n, bit_length, tmp_c);
1109 #endif
1110
1111     rsa_encrypt((uint8_t *)n, (uint8_t *)e, (uint8_t *)src, (uint32_t)src_size, (uint8_t *)out, (uint32_t *)out_size, (uint32_t)(padding.padding_type), bit_length, tmp_c);
1112     rsa_priv->status.busy = 0U;
1113
1114     if (rsa_priv->cb) {
1115         rsa_priv->cb(RSA_EVENT_ENCRYPT_COMPLETE);
1116     }
1117
1118     return 0;
1119 }
1120
1121 /**
1122   \brief       decrypt
1123   \param[in]   handle  rsa handle to operate.
1124   \param[in]   n         Pointer to the public modulus
1125   \param[in]   d         Pointer to the privte exponent
1126   \param[in]   src       Pointer to the source data.
1127   \param[in]   src_size  the source data len
1128   \param[out]  out       Pointer to the result buffer
1129   \param[out]  out_size  the result size
1130   \param[in]   padding   \ref rsa_padding_t
1131   \return      error code
1132 */
1133 int32_t csi_rsa_decrypt(rsa_handle_t handle, void *n, void *d, void *src, uint32_t src_size, void *out, uint32_t *out_size, rsa_padding_t padding)
1134 {
1135 #ifndef RSA_USING_ID2KEY
1136     uint32_t tmp_c[RSA_KEY_WORD];
1137 #endif
1138     RSA_NULL_PARAM_CHK(handle);
1139     RSA_NULL_PARAM_CHK(n);
1140     RSA_NULL_PARAM_CHK(d);
1141     RSA_NULL_PARAM_CHK(src);
1142     RSA_NULL_PARAM_CHK(out);
1143     RSA_NULL_PARAM_CHK(out_size);
1144
1145     if (src_size <= 0 || (padding.padding_type != RSA_PADDING_MODE_PKCS1 && padding.padding_type != RSA_PADDING_MODE_NO)) {
1146         return ERR_RSA(EDRV_PARAMETER);
1147     }
1148
1149     ck_rsa_priv_t *rsa_priv = handle;
1150     rsa_priv->status.busy = 1U;
1151
1152     uint32_t bit_length = 1024;
1153
1154     if (rsa_priv->data_bit == RSA_DATA_BITS_2048) {
1155         bit_length = 2048;
1156     }
1157
1158 #ifndef RSA_USING_ID2KEY
1159     rsa_sw_exptmod_2_2m(n, bit_length, tmp_c);
1160 #endif
1161
1162     rsa_decrypt((uint8_t *)n, (uint8_t *)d, (uint8_t *)src, (uint32_t)src_size, (uint8_t *)out, (uint32_t *)out_size, (uint32_t)(padding.padding_type), bit_length, tmp_c);
1163     rsa_priv->status.busy = 0U;
1164
1165     if (rsa_priv->cb) {
1166         rsa_priv->cb(RSA_EVENT_DECRYPT_COMPLETE);
1167     }
1168
1169     return 0;
1170 }
1171
1172 /**
1173   \brief       rsa sign
1174   \param[in]   handle  rsa handle to operate.
1175   \param[in]   n         Pointer to the public modulus
1176   \param[in]   d         Pointer to the privte exponent
1177   \param[in]   src       Pointer to the source data.
1178   \param[in]   src_size  the source data len
1179   \param[out]  signature Pointer to the signature
1180   \param[out]  sig_size  the signature size
1181   \param[in]   padding   \ref rsa_padding_t
1182   \return      error code
1183 */
1184 int32_t csi_rsa_sign(rsa_handle_t handle, void *n, void *d, void *src, uint32_t src_size, void *signature, void *sig_size, rsa_padding_t padding)
1185 {
1186 #ifndef RSA_USING_ID2KEY
1187     uint32_t tmp_c[RSA_KEY_WORD];
1188 #endif
1189     RSA_NULL_PARAM_CHK(handle);
1190     RSA_NULL_PARAM_CHK(n);
1191     RSA_NULL_PARAM_CHK(d);
1192     RSA_NULL_PARAM_CHK(src);
1193     RSA_NULL_PARAM_CHK(signature);
1194     RSA_NULL_PARAM_CHK(sig_size);
1195
1196     if (src_size <= 0 || (padding.hash_type != RSA_HASH_TYPE_MD5
1197                           && padding.hash_type != RSA_HASH_TYPE_SHA1
1198                           && padding.hash_type != RSA_HASH_TYPE_SHA256)) {
1199         return ERR_RSA(EDRV_PARAMETER);
1200     }
1201
1202     ck_rsa_priv_t *rsa_priv = handle;
1203     rsa_priv->status.busy = 1U;
1204     uint32_t bit_length = 1024;
1205
1206     if (rsa_priv->data_bit == RSA_DATA_BITS_2048) {
1207         bit_length = 2048;
1208     }
1209
1210 #ifndef RSA_USING_ID2KEY
1211     rsa_sw_exptmod_2_2m(n, bit_length, tmp_c);
1212 #endif
1213
1214     rsa_sign((uint8_t *)n, (uint8_t *)d, (uint8_t *)src, (uint32_t)src_size, (uint8_t *)signature, (uint32_t *)sig_size, (uint32_t)(padding.hash_type), bit_length, tmp_c);
1215     rsa_priv->status.busy = 0U;
1216
1217     if (rsa_priv->cb) {
1218         rsa_priv->cb(RSA_EVENT_SIGN_COMPLETE);
1219     }
1220
1221     return 0;
1222 }
1223
1224 /**
1225   \brief       rsa verify
1226   \param[in]   handle  rsa handle to operate.
1227   \param[in]   n         Pointer to the public modulus
1228   \param[in]   e         Pointer to the public exponent
1229   \param[in]   src       Pointer to the source data.
1230   \param[in]   src_size  the source data len
1231   \param[in]   signature Pointer to the signature
1232   \param[in]   sig_size  the signature size
1233   \param[out]  result    Pointer to the result
1234   \param[in]   padding   \ref rsa_padding_t
1235   \return      error code
1236 */
1237 int32_t csi_rsa_verify(rsa_handle_t handle, void *n, void *e, void *src, uint32_t src_size, void *signature, uint32_t sig_size, void *result, rsa_padding_t padding)
1238 {
1239 #ifndef RSA_USING_ID2KEY
1240     uint32_t tmp_c[RSA_KEY_WORD];
1241 #endif
1242     RSA_NULL_PARAM_CHK(handle);
1243     RSA_NULL_PARAM_CHK(n);
1244     RSA_NULL_PARAM_CHK(e);
1245     RSA_NULL_PARAM_CHK(src);
1246     RSA_NULL_PARAM_CHK(signature);
1247     RSA_NULL_PARAM_CHK(result);
1248
1249     if (src_size <= 0 || sig_size <= 0 || (padding.hash_type != RSA_HASH_TYPE_MD5 && padding.hash_type != RSA_HASH_TYPE_SHA1 && padding.hash_type != RSA_HASH_TYPE_SHA256)) {
1250         return ERR_RSA(EDRV_PARAMETER);
1251     }
1252
1253     ck_rsa_priv_t *rsa_priv = handle;
1254     rsa_priv->status.busy = 1U;
1255
1256     uint32_t bit_length = 1024;
1257
1258     if (rsa_priv->data_bit == RSA_DATA_BITS_2048) {
1259         bit_length = 2048;
1260     }
1261
1262 #ifndef RSA_USING_ID2KEY
1263     rsa_sw_exptmod_2_2m(n, bit_length, tmp_c);
1264 #endif
1265
1266     rsa_verify((uint8_t *)n, (uint8_t *)e, (uint8_t *)src, (uint32_t)src_size, (uint8_t *)signature, sig_size, (uint32_t)(padding.hash_type), bit_length, (uint8_t *)result, tmp_c);
1267     rsa_priv->status.busy = 0U;
1268
1269     if (rsa_priv->cb) {
1270         rsa_priv->cb(RSA_EVENT_VERIFY_COMPLETE);
1271     }
1272
1273     return 0;
1274 }
1275
1276 /**
1277   \brief       Get RSA status.
1278   \param[in]   handle  rsa handle to operate.
1279   \return      RSA status \ref rsa_status_t
1280 */
1281 rsa_status_t csi_rsa_get_status(rsa_handle_t handle)
1282 {
1283     ck_rsa_priv_t *rsa_priv = handle;
1284     return rsa_priv->status;
1285 }