src/flash.c

   1 /*
   2  * flash.c -- Data Objects (DO) and GPG Key handling on Flash ROM
   3  *
   4  * Copyright (C) 2010, 2011, 2012, 2013, 2014, 2015
   5  *               Free Software Initiative of Japan
   6  * Author: NIIBE Yutaka <gniibe@fsij.org>
   7  *
   8  * This file is a part of Gnuk, a GnuPG USB Token implementation.
   9  *
  10  * Gnuk is free software: you can redistribute it and/or modify it
  11  * under the terms of the GNU General Public License as published by
  12  * the Free Software Foundation, either version 3 of the License, or
  13  * (at your option) any later version.
  14  *
  15  * Gnuk is distributed in the hope that it will be useful, but WITHOUT
  16  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
  17  * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public
  18  * License for more details.
  19  *
  20  * You should have received a copy of the GNU General Public License
  21  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  22  *
  23  */
  24
  25 /*
  26  * We assume single DO size is less than 256.
  27  *
  28  * NOTE: "Card holder certificate" (which size is larger than 256) is
  29  *       not put into data pool, but is implemented by its own flash
  30  *       page(s).
  31  */
  32
  33 #include <stdint.h>
  34 #include <string.h>
  35
  36 #include "config.h"
  37
  38 #include "sys.h"
  39 #include "gnuk.h"
  40
  41 /*
  42  * Flash memory map
  43  *
  44  * _text
  45  *         .text
  46  *         .ctors
  47  *         .dtors
  48  * _etext
  49  *         .data
  50  * _bss_start
  51  *         .bss
  52  * _end
  53  *         <alignment to page>
  54  * ch_certificate_startp
  55  *         <2048 bytes>
  56  * _data_pool
  57  *         <two pages>
  58  * _keystore_pool
  59  *         Three flash pages for keystore
  60  *         a page contains a key data of:
  61  *              For RSA-2048: 512-byte (p, q and N)
  62  *              For RSA-4096: 1024-byte (p, q and N)
  63  *              For ECDSA/ECDH and EdDSA, there are padding after public key
  64  */
  65
  66 #define FLASH_DATA_POOL_HEADER_SIZE     2
  67 #define FLASH_DATA_POOL_SIZE            (flash_page_size*2)
  68
  69 static uint16_t flash_page_size;
  70
  71 static const uint8_t *data_pool;
  72 extern uint8_t _keystore_pool;
  73
  74 static uint8_t *last_p;
  75
  76 /* The first halfword is generation for the data page (little endian) */
  77 const uint8_t const flash_data[4] __attribute__ ((section (".gnuk_data"))) = {
  78   0x01, 0x00, 0xff, 0xff
  79 };
  80
  81 /* Linker set this symbol */
  82 extern uint8_t _data_pool;
  83
  84 static int key_available_at (const uint8_t *k, int key_size)
  85 {
  86   int i;
  87
  88   for (i = 0; i < key_size; i++)
  89     if (k[i])
  90       break;
  91   if (i == key_size)    /* It's ZERO.  Released key.  */
  92     return 0;
  93
  94   for (i = 0; i < key_size; i++)
  95     if (k[i] != 0xff)
  96       break;
  97   if (i == key_size)    /* It's FULL.  Unused key.  */
  98     return 0;
  99
 100   return 1;
 101 }
 102
 103
 104 #define CHIP_ID_REG      ((uint32_t *)0xe0042000)
 105 const uint8_t *
 106 flash_init (void)
 107 {
 108   uint16_t gen0, gen1;
 109   uint16_t *gen0_p = (uint16_t *)&_data_pool;
 110   uint16_t *gen1_p;
 111
 112   flash_page_size = 1024;
 113   if (((*CHIP_ID_REG) & 0xfff) == 0x0414)
 114     flash_page_size = 2048;
 115
 116   gen1_p = (uint16_t *)(&_data_pool + flash_page_size);
 117
 118   /* Check data pool generation and choose the page */
 119   gen0 = *gen0_p;
 120   gen1 = *gen1_p;
 121   if (gen0 == 0xffff)
 122     data_pool = &_data_pool + flash_page_size;
 123   else if (gen1 == 0xffff)
 124     data_pool = &_data_pool;
 125   else if (gen1 > gen0)
 126     data_pool = &_data_pool + flash_page_size;
 127   else
 128     data_pool = &_data_pool;
 129
 130   return data_pool + FLASH_DATA_POOL_HEADER_SIZE;
 131 }
 132
 133 void
 134 flash_init_keys (void)
 135 {
 136   const uint8_t *p;
 137   int i;
 138
 139   /* For each key, find its address.  */
 140   p = &_keystore_pool;
 141   for (i = 0; i < 3; i++)
 142     {
 143       const uint8_t *k;
 144       int key_size = gpg_get_algo_attr_key_size (i, GPG_KEY_STORAGE);
 145
 146       kd[i].pubkey = NULL;
 147       for (k = p; k < p + flash_page_size; k += key_size)
 148         if (key_available_at (k, key_size))
 149           {
 150             int prv_len = gpg_get_algo_attr_key_size (i, GPG_KEY_PRIVATE);
 151
 152             kd[i].pubkey = k + prv_len;
 153             break;
 154           }
 155
 156       p += flash_page_size;
 157     }
 158 }
 159
 160 /*
 161  * Flash data pool managenent
 162  *
 163  * Flash data pool consists of two parts:
 164  *   2-byte header
 165  *   contents
 166  *
 167  * Flash data pool objects:
 168  *   Data Object (DO) (of smart card)
 169  *   Internal objects:
 170  *     NONE (0x0000)
 171  *     123-counter
 172  *     14-bit counter
 173  *     bool object
 174  *     small enum
 175  *
 176  * Format of a Data Object:
 177  *    NR:   8-bit tag_number
 178  *    LEN:  8-bit length
 179  *    DATA: data * LEN
 180  *    PAD:  optional byte for 16-bit alignment
 181  */
 182
 183 void
 184 flash_set_data_pool_last (const uint8_t *p)
 185 {
 186   last_p = (uint8_t *)p;
 187 }
 188
 189 /*
 190  * We use two pages
 191  */
 192 static int
 193 flash_copying_gc (void)
 194 {
 195   uint8_t *src, *dst;
 196   uint16_t generation;
 197
 198   if (data_pool == &_data_pool)
 199     {
 200       src = &_data_pool;
 201       dst = &_data_pool + flash_page_size;
 202     }
 203   else
 204     {
 205       src = &_data_pool + flash_page_size;
 206       dst = &_data_pool;
 207     }
 208
 209   generation = *(uint16_t *)src;
 210   data_pool = dst;
 211   gpg_data_copy (data_pool + FLASH_DATA_POOL_HEADER_SIZE);
 212   flash_erase_page ((uint32_t)src);
 213   flash_program_halfword ((uint32_t)dst, generation+1);
 214   return 0;
 215 }
 216
 217 static int
 218 is_data_pool_full (size_t size)
 219 {
 220   return last_p + size > data_pool + flash_page_size;
 221 }
 222
 223 static uint8_t *
 224 flash_data_pool_allocate (size_t size)
 225 {
 226   uint8_t *p;
 227
 228   size = (size + 1) & ~1;       /* allocation unit is 1-halfword (2-byte) */
 229
 230   if (is_data_pool_full (size))
 231     if (flash_copying_gc () < 0 || /*still*/ is_data_pool_full (size))
 232       fatal (FATAL_FLASH);
 233
 234   p = last_p;
 235   last_p += size;
 236   return p;
 237 }
 238
 239 void
 240 flash_do_write_internal (const uint8_t *p, int nr, const uint8_t *data, int len)
 241 {
 242   uint16_t hw;
 243   uint32_t addr;
 244   int i;
 245
 246   addr = (uint32_t)p;
 247   hw = nr | (len << 8);
 248   if (flash_program_halfword (addr, hw) != 0)
 249     flash_warning ("DO WRITE ERROR");
 250   addr += 2;
 251
 252   for (i = 0; i < len/2; i++)
 253     {
 254       hw = data[i*2] | (data[i*2+1]<<8);
 255       if (flash_program_halfword (addr, hw) != 0)
 256         flash_warning ("DO WRITE ERROR");
 257       addr += 2;
 258     }
 259
 260   if ((len & 1))
 261     {
 262       hw = data[i*2] | 0xff00;
 263       if (flash_program_halfword (addr, hw) != 0)
 264         flash_warning ("DO WRITE ERROR");
 265     }
 266 }
 267
 268 const uint8_t *
 269 flash_do_write (uint8_t nr, const uint8_t *data, int len)
 270 {
 271   const uint8_t *p;
 272
 273   DEBUG_INFO ("flash DO\r\n");
 274
 275   p = flash_data_pool_allocate (2 + len);
 276   if (p == NULL)
 277     {
 278       DEBUG_INFO ("flash data pool allocation failure.\r\n");
 279       return NULL;
 280     }
 281
 282   flash_do_write_internal (p, nr, data, len);
 283   DEBUG_INFO ("flash DO...done\r\n");
 284   return p + 1;
 285 }
 286
 287 void
 288 flash_warning (const char *msg)
 289 {
 290   (void)msg;
 291   DEBUG_INFO ("FLASH: ");
 292   DEBUG_INFO (msg);
 293   DEBUG_INFO ("\r\n");
 294 }
 295
 296 void
 297 flash_do_release (const uint8_t *do_data)
 298 {
 299   uint32_t addr = (uint32_t)do_data - 1;
 300   uint32_t addr_tag = addr;
 301   int i;
 302   int len = do_data[0];
 303
 304   /* Don't filling zero for data in code (such as ds_count_initial_value) */
 305   if (do_data < &_data_pool || do_data > &_data_pool + FLASH_DATA_POOL_SIZE)
 306     return;
 307
 308   addr += 2;
 309
 310   /* Fill zero for content and pad */
 311   for (i = 0; i < len/2; i ++)
 312     {
 313       if (flash_program_halfword (addr, 0) != 0)
 314         flash_warning ("fill-zero failure");
 315       addr += 2;
 316     }
 317
 318   if ((len & 1))
 319     {
 320       if (flash_program_halfword (addr, 0) != 0)
 321         flash_warning ("fill-zero pad failure");
 322     }
 323
 324   /* Fill 0x0000 for "tag_number and length" word */
 325   if (flash_program_halfword (addr_tag, 0) != 0)
 326     flash_warning ("fill-zero tag_nr failure");
 327 }
 328
 329
 330 static uint8_t *
 331 flash_key_getpage (enum kind_of_key kk)
 332 {
 333   /* There is a page for each KK.  */
 334   return &_keystore_pool + (flash_page_size * kk);
 335 }
 336
 337 uint8_t *
 338 flash_key_alloc (enum kind_of_key kk)
 339 {
 340   uint8_t *k, *k0 = flash_key_getpage (kk);
 341   int i;
 342   int key_size = gpg_get_algo_attr_key_size (kk, GPG_KEY_STORAGE);
 343
 344   /* Seek free space in the page.  */
 345   for (k = k0; k < k0 + flash_page_size; k += key_size)
 346     {
 347       const uint32_t *p = (const uint32_t *)k;
 348
 349       for (i = 0; i < key_size/4; i++)
 350         if (p[i] != 0xffffffff)
 351           break;
 352
 353       if (i == key_size/4)      /* Yes, it's empty.  */
 354         return k;
 355     }
 356
 357   /* Should not happen as we have enough free space all time, but just
 358      in case.  */
 359   return NULL;
 360 }
 361
 362 int
 363 flash_key_write (uint8_t *key_addr,
 364                  const uint8_t *key_data, int key_data_len,
 365                  const uint8_t *pubkey, int pubkey_len)
 366 {
 367   uint16_t hw;
 368   uint32_t addr;
 369   int i;
 370
 371   addr = (uint32_t)key_addr;
 372   for (i = 0; i < key_data_len/2; i ++)
 373     {
 374       hw = key_data[i*2] | (key_data[i*2+1]<<8);
 375       if (flash_program_halfword (addr, hw) != 0)
 376         return -1;
 377       addr += 2;
 378     }
 379
 380   for (i = 0; i < pubkey_len/2; i ++)
 381     {
 382       hw = pubkey[i*2] | (pubkey[i*2+1]<<8);
 383       if (flash_program_halfword (addr, hw) != 0)
 384         return -1;
 385       addr += 2;
 386     }
 387
 388   return 0;
 389 }
 390
 391 static int
 392 flash_check_all_other_keys_released (const uint8_t *key_addr, int key_size)
 393 {
 394   uint32_t start = (uint32_t)key_addr & ~(flash_page_size - 1);
 395   const uint32_t *p = (const uint32_t *)start;
 396
 397   while (p < (const uint32_t *)(start + flash_page_size))
 398     if (p == (const uint32_t *)key_addr)
 399       p += key_size/4;
 400     else
 401       if (*p)
 402         return 0;
 403       else
 404         p++;
 405
 406   return 1;
 407 }
 408
 409 static void
 410 flash_key_fill_zero_as_released (uint8_t *key_addr, int key_size)
 411 {
 412   int i;
 413   uint32_t addr = (uint32_t)key_addr;
 414
 415   for (i = 0; i < key_size/2; i++)
 416     flash_program_halfword (addr + i*2, 0);
 417 }
 418
 419 void
 420 flash_key_release (uint8_t *key_addr, int key_size)
 421 {
 422   if (flash_check_all_other_keys_released (key_addr, key_size))
 423     flash_erase_page (((uint32_t)key_addr & ~(flash_page_size - 1)));
 424   else
 425     flash_key_fill_zero_as_released (key_addr, key_size);
 426 }
 427
 428 void
 429 flash_key_release_page (enum kind_of_key kk)
 430 {
 431   flash_erase_page ((uint32_t)flash_key_getpage (kk));
 432 }
 433
 434
 435 void
 436 flash_clear_halfword (uint32_t addr)
 437 {
 438   flash_program_halfword (addr, 0);
 439 }
 440
 441
 442 void
 443 flash_put_data_internal (const uint8_t *p, uint16_t hw)
 444 {
 445   flash_program_halfword ((uint32_t)p, hw);
 446 }
 447
 448 void
 449 flash_put_data (uint16_t hw)
 450 {
 451   uint8_t *p;
 452
 453   p = flash_data_pool_allocate (2);
 454   if (p == NULL)
 455     {
 456       DEBUG_INFO ("data allocation failure.\r\n");
 457     }
 458
 459   flash_program_halfword ((uint32_t)p, hw);
 460 }
 461
 462
 463 void
 464 flash_bool_clear (const uint8_t **addr_p)
 465 {
 466   const uint8_t *p;
 467
 468   if ((p = *addr_p) == NULL)
 469     return;
 470
 471   flash_program_halfword ((uint32_t)p, 0);
 472   *addr_p = NULL;
 473 }
 474
 475 void
 476 flash_bool_write_internal (const uint8_t *p, int nr)
 477 {
 478   flash_program_halfword ((uint32_t)p, nr);
 479 }
 480
 481 const uint8_t *
 482 flash_bool_write (uint8_t nr)
 483 {
 484   uint8_t *p;
 485   uint16_t hw = nr;
 486
 487   p = flash_data_pool_allocate (2);
 488   if (p == NULL)
 489     {
 490       DEBUG_INFO ("bool allocation failure.\r\n");
 491       return NULL;
 492     }
 493
 494   flash_program_halfword ((uint32_t)p, hw);
 495   return p;
 496 }
 497
 498
 499 void
 500 flash_enum_clear (const uint8_t **addr_p)
 501 {
 502   flash_bool_clear (addr_p);
 503 }
 504
 505 void
 506 flash_enum_write_internal (const uint8_t *p, int nr, uint8_t v)
 507 {
 508   uint16_t hw = nr | (v << 8);
 509
 510   flash_program_halfword ((uint32_t)p, hw);
 511 }
 512
 513 const uint8_t *
 514 flash_enum_write (uint8_t nr, uint8_t v)
 515 {
 516   uint8_t *p;
 517   uint16_t hw = nr | (v << 8);
 518
 519   p = flash_data_pool_allocate (2);
 520   if (p == NULL)
 521     {
 522       DEBUG_INFO ("enum allocation failure.\r\n");
 523       return NULL;
 524     }
 525
 526   flash_program_halfword ((uint32_t)p, hw);
 527   return p;
 528 }
 529
 530
 531 int
 532 flash_cnt123_get_value (const uint8_t *p)
 533 {
 534   if (p == NULL)
 535     return 0;
 536   else
 537     {
 538       uint8_t v = *p;
 539
 540       /*
 541        * After erase, a halfword in flash memory becomes 0xffff.
 542        * The halfword can be programmed to any value.
 543        * Then, the halfword can be programmed to zero.
 544        *
 545        * Thus, we can represent value 1, 2, and 3.
 546        */
 547       if (v == 0xff)
 548         return 1;
 549       else if (v == 0x00)
 550         return 3;
 551       else
 552         return 2;
 553     }
 554 }
 555
 556 void
 557 flash_cnt123_write_internal (const uint8_t *p, int which, int v)
 558 {
 559   uint16_t hw;
 560
 561   hw = NR_COUNTER_123 | (which << 8);
 562   flash_program_halfword ((uint32_t)p, hw);
 563
 564   if (v == 1)
 565     return;
 566   else if (v == 2)
 567     flash_program_halfword ((uint32_t)p+2, 0xc3c3);
 568   else                          /* v == 3 */
 569     flash_program_halfword ((uint32_t)p+2, 0);
 570 }
 571
 572 void
 573 flash_cnt123_increment (uint8_t which, const uint8_t **addr_p)
 574 {
 575   const uint8_t *p;
 576   uint16_t hw;
 577
 578   if ((p = *addr_p) == NULL)
 579     {
 580       p = flash_data_pool_allocate (4);
 581       if (p == NULL)
 582         {
 583           DEBUG_INFO ("cnt123 allocation failure.\r\n");
 584           return;
 585         }
 586       hw = NR_COUNTER_123 | (which << 8);
 587       flash_program_halfword ((uint32_t)p, hw);
 588       *addr_p = p + 2;
 589     }
 590   else
 591     {
 592       uint8_t v = *p;
 593
 594       if (v == 0)
 595         return;
 596
 597       if (v == 0xff)
 598         hw = 0xc3c3;
 599       else
 600         hw = 0;
 601
 602       flash_program_halfword ((uint32_t)p, hw);
 603     }
 604 }
 605
 606 void
 607 flash_cnt123_clear (const uint8_t **addr_p)
 608 {
 609   const uint8_t *p;
 610
 611   if ((p = *addr_p) == NULL)
 612     return;
 613
 614   flash_program_halfword ((uint32_t)p, 0);
 615   p -= 2;
 616   flash_program_halfword ((uint32_t)p, 0);
 617   *addr_p = NULL;
 618 }
 619
 620
 621 #if defined(CERTDO_SUPPORT)
 622 int
 623 flash_erase_binary (uint8_t file_id)
 624 {
 625   if (file_id == FILEID_CH_CERTIFICATE)
 626     {
 627       const uint8_t *p = &ch_certificate_start;
 628       if (flash_check_blank (p, FLASH_CH_CERTIFICATE_SIZE) == 0)
 629         {
 630           flash_erase_page ((uint32_t)p);
 631           if (FLASH_CH_CERTIFICATE_SIZE > flash_page_size)
 632             flash_erase_page ((uint32_t)p + flash_page_size);
 633         }
 634
 635       return 0;
 636     }
 637
 638   return -1;
 639 }
 640 #endif
 641
 642
 643 int
 644 flash_write_binary (uint8_t file_id, const uint8_t *data,
 645                     uint16_t len, uint16_t offset)
 646 {
 647   uint16_t maxsize;
 648   const uint8_t *p;
 649
 650   if (file_id == FILEID_SERIAL_NO)
 651     {
 652       maxsize = 6;
 653       p = &openpgpcard_aid[8];
 654     }
 655   else if (file_id >= FILEID_UPDATE_KEY_0 && file_id <= FILEID_UPDATE_KEY_3)
 656     {
 657       maxsize = FIRMWARE_UPDATE_KEY_CONTENT_LEN;
 658       p = gpg_get_firmware_update_key (file_id - FILEID_UPDATE_KEY_0);
 659       if (len == 0 && offset == 0)
 660         { /* This means removal of update key.  */
 661           if (flash_program_halfword ((uint32_t)p, 0) != 0)
 662             flash_warning ("DO WRITE ERROR");
 663           return 0;
 664         }
 665     }
 666 #if defined(CERTDO_SUPPORT)
 667   else if (file_id == FILEID_CH_CERTIFICATE)
 668     {
 669       maxsize = FLASH_CH_CERTIFICATE_SIZE;
 670       p = &ch_certificate_start;
 671     }
 672 #endif
 673   else
 674     return -1;
 675
 676   if (offset + len > maxsize || (offset&1) || (len&1))
 677     return -1;
 678   else
 679     {
 680       uint16_t hw;
 681       uint32_t addr;
 682       int i;
 683
 684       if (flash_check_blank (p + offset, len)  == 0)
 685         return -1;
 686
 687       addr = (uint32_t)p + offset;
 688       for (i = 0; i < len/2; i++)
 689         {
 690           hw = data[i*2] | (data[i*2+1]<<8);
 691           if (flash_program_halfword (addr, hw) != 0)
 692             flash_warning ("DO WRITE ERROR");
 693           addr += 2;
 694         }
 695
 696       return 0;
 697     }
 698 }