383d64559d2888ab6ca4eeb19f025101836d80c3
[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
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 }