b12fcfb833de8ea8a32acb96f922c34bce26451a
[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 Free Software Initiative of Japan
5  * Author: NIIBE Yutaka <gniibe@fsij.org>
6  *
7  * This file is a part of Gnuk, a GnuPG USB Token implementation.
8  *
9  * Gnuk is free software: you can redistribute it and/or modify it
10  * under the terms of the GNU General Public License as published by
11  * the Free Software Foundation, either version 3 of the License, or
12  * (at your option) any later version.
13  *
14  * Gnuk is distributed in the hope that it will be useful, but WITHOUT
15  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
16  * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public
17  * License for more details.
18  *
19  * You should have received a copy of the GNU General Public License
20  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
21  *
22  */
23
24 /*
25  * We assume single DO size is less than 256.
26  *
27  * NOTE: "Card holder certificate" (which size is larger than 256) is
28  *       not put into data pool, but is implemented by its own flash
29  *       page(s).
30  */
31
32 #include "config.h"
33 #include "ch.h"
34 #include "hal.h"
35 #include "sys.h"
36 #include "gnuk.h"
37
38 /*
39  * Flash memory map
40  *
41  * _text
42  *         .text
43  *         .ctors
44  *         .dtors
45  * _etext
46  *         .data
47  * _bss_start
48  *         .bss
49  * _end 
50  *         <alignment to page>
51  * ch_certificate_startp
52  *         <2048 bytes>
53  * _data_pool
54  *         <two pages>
55  * _keystore_pool
56  *         1.5-KiB Key store (512-byte (p, q and N) key-store * 3)
57  */
58 #define FLASH_DATA_POOL_HEADER_SIZE     2
59 #define FLASH_DATA_POOL_SIZE            (FLASH_PAGE_SIZE*2)
60 #define FLASH_KEYSTORE_SIZE             (512*3)
61
62 static const uint8_t *data_pool;
63 extern uint8_t _keystore_pool;
64
65 static uint8_t *last_p;
66 static const uint8_t *keystore;
67
68 /* The first halfword is generation for the data page (little endian) */
69 const uint8_t const flash_data[4] __attribute__ ((section (".gnuk_data"))) = {
70   0x01, 0x00, 0xff, 0xff
71 };
72
73 /* Linker set this symbol */
74 extern uint8_t _data_pool;
75
76 const uint8_t *
77 flash_init (void)
78 {
79   const uint8_t *p;
80   uint16_t gen0, gen1;
81   uint16_t *gen0_p = (uint16_t *)&_data_pool;
82   uint16_t *gen1_p = (uint16_t *)(&_data_pool + FLASH_PAGE_SIZE);
83
84   /* Check data pool generation and choose the page */
85   gen0 = *gen0_p;
86   gen1 = *gen1_p;
87   if (gen0 == 0xffff)
88     data_pool = &_data_pool + FLASH_PAGE_SIZE;
89   else if (gen1 == 0xffff)
90     data_pool = &_data_pool;
91   else if (gen1 > gen0)
92     data_pool = &_data_pool + FLASH_PAGE_SIZE;
93   else
94     data_pool = &_data_pool;
95
96   /* Seek empty keystore */
97   p = &_keystore_pool;
98   while (*p != 0xff || *(p+1) != 0xff)
99     p += 512;
100
101   keystore = p;
102
103   return data_pool + FLASH_DATA_POOL_HEADER_SIZE;
104 }
105
106 /*
107  * Flash data pool managenent
108  *
109  * Flash data pool consists of two parts:
110  *   2-byte header
111  *   contents
112  *
113  * Flash data pool objects:
114  *   Data Object (DO) (of smart card)
115  *   Internal objects:
116  *     NONE (0x0000)
117  *     123-counter
118  *     14-bit counter
119  *     bool object
120  *
121  * Format of a Data Object:
122  *    NR:   8-bit tag_number
123  *    LEN:  8-bit length
124  *    DATA: data * LEN
125  *    PAD:  optional byte for 16-bit alignment
126  */
127
128 void
129 flash_set_data_pool_last (const uint8_t *p)
130 {
131   last_p = (uint8_t *)p;
132 }
133
134 /*
135  * We use two pages
136  */
137 static int
138 flash_copying_gc (void)
139 {
140   uint8_t *src, *dst;
141   uint16_t generation;
142
143   if (data_pool == &_data_pool)
144     {
145       src = &_data_pool;
146       dst = &_data_pool + FLASH_PAGE_SIZE;
147     }
148   else
149     {
150       src = &_data_pool + FLASH_PAGE_SIZE;
151       dst = &_data_pool;
152     }
153
154   generation = *(uint16_t *)src;
155   data_pool = dst;
156   gpg_data_copy (data_pool + FLASH_DATA_POOL_HEADER_SIZE);
157   flash_erase_page ((uint32_t)src);
158   flash_program_halfword ((uint32_t)dst, generation+1);
159   return 0;
160 }
161
162 static int
163 is_data_pool_full (size_t size)
164 {
165   return last_p + size > data_pool + FLASH_PAGE_SIZE;
166 }
167
168 static uint8_t *
169 flash_data_pool_allocate (size_t size)
170 {
171   uint8_t *p;
172
173   size = (size + 1) & ~1;       /* allocation unit is 1-halfword (2-byte) */
174
175   if (is_data_pool_full (size))
176     if (flash_copying_gc () < 0 || /*still*/ is_data_pool_full (size))
177       fatal (FATAL_FLASH);
178
179   p = last_p;
180   last_p += size;
181   return p;
182 }
183
184 void
185 flash_do_write_internal (const uint8_t *p, int nr, const uint8_t *data, int len)
186 {
187   uint16_t hw;
188   uint32_t addr;
189   int i;
190
191   addr = (uint32_t)p;
192   hw = nr | (len << 8);
193   if (flash_program_halfword (addr, hw) != 0)
194     flash_warning ("DO WRITE ERROR");
195   addr += 2;
196
197   for (i = 0; i < len/2; i++)
198     {
199       hw = data[i*2] | (data[i*2+1]<<8);
200       if (flash_program_halfword (addr, hw) != 0)
201         flash_warning ("DO WRITE ERROR");
202       addr += 2;
203     }
204
205   if ((len & 1))
206     {
207       hw = data[i*2] | 0xff00;
208       if (flash_program_halfword (addr, hw) != 0)
209         flash_warning ("DO WRITE ERROR");
210     }
211 }
212
213 const uint8_t *
214 flash_do_write (uint8_t nr, const uint8_t *data, int len)
215 {
216   const uint8_t *p;
217
218   DEBUG_INFO ("flash DO\r\n");
219
220   p = flash_data_pool_allocate (2 + len);
221   if (p == NULL)
222     {
223       DEBUG_INFO ("flash data pool allocation failure.\r\n");
224       return NULL;
225     }
226
227   flash_do_write_internal (p, nr, data, len);
228   DEBUG_INFO ("flash DO...done\r\n");
229   return p + 1;
230 }
231
232 void
233 flash_warning (const char *msg)
234 {
235   (void)msg;
236   DEBUG_INFO ("FLASH: ");
237   DEBUG_INFO (msg);
238   DEBUG_INFO ("\r\n");
239 }
240
241 void
242 flash_do_release (const uint8_t *do_data)
243 {
244   uint32_t addr = (uint32_t)do_data - 1;
245   uint32_t addr_tag = addr;
246   int i;
247   int len = do_data[0];
248
249   /* Don't filling zero for data in code (such as ds_count_initial_value) */
250   if (do_data < &_data_pool || do_data > &_data_pool + FLASH_DATA_POOL_SIZE)
251     return;
252
253   addr += 2;
254
255   /* Fill zero for content and pad */
256   for (i = 0; i < len/2; i ++)
257     {
258       if (flash_program_halfword (addr, 0) != 0)
259         flash_warning ("fill-zero failure");
260       addr += 2;
261     }
262
263   if ((len & 1))
264     {
265       if (flash_program_halfword (addr, 0) != 0)
266         flash_warning ("fill-zero pad failure");
267     }
268
269   /* Fill 0x0000 for "tag_number and length" word */
270   if (flash_program_halfword (addr_tag, 0) != 0)
271     flash_warning ("fill-zero tag_nr failure");
272 }
273
274 uint8_t *
275 flash_key_alloc (void)
276 {
277   uint8_t *k = (uint8_t *)keystore;
278
279   if ((k - &_keystore_pool) >= FLASH_KEYSTORE_SIZE)
280     return NULL;
281
282   keystore += 512;
283   return k;
284 }
285
286 int
287 flash_key_write (uint8_t *key_addr, const uint8_t *key_data,
288                  const uint8_t *modulus)
289 {
290   uint16_t hw;
291   uint32_t addr;
292   int i;
293
294   addr = (uint32_t)key_addr;
295   for (i = 0; i < KEY_CONTENT_LEN/2; i ++)
296     {
297       hw = key_data[i*2] | (key_data[i*2+1]<<8);
298       if (flash_program_halfword (addr, hw) != 0)
299         return -1;
300       addr += 2;
301     }
302
303   for (i = 0; i < KEY_CONTENT_LEN/2; i ++)
304     {
305       hw = modulus[i*2] | (modulus[i*2+1]<<8);
306       if (flash_program_halfword (addr, hw) != 0)
307         return -1;
308       addr += 2;
309     }
310
311   return 0;
312 }
313
314 void
315 flash_keystore_release (void)
316 {
317   flash_erase_page ((uint32_t)&_keystore_pool);
318 #if FLASH_KEYSTORE_SIZE > FLASH_PAGE_SIZE
319   flash_erase_page ((uint32_t)&_keystore_pool + FLASH_PAGE_SIZE);
320 #endif
321   keystore = &_keystore_pool;
322 }
323
324 void
325 flash_clear_halfword (uint32_t addr)
326 {
327   flash_program_halfword (addr, 0);
328 }
329
330
331 void
332 flash_put_data_internal (const uint8_t *p, uint16_t hw)
333 {
334   flash_program_halfword ((uint32_t)p, hw);
335 }
336
337 void
338 flash_put_data (uint16_t hw)
339 {
340   uint8_t *p;
341
342   p = flash_data_pool_allocate (2);
343   if (p == NULL)
344     {
345       DEBUG_INFO ("data allocation failure.\r\n");
346     }
347
348   flash_program_halfword ((uint32_t)p, hw);
349 }
350
351
352 void
353 flash_bool_clear (const uint8_t **addr_p)
354 {
355   const uint8_t *p;
356
357   if ((p = *addr_p) == NULL)
358     return;
359
360   flash_program_halfword ((uint32_t)p, 0);
361   *addr_p = NULL;
362 }
363
364 void
365 flash_bool_write_internal (const uint8_t *p, int nr)
366 {
367   flash_program_halfword ((uint32_t)p, nr);
368 }
369
370 const uint8_t *
371 flash_bool_write (uint8_t nr)
372 {
373   uint8_t *p;
374   uint16_t hw = nr;
375
376   p = flash_data_pool_allocate (2);
377   if (p == NULL)
378     {
379       DEBUG_INFO ("bool allocation failure.\r\n");
380       return NULL;
381     }
382
383   flash_program_halfword ((uint32_t)p, hw);
384   return p;
385 }
386
387
388 int
389 flash_cnt123_get_value (const uint8_t *p)
390 {
391   if (p == NULL)
392     return 0;
393   else
394     {
395       uint8_t v = *p;
396
397       /*
398        * After erase, a halfword in flash memory becomes 0xffff.
399        * The halfword can be programmed to any value.
400        * Then, the halfword can be programmed to zero.
401        *
402        * Thus, we can represent value 1, 2, and 3.
403        */
404       if (v == 0xff)
405         return 1;
406       else if (v == 0x00)
407         return 3;
408       else
409         return 2;
410     }
411 }
412
413 void
414 flash_cnt123_write_internal (const uint8_t *p, int which, int v)
415 {
416   uint16_t hw;
417
418   hw = NR_COUNTER_123 | (which << 8);
419   flash_program_halfword ((uint32_t)p, hw);
420
421   if (v == 1)
422     return;
423   else if (v == 2)
424     flash_program_halfword ((uint32_t)p+2, 0xc3c3);
425   else                          /* v == 3 */
426     flash_program_halfword ((uint32_t)p+2, 0);
427 }
428
429 void
430 flash_cnt123_increment (uint8_t which, const uint8_t **addr_p)
431 {
432   const uint8_t *p;
433   uint16_t hw;
434
435   if ((p = *addr_p) == NULL)
436     {
437       p = flash_data_pool_allocate (4);
438       if (p == NULL)
439         {
440           DEBUG_INFO ("cnt123 allocation failure.\r\n");
441           return;
442         }
443       hw = NR_COUNTER_123 | (which << 8);
444       flash_program_halfword ((uint32_t)p, hw);
445       *addr_p = p + 2;
446     }
447   else
448     {
449       uint8_t v = *p;
450
451       if (v == 0)
452         return;
453
454       if (v == 0xff)
455         hw = 0xc3c3;
456       else
457         hw = 0;
458
459       flash_program_halfword ((uint32_t)p, hw);
460     }
461 }
462
463 void
464 flash_cnt123_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   p -= 2;
473   flash_program_halfword ((uint32_t)p, 0);
474   *addr_p = NULL;
475 }
476
477
478 #if defined(CERTDO_SUPPORT)
479 #define FLASH_CH_CERTIFICATE_SIZE 2048
480 int
481 flash_erase_binary (uint8_t file_id)
482 {
483   if (file_id == FILEID_CH_CERTIFICATE)
484     {
485       const uint8_t *p = &ch_certificate_start;
486       if (flash_check_blank (p, FLASH_CH_CERTIFICATE_SIZE) == 0)
487         {
488           flash_erase_page ((uint32_t)p);
489 #if FLASH_CH_CERTIFICATE_SIZE > FLASH_PAGE_SIZE
490           flash_erase_page ((uint32_t)p + FLASH_PAGE_SIZE);
491 #endif
492         }
493
494       return 0;
495     }
496
497   return -1;
498 }
499 #endif
500
501
502 int
503 flash_write_binary (uint8_t file_id, const uint8_t *data,
504                     uint16_t len, uint16_t offset)
505 {
506   uint16_t maxsize;
507   const uint8_t *p;
508
509   if (file_id == FILEID_SERIAL_NO)
510     {
511       maxsize = 6;
512       p = &openpgpcard_aid[8];
513     }
514   else if (file_id >= FILEID_UPDATE_KEY_0 && file_id <= FILEID_UPDATE_KEY_3)
515     {
516       maxsize = KEY_CONTENT_LEN;
517       p = gpg_get_firmware_update_key (file_id - FILEID_UPDATE_KEY_0);
518     }
519 #if defined(CERTDO_SUPPORT)
520   else if (file_id == FILEID_CH_CERTIFICATE)
521     {
522       maxsize = FLASH_CH_CERTIFICATE_SIZE;
523       p = &ch_certificate_start;
524     }
525 #endif
526   else
527     return -1;
528
529   if (offset + len > maxsize || (offset&1) || (len&1))
530     return -1;
531   else
532     {
533       uint16_t hw;
534       uint32_t addr;
535       int i;
536
537       if (flash_check_blank (p, len)  == 0)
538         return -1;
539
540       addr = (uint32_t)p + offset;
541       for (i = 0; i < len/2; i++)
542         {
543           hw = data[i*2] | (data[i*2+1]<<8);
544           if (flash_program_halfword (addr, hw) != 0)
545             flash_warning ("DO WRITE ERROR");
546           addr += 2;
547         }
548
549       return 0;
550     }
551 }