keygen is configure option
[gnuk/gnuk.git] / src / openpgp-do.c
1 /*
2  * openpgp-do.c -- OpenPGP card Data Objects (DO) handling
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 #include <stdlib.h>
25
26 #include "config.h"
27 #include "ch.h"
28 #include "sys.h"
29 #include "gnuk.h"
30 #include "openpgp.h"
31
32 #include "polarssl/config.h"
33 #include "polarssl/aes.h"
34 #include "polarssl/sha1.h"
35
36 #define PASSWORD_ERRORS_MAX 3   /* >= errors, it will be locked */
37 static const uint8_t *pw_err_counter_p[3];
38
39 static int
40 gpg_pw_get_err_counter (uint8_t which)
41 {
42   return flash_cnt123_get_value (pw_err_counter_p[which]);
43 }
44
45 int
46 gpg_pw_locked (uint8_t which)
47 {
48   if (gpg_pw_get_err_counter (which) >= PASSWORD_ERRORS_MAX)
49     return 1;
50   else
51     return 0;
52 }
53
54 void
55 gpg_pw_reset_err_counter (uint8_t which)
56 {
57   flash_cnt123_clear (&pw_err_counter_p[which]);
58   if (pw_err_counter_p[which] != NULL)
59     GPG_MEMORY_FAILURE ();
60 }
61
62 void
63 gpg_pw_increment_err_counter (uint8_t which)
64 {
65   flash_cnt123_increment (which, &pw_err_counter_p[which]);
66 }
67
68
69 uint16_t data_objects_number_of_bytes;
70
71 /*
72  * Compile time vars:
73  *   Historical Bytes (template), Extended Capabilities,
74  *   and Algorithm Attributes
75  */
76
77 /* Historical Bytes (template) */
78 static const uint8_t historical_bytes[] __attribute__ ((aligned (1))) = {
79   10,
80   0x00,
81   0x31, 0x84,                   /* Full DF name, GET DATA, MF */
82   0x73,
83   0x80, 0x01, 0x80,             /* Full DF name */
84                                 /* 1-byte */
85                                 /* Command chaining, No extended Lc and Le */
86   0x00, 0x90, 0x00              /* Status info (no life cycle management) */
87 };
88
89 /* Extended Capabilities */
90 static const uint8_t extended_capabilities[] __attribute__ ((aligned (1))) = {
91   10,
92   0x30,                         /*
93                                  * No SM,
94                                  * No get challenge,
95                                  * Key import supported,
96                                  * PW status byte can be put,
97                                  * No private_use_DO,
98                                  * No algo change allowed
99                                  */
100   0,              /* Secure Messaging Algorithm: N/A (TDES=0, AES=1) */
101   0x00, 0x00,     /* Max get challenge (0: Get challenge not supported) */
102 #ifdef CERTDO_SUPPORT
103   0x08, 0x00,     /* max. length of cardholder certificate (2KiB) */
104 #else
105   0x00, 0x00,
106 #endif
107   /* Max. length of command APDU data */
108   0x00, 0xff,
109   /* Max. length of response APDU data */
110   0x01, 0x00,
111 };
112
113 /* Algorithm Attributes */
114 static const uint8_t algorithm_attr[] __attribute__ ((aligned (1))) = {
115   6,
116   0x01, /* RSA */
117   0x08, 0x00,         /* Length modulus (in bit): 2048 */
118   0x00, 0x20,         /* Length exponent (in bit): 32  */
119   0x00                /* 0: p&q , 3: CRT with N (not yet supported) */
120 };
121
122 #define PW_LEN_MAX 127
123 /*
124  * Representation of PW1_LIFETIME:
125  *    0: PW1_LIEFTIME_P == NULL : PW1 is valid for single PSO:CDS command
126  *    1: PW1_LIEFTIME_P != NULL : PW1 is valid for several PSO:CDS commands
127  *
128  * The address in the variable PW1_LIEFTIME_P is used when filling zero
129  * in flash memory
130  */
131 static const uint8_t *pw1_lifetime_p;
132
133 static int
134 gpg_get_pw1_lifetime (void)
135 {
136   if (pw1_lifetime_p == NULL)
137     return 0;
138   else
139     return 1;
140 }
141
142
143 static uint32_t digital_signature_counter;
144
145 static const uint8_t *
146 gpg_write_digital_signature_counter (const uint8_t *p, uint32_t dsc)
147 {
148   uint16_t hw0, hw1;
149
150   if ((dsc >> 10) == 0)
151     { /* no upper bits */
152       hw1 = NR_COUNTER_DS_LSB | ((dsc & 0x0300) >> 8) | ((dsc & 0x00ff) << 8);
153       flash_put_data_internal (p, hw1);
154       return p+2;
155     }
156   else
157     {
158       hw0 = NR_COUNTER_DS | ((dsc & 0xfc0000) >> 18) | ((dsc & 0x03fc00) >> 2);
159       hw1 = NR_COUNTER_DS_LSB;
160       flash_put_data_internal (p, hw0);
161       flash_put_data_internal (p+2, hw1);
162       return p+4;
163     }
164 }
165
166 static void
167 gpg_reset_digital_signature_counter (void)
168 {
169   if (digital_signature_counter != 0)
170     {
171       flash_put_data (NR_COUNTER_DS);
172       flash_put_data (NR_COUNTER_DS_LSB);
173       digital_signature_counter = 0;
174     }
175 }
176
177 void
178 gpg_increment_digital_signature_counter (void)
179 {
180   uint16_t hw0, hw1;
181   uint32_t dsc = (digital_signature_counter + 1) & 0x00ffffff;
182
183   if ((dsc & 0x03ff) == 0)
184     { /* carry occurs from l10 to h14 */
185       hw0 = NR_COUNTER_DS | ((dsc & 0xfc0000) >> 18) | ((dsc & 0x03fc00) >> 2);
186       hw1 = NR_COUNTER_DS_LSB;  /* zero */
187       flash_put_data (hw0);
188       flash_put_data (hw1);
189     }
190   else
191     {
192       hw1 = NR_COUNTER_DS_LSB | ((dsc & 0x0300) >> 8) | ((dsc & 0x00ff) << 8);
193       flash_put_data (hw1);
194     }
195
196   digital_signature_counter = dsc;
197
198   if (gpg_get_pw1_lifetime () == 0)
199     ac_reset_pso_cds ();
200 }
201
202
203 #define SIZE_FINGER_PRINT 20
204 #define SIZE_KEYGEN_TIME 4      /* RFC4880 */
205
206 enum do_type {
207   DO_FIXED,
208   DO_VAR,
209   DO_CMP_READ,
210   DO_PROC_READ,
211   DO_PROC_WRITE,
212   DO_PROC_READWRITE,
213 };
214
215 struct do_table_entry {
216   uint16_t tag;
217   enum do_type do_type;
218   uint8_t ac_read;
219   uint8_t ac_write;
220   const void *obj;
221 };
222
223 static uint8_t *res_p;
224
225 static void copy_do_1 (uint16_t tag, const uint8_t *do_data, int with_tag);
226 static const struct do_table_entry *get_do_entry (uint16_t tag);
227
228 #define GPG_DO_AID              0x004f
229 #define GPG_DO_NAME             0x005b
230 #define GPG_DO_LOGIN_DATA       0x005e
231 #define GPG_DO_CH_DATA          0x0065
232 #define GPG_DO_APP_DATA         0x006e
233 /* XXX: 0x0073 ??? */
234 #define GPG_DO_SS_TEMP          0x007a
235 #define GPG_DO_DS_COUNT         0x0093
236 #define GPG_DO_EXTCAP           0x00c0
237 #define GPG_DO_ALG_SIG          0x00c1
238 #define GPG_DO_ALG_DEC          0x00c2
239 #define GPG_DO_ALG_AUT          0x00c3
240 #define GPG_DO_PW_STATUS        0x00c4
241 #define GPG_DO_FP_ALL           0x00c5
242 #define GPG_DO_CAFP_ALL         0x00c6
243 #define GPG_DO_FP_SIG           0x00c7
244 #define GPG_DO_FP_DEC           0x00c8
245 #define GPG_DO_FP_AUT           0x00c9
246 #define GPG_DO_CAFP_1           0x00ca
247 #define GPG_DO_CAFP_2           0x00cb
248 #define GPG_DO_CAFP_3           0x00cc
249 #define GPG_DO_KGTIME_ALL       0x00cd
250 #define GPG_DO_KGTIME_SIG       0x00ce
251 #define GPG_DO_KGTIME_DEC       0x00cf
252 #define GPG_DO_KGTIME_AUT       0x00d0
253 #define GPG_DO_RESETTING_CODE   0x00d3
254 #define GPG_DO_KEY_IMPORT       0x3fff
255 #define GPG_DO_LANGUAGE         0x5f2d
256 #define GPG_DO_SEX              0x5f35
257 #define GPG_DO_URL              0x5f50
258 #define GPG_DO_HIST_BYTES       0x5f52
259 #define GPG_DO_CH_CERTIFICATE   0x7f21
260
261 static const uint8_t *do_ptr[NR_DO__LAST__];
262
263 static uint8_t
264 do_tag_to_nr (uint16_t tag)
265 {
266   switch (tag)
267     {
268     case GPG_DO_SEX:
269       return NR_DO_SEX;
270     case GPG_DO_FP_SIG:
271       return NR_DO_FP_SIG;
272     case GPG_DO_FP_DEC:
273       return NR_DO_FP_DEC;
274     case GPG_DO_FP_AUT:
275       return NR_DO_FP_AUT;
276     case GPG_DO_CAFP_1:
277       return NR_DO_CAFP_1;
278     case GPG_DO_CAFP_2:
279       return NR_DO_CAFP_2;
280     case GPG_DO_CAFP_3:
281       return NR_DO_CAFP_3;
282     case GPG_DO_KGTIME_SIG:
283       return NR_DO_KGTIME_SIG;
284     case GPG_DO_KGTIME_DEC:
285       return NR_DO_KGTIME_DEC;
286     case GPG_DO_KGTIME_AUT:
287       return NR_DO_KGTIME_AUT;
288     case GPG_DO_LOGIN_DATA:
289       return NR_DO_LOGIN_DATA;
290     case GPG_DO_URL:
291       return NR_DO_URL;
292     case GPG_DO_NAME:
293       return NR_DO_NAME;
294     case GPG_DO_LANGUAGE:
295       return NR_DO_LANGUAGE;
296     default:
297       return NR_NONE;
298     }
299 }
300
301 static void
302 copy_tag (uint16_t tag)
303 {
304   if (tag < 0x0100)
305     *res_p++ = (tag & 0xff);
306   else
307     {
308       *res_p++ = (tag >> 8);
309       *res_p++ = (tag & 0xff);
310     }
311 }
312
313 static int
314 do_hist_bytes (uint16_t tag, int with_tag)
315 {
316   /* XXX: For now, no life cycle management, just return template as is. */
317   /* XXX: Supporing TERMINATE DF / ACTIVATE FILE, we need to fix here */
318   copy_do_1 (tag, historical_bytes, with_tag);
319   return 1;
320 }
321
322 #define SIZE_FP 20
323 #define SIZE_KGTIME 4
324
325 static int
326 do_fp_all (uint16_t tag, int with_tag)
327 {
328   const uint8_t *data;
329
330   if (with_tag)
331     {
332       copy_tag (tag);
333       *res_p++ = SIZE_FP*3;
334     }
335
336   data = gpg_do_read_simple (NR_DO_FP_SIG);
337   if (data)
338     memcpy (res_p, data, SIZE_FP);
339   else
340     memset (res_p, 0, SIZE_FP);
341   res_p += SIZE_FP;
342
343   data = gpg_do_read_simple (NR_DO_FP_DEC);
344   if (data)
345     memcpy (res_p, data, SIZE_FP);
346   else
347     memset (res_p, 0, SIZE_FP);
348   res_p += SIZE_FP;
349
350   data = gpg_do_read_simple (NR_DO_FP_AUT);
351   if (data)
352     memcpy (res_p, data, SIZE_FP);
353   else
354     memset (res_p, 0, SIZE_FP);
355   res_p += SIZE_FP;
356   return 1;
357 }
358
359 static int
360 do_cafp_all (uint16_t tag, int with_tag)
361 {
362   const uint8_t *data;
363
364   if (with_tag)
365     {
366       copy_tag (tag);
367       *res_p++ = SIZE_FP*3;
368     }
369
370   data = gpg_do_read_simple (NR_DO_CAFP_1);
371   if (data)
372     memcpy (res_p, data, SIZE_FP);
373   else
374     memset (res_p, 0, SIZE_FP);
375   res_p += SIZE_FP;
376
377   data = gpg_do_read_simple (NR_DO_CAFP_2);
378   if (data)
379     memcpy (res_p, data, SIZE_FP);
380   else
381     memset (res_p, 0, SIZE_FP);
382   res_p += SIZE_FP;
383
384   data = gpg_do_read_simple (NR_DO_CAFP_2);
385   if (data)
386     memcpy (res_p, data, SIZE_FP);
387   else
388     memset (res_p, 0, SIZE_FP);
389   res_p += SIZE_FP;
390   return 1;
391 }
392
393 static int
394 do_kgtime_all (uint16_t tag, int with_tag)
395 {
396   const uint8_t *data;
397
398   if (with_tag)
399     {
400       copy_tag (tag);
401       *res_p++ = SIZE_KGTIME*3;
402     }
403
404   data = gpg_do_read_simple (NR_DO_KGTIME_SIG);
405   if (data)
406     memcpy (res_p, data, SIZE_KGTIME);
407   else
408     memset (res_p, 0, SIZE_KGTIME);
409   res_p += SIZE_KGTIME;
410
411   data = gpg_do_read_simple (NR_DO_KGTIME_DEC);
412   if (data)
413     memcpy (res_p, data, SIZE_KGTIME);
414   else
415     memset (res_p, 0, SIZE_KGTIME);
416   res_p += SIZE_KGTIME;
417
418   data = gpg_do_read_simple (NR_DO_KGTIME_AUT);
419   if (data)
420     memcpy (res_p, data, SIZE_KGTIME);
421   else
422     memset (res_p, 0, SIZE_KGTIME);
423   res_p += SIZE_KGTIME;
424   return 1;
425 }
426
427 const uint8_t openpgpcard_aid[] = {
428   0xd2, 0x76,               /* D: National, 276: DEU ISO 3166-1 */
429   0x00, 0x01, 0x24,         /* Registered Application Provider Identifier */
430   0x01,                     /* Application: OpenPGPcard */
431   0x02, 0x00,               /* Version 2.0 */
432   /* v. id */ /*   serial number   */
433   0xff, 0xff, 0xff, 0xff,  0xff, 0xff, /* To be overwritten */
434 };
435
436 static int
437 do_openpgpcard_aid (uint16_t tag, int with_tag)
438 {
439   uint16_t vid = *((const volatile uint16_t *)&openpgpcard_aid[8]);
440
441   if (with_tag)
442     {
443       copy_tag (tag);
444       *res_p++ = 16;
445     }
446
447   if (vid == 0xffff || vid == 0x0000)
448     {
449       const uint8_t *u = unique_device_id ();
450
451       memcpy (res_p, openpgpcard_aid, 8);
452       res_p += 8;
453
454       /* vid == 0xfffe: serial number is random byte */
455       *res_p++ = 0xff;
456       *res_p++ = 0xfe;
457       memcpy (res_p, u, 4);
458       res_p += 4;
459     }
460   else
461     {
462       memcpy (res_p, openpgpcard_aid, 14);
463       res_p += 14;
464     }
465
466   *res_p++ = 0;
467   *res_p++ = 0;
468
469   return 1;
470 }
471
472 static int
473 do_ds_count (uint16_t tag, int with_tag)
474 {
475   if (with_tag)
476     {
477       copy_tag (tag);
478       *res_p++ = 3;
479     }
480
481   *res_p++ = (digital_signature_counter >> 16) & 0xff;
482   *res_p++ = (digital_signature_counter >> 8) & 0xff;
483   *res_p++ = digital_signature_counter & 0xff;
484   return 1;
485 }
486
487 static int
488 rw_pw_status (uint16_t tag, int with_tag,
489               const uint8_t *data, int len, int is_write)
490 {
491   if (is_write)
492     {
493       (void)len;                /* Should be SIZE_PW_STATUS_BYTES */
494
495       /* Only the first byte of DATA is checked */
496       if (data[0] == 0)
497         {
498           flash_bool_clear (&pw1_lifetime_p);
499           if (pw1_lifetime_p == NULL)
500             return 1;
501           else
502             return 0;
503         }
504       else
505         {
506           pw1_lifetime_p = flash_bool_write (NR_BOOL_PW1_LIFETIME);
507           if (pw1_lifetime_p != NULL)
508             return 1;
509           else
510             return 0;
511         }
512     }
513   else
514     {
515       if (with_tag)
516         {
517           copy_tag (tag);
518           *res_p++ = SIZE_PW_STATUS_BYTES;
519         }
520
521       *res_p++ = gpg_get_pw1_lifetime ();
522       *res_p++ = PW_LEN_MAX;
523       *res_p++ = PW_LEN_MAX;
524       *res_p++ = PW_LEN_MAX;
525       *res_p++ = PASSWORD_ERRORS_MAX - gpg_pw_get_err_counter (PW_ERR_PW1);
526       *res_p++ = PASSWORD_ERRORS_MAX - gpg_pw_get_err_counter (PW_ERR_RC);
527       *res_p++ = PASSWORD_ERRORS_MAX - gpg_pw_get_err_counter (PW_ERR_PW3);
528       return 1;
529     }
530 }
531
532 static int
533 proc_resetting_code (const uint8_t *data, int len)
534 {
535   const uint8_t *old_ks = keystring_md_pw3;
536   uint8_t new_ks0[KEYSTRING_MD_SIZE+1];
537   uint8_t *new_ks = &new_ks0[1];
538   const uint8_t *newpw;
539   int newpw_len;
540   int r;
541
542   DEBUG_INFO ("Resetting Code!\r\n");
543
544   newpw_len = len;
545   newpw = data;
546   sha1 (newpw, newpw_len, new_ks);
547   new_ks0[0] = newpw_len;
548   r = gpg_change_keystring (admin_authorized, old_ks, BY_RESETCODE, new_ks);
549   if (r <= -2)
550     {
551       DEBUG_INFO ("memory error.\r\n");
552       return 0;
553     }
554   else if (r < 0)
555     {
556       DEBUG_INFO ("security error.\r\n");
557       return 0;
558     }
559   else if (r == 0)
560     {
561       DEBUG_INFO ("done (no prvkey).\r\n");
562       gpg_do_write_simple (NR_DO_KEYSTRING_RC, new_ks0, KEYSTRING_SIZE_RC);
563     }
564   else
565     {
566       DEBUG_INFO ("done.\r\n");
567       gpg_do_write_simple (NR_DO_KEYSTRING_RC, new_ks0, 1);
568     }
569
570   gpg_pw_reset_err_counter (PW_ERR_RC);
571   return 1;
572 }
573
574 static void
575 encrypt (const uint8_t *key_str, uint8_t *data, int len)
576 {
577   aes_context aes;
578   uint8_t iv[16];
579   int iv_offset;
580
581   DEBUG_INFO ("ENC\r\n");
582   DEBUG_BINARY (data, len);
583
584   aes_setkey_enc (&aes, key_str, 128);
585   memset (iv, 0, 16);
586   iv_offset = 0;
587   aes_crypt_cfb128 (&aes, AES_ENCRYPT, len, &iv_offset, iv, data, data);
588 }
589
590 /* Signing, Decryption, and Authentication */
591 struct key_data kd[3];
592
593 static void
594 decrypt (const uint8_t *key_str, uint8_t *data, int len)
595 {
596   aes_context aes;
597   uint8_t iv[16];
598   int iv_offset;
599
600   aes_setkey_enc (&aes, key_str, 128);
601   memset (iv, 0, 16);
602   iv_offset = 0;
603   aes_crypt_cfb128 (&aes, AES_DECRYPT, len, &iv_offset, iv, data, data);
604
605   DEBUG_INFO ("DEC\r\n");
606   DEBUG_BINARY (data, len);
607 }
608
609 static uint8_t
610 get_do_ptr_nr_for_kk (enum kind_of_key kk)
611 {
612   switch (kk)
613     {
614     case GPG_KEY_FOR_SIGNING:
615       return NR_DO_PRVKEY_SIG;
616     case GPG_KEY_FOR_DECRYPTION:
617       return NR_DO_PRVKEY_DEC;
618     case GPG_KEY_FOR_AUTHENTICATION:
619       return NR_DO_PRVKEY_AUT;
620     }
621   return NR_DO_PRVKEY_SIG;
622 }
623
624 void
625 gpg_do_clear_prvkey (enum kind_of_key kk)
626 {
627   memset ((void *)&kd[kk], 0, sizeof (struct key_data));
628 }
629
630 /*
631  * Return  1 on success,
632  *         0 if none,
633  *        -1 on error,
634  */
635 int
636 gpg_do_load_prvkey (enum kind_of_key kk, int who, const uint8_t *keystring)
637 {
638   uint8_t nr = get_do_ptr_nr_for_kk (kk);
639   const uint8_t *do_data = do_ptr[nr - NR_DO__FIRST__];
640   uint8_t *key_addr;
641   uint8_t dek[DATA_ENCRYPTION_KEY_SIZE];
642   struct key_data_internal kdi;
643
644   DEBUG_INFO ("Loading private key: ");
645   DEBUG_BYTE (kk);
646
647   if (do_data == NULL)
648     return 0;
649
650   key_addr = *(uint8_t **)&(do_data)[1];
651   memcpy (kdi.data, key_addr, KEY_CONTENT_LEN);
652   memcpy (((uint8_t *)&kdi.check), do_data+5, ADDITIONAL_DATA_SIZE);
653
654   memcpy (dek, do_data+5+16*who, DATA_ENCRYPTION_KEY_SIZE);
655   decrypt (keystring, dek, DATA_ENCRYPTION_KEY_SIZE);
656
657   decrypt (dek, (uint8_t *)&kdi, sizeof (struct key_data_internal));
658   if (memcmp (kdi.magic, GNUK_MAGIC, KEY_MAGIC_LEN) != 0)
659     {
660       DEBUG_INFO ("gpg_do_load_prvkey failed.\r\n");
661       return -1;
662     }
663   /* more sanity check??? */
664
665   memcpy (kd[kk].data, kdi.data, KEY_CONTENT_LEN);
666   DEBUG_BINARY (&kd[kk], KEY_CONTENT_LEN);
667   return 1;
668 }
669
670 static uint32_t
671 calc_check32 (const uint8_t *p, int len)
672 {
673   uint32_t check = 0;
674   uint32_t *data = (uint32_t *)p;
675   int i;
676
677   for (i = 0; i < len/4; i++)
678     check += data[i];
679
680   return check;
681 }
682
683 static int8_t num_prv_keys;
684
685 static int
686 gpg_do_write_prvkey (enum kind_of_key kk, const uint8_t *key_data, int key_len,
687                      const uint8_t *keystring_admin, const uint8_t *modulus)
688 {
689   uint8_t nr = get_do_ptr_nr_for_kk (kk);
690   const uint8_t *p;
691   int r;
692   struct prvkey_data *pd;
693   uint8_t *key_addr;
694   const uint8_t *dek;
695   const uint8_t *do_data = do_ptr[nr - NR_DO__FIRST__];
696   const uint8_t *ks_pw1;
697   const uint8_t *ks_rc;
698   struct key_data_internal kdi;
699   int modulus_allocated_here = 0;
700
701   DEBUG_INFO ("Key import\r\n");
702   DEBUG_SHORT (key_len);
703
704   if (do_data)
705     /* No replace support, you need to remove it first.  */
706     return -1;
707
708   if (key_len != KEY_CONTENT_LEN)
709     return -1;
710
711   pd = (struct prvkey_data *)malloc (sizeof (struct prvkey_data));
712   if (pd == NULL)
713     return -1;
714
715   if (modulus == NULL)
716     {
717       modulus = modulus_calc (key_data, key_len);
718       if (modulus == NULL)
719         {
720           free (pd);
721           return -1;
722         }
723
724       modulus_allocated_here = 1;
725     }
726
727   DEBUG_INFO ("Getting keystore address...\r\n");
728   key_addr = flash_key_alloc ();
729   if (key_addr == NULL)
730     {
731       free (pd);
732       if (modulus_allocated_here)
733         modulus_free (modulus);
734       return -1;
735     }
736
737   DEBUG_INFO ("key_addr: ");
738   DEBUG_WORD ((uint32_t)key_addr);
739
740   memcpy (kdi.data, key_data, KEY_CONTENT_LEN);
741   kdi.check = calc_check32 (key_data, KEY_CONTENT_LEN);
742   kdi.random = get_salt ();
743   memcpy (kdi.magic, GNUK_MAGIC, KEY_MAGIC_LEN);
744
745   dek = random_bytes_get (); /* 16-byte random bytes */
746   memcpy (pd->dek_encrypted_1, dek, DATA_ENCRYPTION_KEY_SIZE);
747   memcpy (pd->dek_encrypted_2, dek, DATA_ENCRYPTION_KEY_SIZE);
748   memcpy (pd->dek_encrypted_3, dek, DATA_ENCRYPTION_KEY_SIZE);
749   ks_pw1 = gpg_do_read_simple (NR_DO_KEYSTRING_PW1);
750   ks_rc = gpg_do_read_simple (NR_DO_KEYSTRING_RC);
751
752   encrypt (dek, (uint8_t *)&kdi, sizeof (struct key_data_internal));
753
754   r = flash_key_write (key_addr, kdi.data, modulus);
755   if (modulus_allocated_here)
756     modulus_free (modulus);
757
758   if (r < 0)
759     {
760       random_bytes_free (dek);
761       free (pd);
762       return r;
763     }
764
765   pd->key_addr = key_addr;
766   memcpy (pd->crm_encrypted, (uint8_t *)&kdi.check, ADDITIONAL_DATA_SIZE);
767
768   if (kk == GPG_KEY_FOR_SIGNING)
769     {
770       ac_reset_pso_cds ();
771       gpg_reset_digital_signature_counter ();
772     }
773   else
774     ac_reset_other ();
775
776   if (ks_pw1)
777     encrypt (ks_pw1+1, pd->dek_encrypted_1, DATA_ENCRYPTION_KEY_SIZE);
778   else
779     {
780       uint8_t ks123_pw1[KEYSTRING_SIZE_PW1];
781
782       ks123_pw1[0] = strlen (OPENPGP_CARD_INITIAL_PW1);
783       sha1 ((uint8_t *)OPENPGP_CARD_INITIAL_PW1, 
784             strlen (OPENPGP_CARD_INITIAL_PW1), ks123_pw1+1);
785       encrypt (ks123_pw1+1, pd->dek_encrypted_1, DATA_ENCRYPTION_KEY_SIZE);
786     }
787
788   if (ks_rc)
789     encrypt (ks_rc+1, pd->dek_encrypted_2, DATA_ENCRYPTION_KEY_SIZE);
790   else
791     memset (pd->dek_encrypted_2, 0, DATA_ENCRYPTION_KEY_SIZE);
792
793   if (keystring_admin)
794     encrypt (keystring_admin, pd->dek_encrypted_3, DATA_ENCRYPTION_KEY_SIZE);
795   else
796     memset (pd->dek_encrypted_3, 0, DATA_ENCRYPTION_KEY_SIZE);
797
798   p = flash_do_write (nr, (const uint8_t *)pd, sizeof (struct prvkey_data));
799   do_ptr[nr - NR_DO__FIRST__] = p;
800
801   random_bytes_free (dek);
802   free (pd);
803   if (p == NULL)
804     return -1;
805
806   if (++num_prv_keys == NUM_ALL_PRV_KEYS) /* All keys are registered.  */
807     {
808       /* Remove contents of keystrings from DO, but length */
809       if (ks_pw1)
810         {
811           uint8_t ks_pw1_len = ks_pw1[0];
812           gpg_do_write_simple (NR_DO_KEYSTRING_PW1, &ks_pw1_len, 1);
813         }
814
815       if (ks_rc)
816         {
817           uint8_t ks_rc_len = ks_rc[0];
818           gpg_do_write_simple (NR_DO_KEYSTRING_RC, &ks_rc_len, 1);
819         }
820     }
821
822   return 0;
823 }
824
825 int
826 gpg_do_chks_prvkey (enum kind_of_key kk,
827                     int who_old, const uint8_t *old_ks,
828                     int who_new, const uint8_t *new_ks)
829 {
830   uint8_t nr = get_do_ptr_nr_for_kk (kk);
831   const uint8_t *do_data = do_ptr[nr - NR_DO__FIRST__];
832   uint8_t dek[DATA_ENCRYPTION_KEY_SIZE];
833   struct prvkey_data *pd;
834   const uint8_t *p;
835   uint8_t *dek_p;
836
837   if (do_data == NULL)
838     return 0;                   /* No private key */
839
840   pd = (struct prvkey_data *)malloc (sizeof (struct prvkey_data));
841   if (pd == NULL)
842     return -1;
843
844   memcpy (pd, &(do_data)[1], sizeof (struct prvkey_data));
845   dek_p = ((uint8_t *)pd) + 4 + ADDITIONAL_DATA_SIZE
846     + DATA_ENCRYPTION_KEY_SIZE * (who_old - 1);
847   memcpy (dek, dek_p, DATA_ENCRYPTION_KEY_SIZE);
848   decrypt (old_ks, dek, DATA_ENCRYPTION_KEY_SIZE);
849   encrypt (new_ks, dek, DATA_ENCRYPTION_KEY_SIZE);
850   dek_p += DATA_ENCRYPTION_KEY_SIZE * (who_new - who_old);
851   memcpy (dek_p, dek, DATA_ENCRYPTION_KEY_SIZE);
852
853   p = flash_do_write (nr, (const uint8_t *)pd, sizeof (struct prvkey_data));
854   do_ptr[nr - NR_DO__FIRST__] = p;
855
856   flash_do_release (do_data);
857   free (pd);
858   if (p == NULL)
859     return -1;
860
861   return 1;
862 }
863
864 /*
865  * 4d, xx, xx, xx:    Extended Header List
866  *   b6 00 (SIG) / b8 00 (DEC) / a4 00 (AUT)
867  *   7f48, xx: cardholder private key template
868  *       91 xx
869  *       92 xx xx
870  *       93 xx xx
871  *   5f48, xx xx xx: cardholder private key
872  */
873 static int
874 proc_key_import (const uint8_t *data, int len)
875 {
876   int r;
877   enum kind_of_key kk;
878   const uint8_t *keystring_admin;
879   const uint8_t *p = data;
880
881   if (admin_authorized == BY_ADMIN)
882     keystring_admin = keystring_md_pw3;
883   else
884     keystring_admin = NULL;
885
886   DEBUG_BINARY (data, len);
887
888   if (*p++ != 0x4d)
889     return 0;
890
891   /* length field */
892   if (*p == 0x82)
893     p += 3;
894   else if (*p == 0x81)
895     p += 2;
896   else
897     p += 1;
898
899   if (*p == 0xb6)
900     kk = GPG_KEY_FOR_SIGNING;
901   else if (*p == 0xb8)
902     kk = GPG_KEY_FOR_DECRYPTION;
903   else                          /* 0xa4 */
904     kk = GPG_KEY_FOR_AUTHENTICATION;
905
906   if (len <= 22)
907     {                                       /* Deletion of the key */
908       uint8_t nr = get_do_ptr_nr_for_kk (kk);
909       const uint8_t *do_data = do_ptr[nr - NR_DO__FIRST__];
910
911       if (do_data == NULL)
912         return 1;
913
914       do_ptr[nr - NR_DO__FIRST__] = NULL;
915       flash_do_release (do_data);
916
917       if (--num_prv_keys == 0)
918         {
919           flash_keystore_release ();
920
921           /* Delete PW1 and RC if any */
922           gpg_do_write_simple (NR_DO_KEYSTRING_PW1, NULL, 0);
923           gpg_do_write_simple (NR_DO_KEYSTRING_RC, NULL, 0);
924         }
925
926       return 1;
927     }
928
929   /* It should starts with 00 01 00 01 (E) */
930   /* Skip E, 4-byte */
931   r = gpg_do_write_prvkey (kk, &data[26], len - 26, keystring_admin, NULL);
932   if (r < 0)
933     return 0;
934   else
935     return 1;
936 }
937
938 static const uint16_t cmp_ch_data[] = {
939   3,
940   GPG_DO_NAME,
941   GPG_DO_LANGUAGE,
942   GPG_DO_SEX,
943 };
944
945 static const uint16_t cmp_app_data[] = {
946   10,
947   GPG_DO_AID,
948   GPG_DO_HIST_BYTES,
949   /* XXX Discretionary data objects 0x0073 ??? */
950   GPG_DO_EXTCAP,
951   GPG_DO_ALG_SIG, GPG_DO_ALG_DEC, GPG_DO_ALG_AUT,
952   GPG_DO_PW_STATUS,
953   GPG_DO_FP_ALL, GPG_DO_CAFP_ALL, GPG_DO_KGTIME_ALL
954 };
955
956 static const uint16_t cmp_ss_temp[] = { 1, GPG_DO_DS_COUNT };
957
958 static const struct do_table_entry
959 gpg_do_table[] = {
960   /* Variables: Fixed size */
961   { GPG_DO_SEX, DO_VAR, AC_ALWAYS, AC_ADMIN_AUTHORIZED, &do_ptr[0] },
962   { GPG_DO_FP_SIG, DO_VAR, AC_ALWAYS, AC_ADMIN_AUTHORIZED, &do_ptr[1] },
963   { GPG_DO_FP_DEC, DO_VAR, AC_ALWAYS, AC_ADMIN_AUTHORIZED, &do_ptr[2] },
964   { GPG_DO_FP_AUT, DO_VAR, AC_ALWAYS, AC_ADMIN_AUTHORIZED, &do_ptr[3] },
965   { GPG_DO_CAFP_1, DO_VAR, AC_ALWAYS, AC_ADMIN_AUTHORIZED, &do_ptr[4] },
966   { GPG_DO_CAFP_2, DO_VAR, AC_ALWAYS, AC_ADMIN_AUTHORIZED, &do_ptr[5] },
967   { GPG_DO_CAFP_3, DO_VAR, AC_ALWAYS, AC_ADMIN_AUTHORIZED, &do_ptr[6] },
968   { GPG_DO_KGTIME_SIG, DO_VAR, AC_ALWAYS, AC_ADMIN_AUTHORIZED, &do_ptr[7] },
969   { GPG_DO_KGTIME_DEC, DO_VAR, AC_ALWAYS, AC_ADMIN_AUTHORIZED, &do_ptr[8] },
970   { GPG_DO_KGTIME_AUT, DO_VAR, AC_ALWAYS, AC_ADMIN_AUTHORIZED, &do_ptr[9] },
971   /* Variables: Variable size */
972   { GPG_DO_LOGIN_DATA, DO_VAR, AC_ALWAYS, AC_ADMIN_AUTHORIZED, &do_ptr[10] },
973   { GPG_DO_URL, DO_VAR, AC_ALWAYS, AC_ADMIN_AUTHORIZED, &do_ptr[11] },
974   { GPG_DO_NAME, DO_VAR, AC_ALWAYS, AC_ADMIN_AUTHORIZED, &do_ptr[12] },
975   { GPG_DO_LANGUAGE, DO_VAR, AC_ALWAYS, AC_ADMIN_AUTHORIZED, &do_ptr[13] },
976   /* Pseudo DO READ: calculated */
977   { GPG_DO_HIST_BYTES, DO_PROC_READ, AC_ALWAYS, AC_NEVER, do_hist_bytes },
978   { GPG_DO_FP_ALL, DO_PROC_READ, AC_ALWAYS, AC_NEVER, do_fp_all },
979   { GPG_DO_CAFP_ALL, DO_PROC_READ, AC_ALWAYS, AC_NEVER, do_cafp_all },
980   { GPG_DO_KGTIME_ALL, DO_PROC_READ, AC_ALWAYS, AC_NEVER, do_kgtime_all },
981   /* Pseudo DO READ: calculated, not changeable by user */
982   { GPG_DO_DS_COUNT, DO_PROC_READ, AC_ALWAYS, AC_NEVER, do_ds_count },
983   { GPG_DO_AID, DO_PROC_READ, AC_ALWAYS, AC_NEVER, do_openpgpcard_aid },
984   /* Pseudo DO READ/WRITE: calculated */
985   { GPG_DO_PW_STATUS, DO_PROC_READWRITE, AC_ALWAYS, AC_ADMIN_AUTHORIZED,
986     rw_pw_status },
987   /* Fixed data */
988   { GPG_DO_EXTCAP, DO_FIXED, AC_ALWAYS, AC_NEVER, extended_capabilities },
989   { GPG_DO_ALG_SIG, DO_FIXED, AC_ALWAYS, AC_NEVER, algorithm_attr },
990   { GPG_DO_ALG_DEC, DO_FIXED, AC_ALWAYS, AC_NEVER, algorithm_attr },
991   { GPG_DO_ALG_AUT, DO_FIXED, AC_ALWAYS, AC_NEVER, algorithm_attr },
992   /* Compound data: Read access only */
993   { GPG_DO_CH_DATA, DO_CMP_READ, AC_ALWAYS, AC_NEVER, cmp_ch_data },
994   { GPG_DO_APP_DATA, DO_CMP_READ, AC_ALWAYS, AC_NEVER, cmp_app_data },
995   { GPG_DO_SS_TEMP, DO_CMP_READ, AC_ALWAYS, AC_NEVER, cmp_ss_temp },
996   /* Simple data: write access only */
997   { GPG_DO_RESETTING_CODE, DO_PROC_WRITE, AC_NEVER, AC_ADMIN_AUTHORIZED,
998     proc_resetting_code },
999   /* Compound data: Write access only */
1000   { GPG_DO_KEY_IMPORT, DO_PROC_WRITE, AC_NEVER, AC_ADMIN_AUTHORIZED,
1001     proc_key_import },
1002 #if 0
1003   /* Card holder certificate is handled in special way, as its size is big */
1004   { GPG_DO_CH_CERTIFICATE, DO_VAR, AC_ALWAYS, AC_ADMIN_AUTHORIZED, NULL },
1005 #endif
1006 };
1007
1008 #define NUM_DO_ENTRIES (int)(sizeof (gpg_do_table) \
1009                              / sizeof (struct do_table_entry))
1010
1011 /*
1012  * Reading data from Flash ROM, initialize DO_PTR, PW_ERR_COUNTERS, etc. 
1013  */
1014 void
1015 gpg_data_scan (const uint8_t *p_start)
1016 {
1017   const uint8_t *p;
1018   int i;
1019   const uint8_t *dsc_h14_p, *dsc_l10_p;
1020   int dsc_h14, dsc_l10;
1021
1022   dsc_h14_p = dsc_l10_p = NULL;
1023   pw1_lifetime_p = NULL;
1024   pw_err_counter_p[PW_ERR_PW1] = NULL;
1025   pw_err_counter_p[PW_ERR_RC] = NULL;
1026   pw_err_counter_p[PW_ERR_PW3] = NULL;
1027
1028   /* Traverse DO, counters, etc. in DATA pool */
1029   p = p_start;
1030   while (*p != NR_EMPTY)
1031     {
1032       uint8_t nr = *p++;
1033       uint8_t second_byte = *p;
1034
1035       if (nr == 0x00 && second_byte == 0x00)
1036         p++;                    /* Skip released word */
1037       else
1038         {
1039           if (nr < 0x80)
1040             {
1041               /* It's Data Object */
1042               do_ptr[nr - NR_DO__FIRST__] = p;
1043               p += second_byte + 1; /* second_byte has length */
1044
1045               if (((uint32_t)p & 1))
1046                 p++;
1047             }
1048           else if (nr >= 0x80 && nr <= 0xbf)
1049             /* Encoded data of Digital Signature Counter: upper 14-bit */
1050             {
1051               dsc_h14_p = p - 1;
1052               p++;
1053             }
1054           else if (nr >= 0xc0 && nr <= 0xc3)
1055             /* Encoded data of Digital Signature Counter: lower 10-bit */
1056             {
1057               dsc_l10_p = p - 1;
1058               p++;
1059             }
1060           else
1061             switch (nr)
1062             {
1063             case NR_BOOL_PW1_LIFETIME:
1064               pw1_lifetime_p = p - 1;
1065               p++;
1066               continue;
1067             case NR_COUNTER_123:
1068               p++;
1069               if (second_byte <= PW_ERR_PW3)
1070                 pw_err_counter_p[second_byte] = p;
1071               p += 2;
1072               break;
1073             }
1074         }
1075     }
1076
1077   flash_set_data_pool_last (p);
1078
1079   num_prv_keys = 0;
1080   if (do_ptr[NR_DO_PRVKEY_SIG - NR_DO__FIRST__] != NULL)
1081     num_prv_keys++;
1082   if (do_ptr[NR_DO_PRVKEY_DEC - NR_DO__FIRST__] != NULL)
1083     num_prv_keys++;
1084   if (do_ptr[NR_DO_PRVKEY_AUT - NR_DO__FIRST__] != NULL)
1085     num_prv_keys++;
1086
1087   data_objects_number_of_bytes = 0;
1088   for (i = NR_DO__FIRST__; i < NR_DO__LAST__; i++)
1089     if (do_ptr[i - NR_DO__FIRST__] != NULL)
1090       data_objects_number_of_bytes += *do_ptr[i - NR_DO__FIRST__];
1091
1092   if (dsc_l10_p == NULL)
1093     dsc_l10 = 0;
1094   else
1095     dsc_l10 = ((*dsc_l10_p - 0xc0) << 8) | *(dsc_l10_p + 1);
1096
1097   if (dsc_h14_p == NULL)
1098     dsc_h14 = 0;
1099   else
1100     {
1101       dsc_h14 = ((*dsc_h14_p - 0x80) << 8) | *(dsc_h14_p + 1);
1102       if (dsc_l10_p == NULL)
1103         DEBUG_INFO ("something wrong in DSC\r\n"); /* weird??? */
1104       else if (dsc_l10_p < dsc_h14_p)
1105         /* Possibly, power off during writing dsc_l10 */
1106         dsc_l10 = 0;
1107     }
1108
1109   digital_signature_counter = (dsc_h14 << 10) | dsc_l10;
1110 }
1111
1112 /*
1113  * Write all data to newly allocated Flash ROM page (from P_START),
1114  * updating PW1_LIFETIME_P, PW_ERR_COUNTER_P, and DO_PTR.
1115  * Called by flash_copying_gc.
1116  */
1117 void
1118 gpg_data_copy (const uint8_t *p_start)
1119 {
1120   const uint8_t *p;
1121   int i;
1122   int v;
1123
1124   p = gpg_write_digital_signature_counter (p_start, digital_signature_counter);
1125
1126   if (pw1_lifetime_p != NULL)
1127     {
1128       flash_bool_write_internal (p, NR_BOOL_PW1_LIFETIME);
1129       pw1_lifetime_p = p;
1130       p += 2;
1131     }
1132
1133   for (i = 0; i < 3; i++)
1134     if ((v = flash_cnt123_get_value (pw_err_counter_p[i])) != 0)
1135       {
1136         flash_cnt123_write_internal (p, i, v);
1137         pw_err_counter_p[i] = p + 2;
1138         p += 4;
1139       }
1140
1141   data_objects_number_of_bytes = 0;
1142   for (i = NR_DO__FIRST__; i < NR_DO__LAST__; i++)
1143     if (do_ptr[i - NR_DO__FIRST__] != NULL)
1144       {
1145         const uint8_t *do_data = do_ptr[i - NR_DO__FIRST__];
1146         int len = do_data[0];
1147
1148         flash_do_write_internal (p, i, &do_data[1], len);
1149         do_ptr[i - NR_DO__FIRST__] = p + 1;
1150         p += 2 + ((len + 1) & ~1);
1151         data_objects_number_of_bytes += len;
1152       }
1153
1154   flash_set_data_pool_last (p);
1155 }
1156
1157 static const struct do_table_entry *
1158 get_do_entry (uint16_t tag)
1159 {
1160   int i;
1161
1162   for (i = 0; i < NUM_DO_ENTRIES; i++)
1163     if (gpg_do_table[i].tag == tag)
1164       return &gpg_do_table[i];
1165
1166   return NULL;
1167 }
1168
1169 static void
1170 copy_do_1 (uint16_t tag, const uint8_t *do_data, int with_tag)
1171 {
1172   int len;
1173
1174   if (with_tag)
1175     {
1176       copy_tag (tag);
1177
1178       if (do_data[0] >= 128)
1179         *res_p++ = 0x81;
1180
1181       len = do_data[0] + 1;
1182     }
1183   else
1184     {
1185       len = do_data[0];
1186       do_data++;
1187     }
1188
1189   memcpy (res_p, do_data, len);
1190   res_p += len;
1191 }
1192
1193 static int
1194 copy_do (const struct do_table_entry *do_p, int with_tag)
1195 {
1196   if (do_p == NULL)
1197     return 0;
1198
1199   if (!ac_check_status (do_p->ac_read))
1200     return -1;
1201
1202   switch (do_p->do_type)
1203     {
1204     case DO_FIXED:
1205       {
1206         const uint8_t *do_data = (const uint8_t *)do_p->obj;
1207         if (do_data == NULL)
1208           return 0;
1209         else
1210           copy_do_1 (do_p->tag, do_data, with_tag);
1211         break;
1212       }
1213     case DO_VAR:
1214       {
1215         const uint8_t *do_data = *(const uint8_t **)do_p->obj;
1216         if (do_data == NULL)
1217           return 0;
1218         else
1219           copy_do_1 (do_p->tag, do_data, with_tag);
1220         break;
1221       }
1222     case DO_CMP_READ:
1223       {
1224         int i;
1225         const uint16_t *cmp_data = (const uint16_t *)do_p->obj;
1226         int num_components = cmp_data[0];
1227         uint8_t *len_p = NULL;
1228
1229         if (with_tag)
1230           {
1231             copy_tag (do_p->tag);
1232             *res_p++ = 0x81;    /* Assume it's less than 256 */
1233             len_p = res_p;
1234             *res_p++ = 0;       /* for now */
1235           }
1236
1237         for (i = 0; i < num_components; i++)
1238           {
1239             uint16_t tag0;
1240             const struct do_table_entry *do0_p;
1241
1242             tag0 = cmp_data[i+1];
1243             do0_p = get_do_entry (tag0);
1244             if (copy_do (do0_p, 1) < 0)
1245               return -1;
1246           }
1247
1248         if (len_p)
1249           *len_p = res_p - len_p - 1;
1250         break;
1251       }
1252     case DO_PROC_READ:
1253       {
1254         int (*do_func)(uint16_t, int) = (int (*)(uint16_t, int))do_p->obj;
1255
1256         return do_func (do_p->tag, with_tag);
1257       }
1258     case DO_PROC_READWRITE:
1259       {
1260         int (*rw_func)(uint16_t, int, uint8_t *, int, int)
1261           = (int (*)(uint16_t, int, uint8_t *, int, int))do_p->obj;
1262
1263         return rw_func (do_p->tag, with_tag, NULL, 0, 0);
1264       }
1265     case DO_PROC_WRITE:
1266       return -1;
1267     }
1268
1269   return 1;
1270 }
1271
1272 /*
1273  * Process GET_DATA request on Data Object specified by TAG
1274  *   Call write_res_adpu to fill data returned
1275  */
1276 void
1277 gpg_do_get_data (uint16_t tag, int with_tag)
1278 {
1279 #if defined(CERTDO_SUPPORT)
1280   if (tag == GPG_DO_CH_CERTIFICATE)
1281     {
1282       apdu.res_apdu_data = &ch_certificate_start;
1283       apdu.res_apdu_data_len = ((apdu.res_apdu_data[2] << 8) | apdu.res_apdu_data[3]);
1284       if (apdu.res_apdu_data_len == 0xffff)
1285         {
1286           apdu.res_apdu_data_len = 0;
1287           GPG_NO_RECORD ();
1288         }
1289       else
1290         /* Add length of (tag+len) */
1291         apdu.res_apdu_data_len += 4;
1292     }
1293   else
1294 #endif
1295     {
1296       const struct do_table_entry *do_p = get_do_entry (tag);
1297
1298       res_p = res_APDU;
1299
1300       DEBUG_INFO ("   ");
1301       DEBUG_SHORT (tag);
1302
1303       if (do_p)
1304         {
1305           if (copy_do (do_p, with_tag) < 0)
1306             /* Overwriting partially written result  */
1307             GPG_SECURITY_FAILURE ();
1308           else
1309             {
1310               res_APDU_size = res_p - res_APDU;
1311               GPG_SUCCESS ();
1312             }
1313         }
1314       else
1315         GPG_NO_RECORD ();
1316     }
1317 }
1318
1319 void
1320 gpg_do_put_data (uint16_t tag, const uint8_t *data, int len)
1321 {
1322   const struct do_table_entry *do_p = get_do_entry (tag);
1323
1324   DEBUG_INFO ("   ");
1325   DEBUG_SHORT (tag);
1326
1327   if (do_p)
1328     {
1329       if (!ac_check_status (do_p->ac_write))
1330         {
1331           GPG_SECURITY_FAILURE ();
1332           return;
1333         }
1334
1335       switch (do_p->do_type)
1336         {
1337         case DO_FIXED:
1338         case DO_CMP_READ:
1339         case DO_PROC_READ:
1340           GPG_SECURITY_FAILURE ();
1341           break;
1342         case DO_VAR:
1343           {
1344             const uint8_t **do_data_p = (const uint8_t **)do_p->obj;
1345
1346             if (*do_data_p)
1347               flash_do_release (*do_data_p);
1348
1349             if (len == 0)
1350               /* make DO empty */
1351               *do_data_p = NULL;
1352             else if (len > 255)
1353               GPG_MEMORY_FAILURE ();
1354             else
1355               {
1356                 uint8_t nr = do_tag_to_nr (tag);
1357
1358                 if (nr == NR_NONE)
1359                   GPG_MEMORY_FAILURE ();
1360                 else
1361                   {
1362                     *do_data_p = flash_do_write (nr, data, len);
1363                     if (*do_data_p)
1364                       GPG_SUCCESS ();
1365                     else
1366                       GPG_MEMORY_FAILURE ();
1367                   }
1368               }
1369             break;
1370           }
1371         case DO_PROC_READWRITE:
1372           {
1373             int (*rw_func)(uint16_t, int, const uint8_t *, int, int)
1374               = (int (*)(uint16_t, int, const uint8_t *, int, int))do_p->obj;
1375
1376             if (rw_func (tag, 0, data, len, 1))
1377               GPG_SUCCESS ();
1378             else
1379               GPG_ERROR ();
1380             break;
1381           }
1382         case DO_PROC_WRITE:
1383           {
1384             int (*proc_func)(const uint8_t *, int)
1385               = (int (*)(const uint8_t *, int))do_p->obj;
1386
1387             if (proc_func (data, len))
1388               GPG_SUCCESS ();
1389             else
1390               GPG_ERROR ();
1391             break;
1392           }
1393         }
1394     }
1395   else
1396     GPG_NO_RECORD ();
1397 }
1398
1399 void
1400 gpg_do_public_key (uint8_t kk_byte)
1401 {
1402   const uint8_t *do_data;
1403   const uint8_t *key_addr;
1404
1405   DEBUG_INFO ("Public key\r\n");
1406   DEBUG_BYTE (kk_byte);
1407
1408   if (kk_byte == 0xb6)
1409     do_data = do_ptr[NR_DO_PRVKEY_SIG - NR_DO__FIRST__];
1410   else if (kk_byte == 0xb8)
1411     do_data = do_ptr[NR_DO_PRVKEY_DEC - NR_DO__FIRST__];
1412   else                          /* 0xa4 */
1413     do_data = do_ptr[NR_DO_PRVKEY_AUT - NR_DO__FIRST__];
1414
1415   if (do_data == NULL)
1416     {
1417       DEBUG_INFO ("none.\r\n");
1418       GPG_NO_RECORD ();
1419       return;
1420     }
1421
1422   key_addr = *(const uint8_t **)&do_data[1];
1423
1424   res_p = res_APDU;
1425
1426   /* TAG */
1427   *res_p++ = 0x7f; *res_p++ = 0x49;
1428   /* LEN = 9+256 */
1429   *res_p++ = 0x82; *res_p++ = 0x01; *res_p++ = 0x09;
1430
1431   {
1432     /*TAG*/          /*LEN = 256 */
1433     *res_p++ = 0x81; *res_p++ = 0x82; *res_p++ = 0x01; *res_p++ = 0x00;
1434     /* 256-byte binary (big endian) */
1435     memcpy (res_p, key_addr + KEY_CONTENT_LEN, KEY_CONTENT_LEN);
1436     res_p += 256;
1437   }
1438   {
1439     /*TAG*/          /*LEN= 3 */
1440     *res_p++ = 0x82; *res_p++ = 3;
1441     /* 3-byte E=0x10001 (big endian) */
1442     *res_p++ = 0x01; *res_p++ = 0x00; *res_p++ = 0x01;
1443
1444     /* Success */
1445     res_APDU_size = res_p - res_APDU;
1446     GPG_SUCCESS ();
1447   }
1448
1449   DEBUG_INFO ("done.\r\n");
1450   return;
1451 }
1452
1453 const uint8_t *
1454 gpg_do_read_simple (uint8_t nr)
1455 {
1456   const uint8_t *do_data;
1457
1458   do_data = do_ptr[nr - NR_DO__FIRST__];
1459   if (do_data == NULL)
1460     return NULL;
1461
1462   return do_data+1;
1463 }
1464
1465 void
1466 gpg_do_write_simple (uint8_t nr, const uint8_t *data, int size)
1467 {
1468   const uint8_t **do_data_p;
1469
1470   do_data_p = (const uint8_t **)&do_ptr[nr - NR_DO__FIRST__];
1471   if (*do_data_p)
1472     flash_do_release (*do_data_p);
1473
1474   if (data != NULL)
1475     {
1476       *do_data_p = flash_do_write (nr, data, size);
1477       if (*do_data_p == NULL)
1478         flash_warning ("DO WRITE ERROR");
1479     }
1480   else
1481     *do_data_p = NULL;
1482 }
1483
1484 #ifdef KEYGEN_SUPPORT
1485 void
1486 gpg_do_keygen (uint8_t kk_byte)
1487 {
1488   enum kind_of_key kk;
1489   const uint8_t *keystring_admin;
1490   const uint8_t *p_q_modulus;
1491   const uint8_t *p_q;
1492   const uint8_t *modulus;
1493   int r;
1494
1495   DEBUG_INFO ("Keygen\r\n");
1496   DEBUG_BYTE (kk_byte);
1497
1498   if (kk_byte == 0xb6)
1499     kk = GPG_KEY_FOR_SIGNING;
1500   else if (kk_byte == 0xb8)
1501     kk = GPG_KEY_FOR_DECRYPTION;
1502   else                          /* 0xa4 */
1503     kk = GPG_KEY_FOR_AUTHENTICATION;
1504
1505   if (admin_authorized == BY_ADMIN)
1506     keystring_admin = keystring_md_pw3;
1507   else
1508     keystring_admin = NULL;
1509
1510   chEvtSignal (main_thread, LED_WAIT_MODE);
1511   p_q_modulus = rsa_genkey ();
1512   chEvtSignal (main_thread, LED_STATUS_MODE);
1513   if (p_q_modulus == NULL)
1514     {
1515       GPG_MEMORY_FAILURE ();
1516       return;
1517     }
1518
1519   p_q = p_q_modulus;
1520   modulus = p_q_modulus + KEY_CONTENT_LEN;
1521
1522   r = gpg_do_write_prvkey (kk, p_q, KEY_CONTENT_LEN,
1523                            keystring_admin, modulus);
1524   free ((uint8_t *)p_q_modulus);
1525   if (r < 0)
1526     {
1527       GPG_ERROR ();
1528       return;
1529     }
1530
1531   DEBUG_INFO ("Calling gpg_do_public_key...\r\n");
1532
1533   if (kk == GPG_KEY_FOR_SIGNING)
1534     {
1535       /* Authintication has been reset within gpg_do_write_prvkey. */
1536       /* But GnuPG expects it's ready for signing. */
1537       /* Thus, we call verify_pso_cds here. */
1538       const uint8_t *ks_pw1 = gpg_do_read_simple (NR_DO_KEYSTRING_PW1);
1539       const uint8_t *pw;
1540       int pw_len;
1541
1542       if (ks_pw1)
1543         {
1544           pw = ks_pw1+1;
1545           pw_len = ks_pw1[0];
1546         }
1547       else
1548         {
1549           pw = (const uint8_t *)OPENPGP_CARD_INITIAL_PW1;
1550           pw_len = strlen (OPENPGP_CARD_INITIAL_PW3);
1551         }
1552
1553       verify_pso_cds (pw, pw_len);
1554     }
1555
1556   gpg_do_public_key (kk_byte);
1557 }
1558 #endif