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