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