Erase CERTDO on terminate.
[gnuk/gnuk.git] / 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, 2016, 2017
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   0x00, 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 void
106 flash_init (const uint8_t **p_do_start, const uint8_t **p_do_end)
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   data_pool = &_data_pool;
118
119   /* Check data pool generation and choose the page */
120   gen0 = *gen0_p;
121   gen1 = *gen1_p;
122
123   if (gen0 == 0xffff && gen1 == 0xffff)
124     {
125       /* It's terminated.  */
126       *p_do_start = *p_do_end = NULL;
127       return;
128     }
129
130   if (gen0 == 0xffff)
131     /* Use another page if a page is erased.  */
132     data_pool = &_data_pool + flash_page_size;
133   else if (gen1 == 0xffff)
134     /* Or use different page if another page is erased.  */
135     data_pool = &_data_pool;
136   else if ((gen0 == 0xfffe && gen1 == 0) || gen1 > gen0)
137     /* When both pages have valid header, use newer page.   */
138     data_pool = &_data_pool + flash_page_size;
139
140   *p_do_start = data_pool + FLASH_DATA_POOL_HEADER_SIZE;
141   *p_do_end = data_pool + flash_page_size;
142 }
143
144 static uint8_t *flash_key_getpage (enum kind_of_key kk);
145
146 void
147 flash_terminate (void)
148 {
149   int i;
150
151   for (i = 0; i < 3; i++)
152     flash_erase_page ((uint32_t)flash_key_getpage (i));
153   flash_erase_page ((uint32_t)&_data_pool);
154   flash_erase_page ((uint32_t)(&_data_pool + flash_page_size));
155   data_pool = &_data_pool;
156   last_p = &_data_pool + FLASH_DATA_POOL_HEADER_SIZE;
157 #if defined(CERTDO_SUPPORT)
158   flash_erase_page ((uint32_t)&ch_certificate_start);
159   if (FLASH_CH_CERTIFICATE_SIZE > flash_page_size)
160     flash_erase_page ((uint32_t)(&ch_certificate_start + flash_page_size));
161 #endif
162 }
163
164 void
165 flash_activate (void)
166 {
167   flash_program_halfword ((uint32_t)&_data_pool, 0);
168 }
169
170
171 void
172 flash_init_keys (void)
173 {
174   const uint8_t *p;
175   int i;
176
177   /* For each key, find its address.  */
178   p = &_keystore_pool;
179   for (i = 0; i < 3; i++)
180     {
181       const uint8_t *k;
182       int key_size = gpg_get_algo_attr_key_size (i, GPG_KEY_STORAGE);
183
184       kd[i].pubkey = NULL;
185       for (k = p; k < p + flash_page_size; k += key_size)
186         if (key_available_at (k, key_size))
187           {
188             int prv_len = gpg_get_algo_attr_key_size (i, GPG_KEY_PRIVATE);
189
190             kd[i].pubkey = k + prv_len;
191             break;
192           }
193
194       p += flash_page_size;
195     }
196 }
197
198 /*
199  * Flash data pool managenent
200  *
201  * Flash data pool consists of two parts:
202  *   2-byte header
203  *   contents
204  *
205  * Flash data pool objects:
206  *   Data Object (DO) (of smart card)
207  *   Internal objects:
208  *     NONE (0x0000)
209  *     123-counter
210  *     14-bit counter
211  *     bool object
212  *     small enum
213  *
214  * Format of a Data Object:
215  *    NR:   8-bit tag_number
216  *    LEN:  8-bit length
217  *    DATA: data * LEN
218  *    PAD:  optional byte for 16-bit alignment
219  */
220
221 void
222 flash_set_data_pool_last (const uint8_t *p)
223 {
224   last_p = (uint8_t *)p;
225 }
226
227 /*
228  * We use two pages
229  */
230 static int
231 flash_copying_gc (void)
232 {
233   uint8_t *src, *dst;
234   uint16_t generation;
235
236   if (data_pool == &_data_pool)
237     {
238       src = &_data_pool;
239       dst = &_data_pool + flash_page_size;
240     }
241   else
242     {
243       src = &_data_pool + flash_page_size;
244       dst = &_data_pool;
245     }
246
247   generation = *(uint16_t *)src;
248   data_pool = dst;
249   gpg_data_copy (data_pool + FLASH_DATA_POOL_HEADER_SIZE);
250   if (generation == 0xfffe)
251     generation = 0;
252   else
253     generation++;
254   flash_program_halfword ((uint32_t)dst, generation);
255   flash_erase_page ((uint32_t)src);
256   return 0;
257 }
258
259 static int
260 is_data_pool_full (size_t size)
261 {
262   return last_p + size > data_pool + flash_page_size;
263 }
264
265 static uint8_t *
266 flash_data_pool_allocate (size_t size)
267 {
268   uint8_t *p;
269
270   size = (size + 1) & ~1;       /* allocation unit is 1-halfword (2-byte) */
271
272   if (is_data_pool_full (size))
273     if (flash_copying_gc () < 0 || /*still*/ is_data_pool_full (size))
274       fatal (FATAL_FLASH);
275
276   p = last_p;
277   last_p += size;
278   return p;
279 }
280
281 void
282 flash_do_write_internal (const uint8_t *p, int nr, const uint8_t *data, int len)
283 {
284   uint16_t hw;
285   uint32_t addr;
286   int i;
287
288   addr = (uint32_t)p;
289   hw = nr | (len << 8);
290   if (flash_program_halfword (addr, hw) != 0)
291     flash_warning ("DO WRITE ERROR");
292   addr += 2;
293
294   for (i = 0; i < len/2; i++)
295     {
296       hw = data[i*2] | (data[i*2+1]<<8);
297       if (flash_program_halfword (addr, hw) != 0)
298         flash_warning ("DO WRITE ERROR");
299       addr += 2;
300     }
301
302   if ((len & 1))
303     {
304       hw = data[i*2] | 0xff00;
305       if (flash_program_halfword (addr, hw) != 0)
306         flash_warning ("DO WRITE ERROR");
307     }
308 }
309
310 const uint8_t *
311 flash_do_write (uint8_t nr, const uint8_t *data, int len)
312 {
313   const uint8_t *p;
314
315   DEBUG_INFO ("flash DO\r\n");
316
317   p = flash_data_pool_allocate (2 + len);
318   if (p == NULL)
319     {
320       DEBUG_INFO ("flash data pool allocation failure.\r\n");
321       return NULL;
322     }
323
324   flash_do_write_internal (p, nr, data, len);
325   DEBUG_INFO ("flash DO...done\r\n");
326   return p + 1;
327 }
328
329 void
330 flash_warning (const char *msg)
331 {
332   (void)msg;
333   DEBUG_INFO ("FLASH: ");
334   DEBUG_INFO (msg);
335   DEBUG_INFO ("\r\n");
336 }
337
338 void
339 flash_do_release (const uint8_t *do_data)
340 {
341   uint32_t addr = (uint32_t)do_data - 1;
342   uint32_t addr_tag = addr;
343   int i;
344   int len = do_data[0];
345
346   /* Don't filling zero for data in code (such as ds_count_initial_value) */
347   if (do_data < &_data_pool || do_data > &_data_pool + FLASH_DATA_POOL_SIZE)
348     return;
349
350   addr += 2;
351
352   /* Fill zero for content and pad */
353   for (i = 0; i < len/2; i ++)
354     {
355       if (flash_program_halfword (addr, 0) != 0)
356         flash_warning ("fill-zero failure");
357       addr += 2;
358     }
359
360   if ((len & 1))
361     {
362       if (flash_program_halfword (addr, 0) != 0)
363         flash_warning ("fill-zero pad failure");
364     }
365
366   /* Fill 0x0000 for "tag_number and length" word */
367   if (flash_program_halfword (addr_tag, 0) != 0)
368     flash_warning ("fill-zero tag_nr failure");
369 }
370
371
372 static uint8_t *
373 flash_key_getpage (enum kind_of_key kk)
374 {
375   /* There is a page for each KK.  */
376   return &_keystore_pool + (flash_page_size * kk);
377 }
378
379 uint8_t *
380 flash_key_alloc (enum kind_of_key kk)
381 {
382   uint8_t *k, *k0 = flash_key_getpage (kk);
383   int i;
384   int key_size = gpg_get_algo_attr_key_size (kk, GPG_KEY_STORAGE);
385
386   /* Seek free space in the page.  */
387   for (k = k0; k < k0 + flash_page_size; k += key_size)
388     {
389       const uint32_t *p = (const uint32_t *)k;
390
391       for (i = 0; i < key_size/4; i++)
392         if (p[i] != 0xffffffff)
393           break;
394
395       if (i == key_size/4)      /* Yes, it's empty.  */
396         return k;
397     }
398
399   /* Should not happen as we have enough free space all time, but just
400      in case.  */
401   return NULL;
402 }
403
404 int
405 flash_key_write (uint8_t *key_addr,
406                  const uint8_t *key_data, int key_data_len,
407                  const uint8_t *pubkey, int pubkey_len)
408 {
409   uint16_t hw;
410   uint32_t addr;
411   int i;
412
413   addr = (uint32_t)key_addr;
414   for (i = 0; i < key_data_len/2; i ++)
415     {
416       hw = key_data[i*2] | (key_data[i*2+1]<<8);
417       if (flash_program_halfword (addr, hw) != 0)
418         return -1;
419       addr += 2;
420     }
421
422   for (i = 0; i < pubkey_len/2; i ++)
423     {
424       hw = pubkey[i*2] | (pubkey[i*2+1]<<8);
425       if (flash_program_halfword (addr, hw) != 0)
426         return -1;
427       addr += 2;
428     }
429
430   return 0;
431 }
432
433 static int
434 flash_check_all_other_keys_released (const uint8_t *key_addr, int key_size)
435 {
436   uint32_t start = (uint32_t)key_addr & ~(flash_page_size - 1);
437   const uint32_t *p = (const uint32_t *)start;
438
439   while (p < (const uint32_t *)(start + flash_page_size))
440     if (p == (const uint32_t *)key_addr)
441       p += key_size/4;
442     else
443       if (*p)
444         return 0;
445       else
446         p++;
447
448   return 1;
449 }
450
451 static void
452 flash_key_fill_zero_as_released (uint8_t *key_addr, int key_size)
453 {
454   int i;
455   uint32_t addr = (uint32_t)key_addr;
456
457   for (i = 0; i < key_size/2; i++)
458     flash_program_halfword (addr + i*2, 0);
459 }
460
461 void
462 flash_key_release (uint8_t *key_addr, int key_size)
463 {
464   if (flash_check_all_other_keys_released (key_addr, key_size))
465     flash_erase_page (((uint32_t)key_addr & ~(flash_page_size - 1)));
466   else
467     flash_key_fill_zero_as_released (key_addr, key_size);
468 }
469
470 void
471 flash_key_release_page (enum kind_of_key kk)
472 {
473   flash_erase_page ((uint32_t)flash_key_getpage (kk));
474 }
475
476
477 void
478 flash_clear_halfword (uint32_t addr)
479 {
480   flash_program_halfword (addr, 0);
481 }
482
483
484 void
485 flash_put_data_internal (const uint8_t *p, uint16_t hw)
486 {
487   flash_program_halfword ((uint32_t)p, hw);
488 }
489
490 void
491 flash_put_data (uint16_t hw)
492 {
493   uint8_t *p;
494
495   p = flash_data_pool_allocate (2);
496   if (p == NULL)
497     {
498       DEBUG_INFO ("data allocation failure.\r\n");
499     }
500
501   flash_program_halfword ((uint32_t)p, hw);
502 }
503
504
505 void
506 flash_bool_clear (const uint8_t **addr_p)
507 {
508   const uint8_t *p;
509
510   if ((p = *addr_p) == NULL)
511     return;
512
513   flash_program_halfword ((uint32_t)p, 0);
514   *addr_p = NULL;
515 }
516
517 void
518 flash_bool_write_internal (const uint8_t *p, int nr)
519 {
520   flash_program_halfword ((uint32_t)p, nr);
521 }
522
523 const uint8_t *
524 flash_bool_write (uint8_t nr)
525 {
526   uint8_t *p;
527   uint16_t hw = nr;
528
529   p = flash_data_pool_allocate (2);
530   if (p == NULL)
531     {
532       DEBUG_INFO ("bool allocation failure.\r\n");
533       return NULL;
534     }
535
536   flash_program_halfword ((uint32_t)p, hw);
537   return p;
538 }
539
540
541 void
542 flash_enum_clear (const uint8_t **addr_p)
543 {
544   flash_bool_clear (addr_p);
545 }
546
547 void
548 flash_enum_write_internal (const uint8_t *p, int nr, uint8_t v)
549 {
550   uint16_t hw = nr | (v << 8);
551
552   flash_program_halfword ((uint32_t)p, hw);
553 }
554
555 const uint8_t *
556 flash_enum_write (uint8_t nr, uint8_t v)
557 {
558   uint8_t *p;
559   uint16_t hw = nr | (v << 8);
560
561   p = flash_data_pool_allocate (2);
562   if (p == NULL)
563     {
564       DEBUG_INFO ("enum allocation failure.\r\n");
565       return NULL;
566     }
567
568   flash_program_halfword ((uint32_t)p, hw);
569   return p;
570 }
571
572
573 int
574 flash_cnt123_get_value (const uint8_t *p)
575 {
576   if (p == NULL)
577     return 0;
578   else
579     {
580       uint8_t v = *p;
581
582       /*
583        * After erase, a halfword in flash memory becomes 0xffff.
584        * The halfword can be programmed to any value.
585        * Then, the halfword can be programmed to zero.
586        *
587        * Thus, we can represent value 1, 2, and 3.
588        */
589       if (v == 0xff)
590         return 1;
591       else if (v == 0x00)
592         return 3;
593       else
594         return 2;
595     }
596 }
597
598 void
599 flash_cnt123_write_internal (const uint8_t *p, int which, int v)
600 {
601   uint16_t hw;
602
603   hw = NR_COUNTER_123 | (which << 8);
604   flash_program_halfword ((uint32_t)p, hw);
605
606   if (v == 1)
607     return;
608   else if (v == 2)
609     flash_program_halfword ((uint32_t)p+2, 0xc3c3);
610   else                          /* v == 3 */
611     flash_program_halfword ((uint32_t)p+2, 0);
612 }
613
614 void
615 flash_cnt123_increment (uint8_t which, const uint8_t **addr_p)
616 {
617   const uint8_t *p;
618   uint16_t hw;
619
620   if ((p = *addr_p) == NULL)
621     {
622       p = flash_data_pool_allocate (4);
623       if (p == NULL)
624         {
625           DEBUG_INFO ("cnt123 allocation failure.\r\n");
626           return;
627         }
628       hw = NR_COUNTER_123 | (which << 8);
629       flash_program_halfword ((uint32_t)p, hw);
630       *addr_p = p + 2;
631     }
632   else
633     {
634       uint8_t v = *p;
635
636       if (v == 0)
637         return;
638
639       if (v == 0xff)
640         hw = 0xc3c3;
641       else
642         hw = 0;
643
644       flash_program_halfword ((uint32_t)p, hw);
645     }
646 }
647
648 void
649 flash_cnt123_clear (const uint8_t **addr_p)
650 {
651   const uint8_t *p;
652
653   if ((p = *addr_p) == NULL)
654     return;
655
656   flash_program_halfword ((uint32_t)p, 0);
657   p -= 2;
658   flash_program_halfword ((uint32_t)p, 0);
659   *addr_p = NULL;
660 }
661
662
663 #if defined(CERTDO_SUPPORT)
664 int
665 flash_erase_binary (uint8_t file_id)
666 {
667   if (file_id == FILEID_CH_CERTIFICATE)
668     {
669       const uint8_t *p = &ch_certificate_start;
670       if (flash_check_blank (p, FLASH_CH_CERTIFICATE_SIZE) == 0)
671         {
672           flash_erase_page ((uint32_t)p);
673           if (FLASH_CH_CERTIFICATE_SIZE > flash_page_size)
674             flash_erase_page ((uint32_t)p + flash_page_size);
675         }
676
677       return 0;
678     }
679
680   return -1;
681 }
682 #endif
683
684
685 int
686 flash_write_binary (uint8_t file_id, const uint8_t *data,
687                     uint16_t len, uint16_t offset)
688 {
689   uint16_t maxsize;
690   const uint8_t *p;
691
692   if (file_id == FILEID_SERIAL_NO)
693     {
694       maxsize = 6;
695       p = &openpgpcard_aid[8];
696     }
697   else if (file_id >= FILEID_UPDATE_KEY_0 && file_id <= FILEID_UPDATE_KEY_3)
698     {
699       maxsize = FIRMWARE_UPDATE_KEY_CONTENT_LEN;
700       p = gpg_get_firmware_update_key (file_id - FILEID_UPDATE_KEY_0);
701       if (len == 0 && offset == 0)
702         { /* This means removal of update key.  */
703           if (flash_program_halfword ((uint32_t)p, 0) != 0)
704             flash_warning ("DO WRITE ERROR");
705           return 0;
706         }
707     }
708 #if defined(CERTDO_SUPPORT)
709   else if (file_id == FILEID_CH_CERTIFICATE)
710     {
711       maxsize = FLASH_CH_CERTIFICATE_SIZE;
712       p = &ch_certificate_start;
713     }
714 #endif
715   else
716     return -1;
717
718   if (offset + len > maxsize || (offset&1) || (len&1))
719     return -1;
720   else
721     {
722       uint16_t hw;
723       uint32_t addr;
724       int i;
725
726       if (flash_check_blank (p + offset, len)  == 0)
727         return -1;
728
729       addr = (uint32_t)p + offset;
730       for (i = 0; i < len/2; i++)
731         {
732           hw = data[i*2] | (data[i*2+1]<<8);
733           if (flash_program_halfword (addr, hw) != 0)
734             flash_warning ("DO WRITE ERROR");
735           addr += 2;
736         }
737
738       return 0;
739     }
740 }