6d91b69d22654a793d3c76e045a5842afc94df83
[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, 2013, 2014
5  *               Free Software Initiative of Japan
6  * Author: NIIBE Yutaka <gniibe@fsij.org>
7  *
8  * This file is a part of Gnuk, a GnuPG USB Token implementation.
9  *
10  * Gnuk is free software: you can redistribute it and/or modify it
11  * under the terms of the GNU General Public License as published by
12  * the Free Software Foundation, either version 3 of the License, or
13  * (at your option) any later version.
14  *
15  * Gnuk is distributed in the hope that it will be useful, but WITHOUT
16  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
17  * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public
18  * License for more details.
19  *
20  * You should have received a copy of the GNU General Public License
21  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
22  *
23  */
24
25 #include <stdint.h>
26 #include <string.h>
27 #include <stdlib.h>
28
29 #include "config.h"
30
31 #include "sys.h"
32 #include "gnuk.h"
33 #include "openpgp.h"
34 #include "random.h"
35 #include "polarssl/config.h"
36 #include "polarssl/aes.h"
37 #include "sha512.h"
38
39 /* Forward declaration */
40 #define CLEAN_PAGE_FULL 1
41 #define CLEAN_SINGLE    0
42 static void gpg_do_delete_prvkey (enum kind_of_key kk, int clean_page_full);
43
44
45 #define PASSWORD_ERRORS_MAX 3   /* >= errors, it will be locked */
46 static const uint8_t *pw_err_counter_p[3];
47
48 static int
49 gpg_pw_get_err_counter (uint8_t which)
50 {
51   return flash_cnt123_get_value (pw_err_counter_p[which]);
52 }
53
54 int
55 gpg_pw_get_retry_counter (int who)
56 {
57   if (who == 0x81 || who == 0x82)
58     return PASSWORD_ERRORS_MAX - gpg_pw_get_err_counter (PW_ERR_PW1);
59   else if (who == 0x83)
60     return PASSWORD_ERRORS_MAX - gpg_pw_get_err_counter (PW_ERR_PW3);
61   else
62     return PASSWORD_ERRORS_MAX - gpg_pw_get_err_counter (PW_ERR_RC);
63 }
64
65 int
66 gpg_pw_locked (uint8_t which)
67 {
68   if (gpg_pw_get_err_counter (which) >= PASSWORD_ERRORS_MAX)
69     return 1;
70   else
71     return 0;
72 }
73
74 void
75 gpg_pw_reset_err_counter (uint8_t which)
76 {
77   flash_cnt123_clear (&pw_err_counter_p[which]);
78   if (pw_err_counter_p[which] != NULL)
79     GPG_MEMORY_FAILURE ();
80 }
81
82 void
83 gpg_pw_increment_err_counter (uint8_t which)
84 {
85   flash_cnt123_increment (which, &pw_err_counter_p[which]);
86 }
87
88
89 uint16_t data_objects_number_of_bytes;
90
91 /*
92  * Compile time vars:
93  *   Historical Bytes (template), Extended Capabilities.
94  */
95
96 /* Historical Bytes (template) */
97 static const uint8_t historical_bytes[] __attribute__ ((aligned (1))) = {
98   10,
99   0x00,
100   0x31, 0x84,                   /* Full DF name, GET DATA, MF */
101   0x73,
102   0x80, 0x01, 0x80,             /* Full DF name */
103                                 /* 1-byte */
104                                 /* Command chaining, No extended Lc and Le */
105   0x00, 0x90, 0x00              /* Status info (no life cycle management) */
106 };
107
108 /* Extended Capabilities */
109 static const uint8_t extended_capabilities[] __attribute__ ((aligned (1))) = {
110   10,
111   0x74,                         /*
112                                  * No Secure Messaging supported
113                                  * GET CHALLENGE supported
114                                  * Key import supported
115                                  * PW status byte can be put
116                                  * No private_use_DO
117                                  * Algorithm attrs are changable
118                                  */
119   0,              /* Secure Messaging Algorithm: N/A (TDES=0, AES=1) */
120   0x00, CHALLENGE_LEN,          /* Max size of GET CHALLENGE */
121 #ifdef CERTDO_SUPPORT
122   0x08, 0x00,     /* max. length of cardholder certificate (2KiB) */
123 #else
124   0x00, 0x00,
125 #endif
126   /* Max. length of command APDU data */
127   0x00, 0xff,
128   /* Max. length of response APDU data */
129   0x01, 0x00,
130 };
131
132 /* Algorithm Attributes */
133 #define OPENPGP_ALGO_RSA   0x01
134 #define OPENPGP_ALGO_ECDH  0x12
135 #define OPENPGP_ALGO_ECDSA 0x13
136 #define OPENPGP_ALGO_EDDSA 0x16 /* It catches 22, finally.  */
137
138 static const uint8_t algorithm_attr_rsa2k[] __attribute__ ((aligned (1))) = {
139   6,
140   OPENPGP_ALGO_RSA,
141   0x08, 0x00,         /* Length modulus (in bit): 2048 */
142   0x00, 0x20,         /* Length exponent (in bit): 32  */
143   0x00                /* 0: Acceptable format is: P and Q */
144 };
145
146 static const uint8_t algorithm_attr_rsa4k[] __attribute__ ((aligned (1))) = {
147   6,
148   OPENPGP_ALGO_RSA,
149   0x10, 0x00,         /* Length modulus (in bit): 4096 */
150   0x00, 0x20,         /* Length exponent (in bit): 32  */
151   0x00                /* 0: Acceptable format is: P and Q */
152 };
153
154 static const uint8_t algorithm_attr_p256r1[] __attribute__ ((aligned (1))) = {
155   9,
156   OPENPGP_ALGO_ECDSA,
157   0x2a, 0x86, 0x48, 0xce, 0x3d, 0x03, 0x01, 0x07 /* OID of NIST curve P-256 */
158 };
159
160 static const uint8_t algorithm_attr_p256k1[] __attribute__ ((aligned (1))) = {
161   6,
162   OPENPGP_ALGO_ECDSA,
163   0x2b, 0x81, 0x04, 0x00, 0x0a /* OID of curve secp256k1 */
164 };
165
166 static const uint8_t algorithm_attr_ed25519[] __attribute__ ((aligned (1))) = {
167   10,
168   OPENPGP_ALGO_EDDSA,
169   /* OID of the curve Ed25519 */
170   0x2b, 0x06, 0x01, 0x04, 0x01, 0xda, 0x47, 0x0f, 0x01
171 };
172
173
174 /*
175  * Representation of PW1_LIFETIME:
176  *    0: PW1_LIEFTIME_P == NULL : PW1 is valid for single PSO:CDS command
177  *    1: PW1_LIEFTIME_P != NULL : PW1 is valid for several PSO:CDS commands
178  *
179  * The address in the variable PW1_LIEFTIME_P is used when filling zero
180  * in flash memory
181  */
182 static const uint8_t *pw1_lifetime_p;
183
184 static int
185 gpg_get_pw1_lifetime (void)
186 {
187   if (pw1_lifetime_p == NULL)
188     return 0;
189   else
190     return 1;
191 }
192
193
194 /*
195  * Representation of algorithm attributes:
196  *    0: ALGO_ATTR_<>_P == NULL : RSA-2048
197  *    N: ALGO_ATTR_<>_P != NULL : 
198  *
199  */
200 static const uint8_t *algo_attr_sig_p;
201 static const uint8_t *algo_attr_dec_p;
202 static const uint8_t *algo_attr_aut_p;
203
204 static const uint8_t **
205 get_algo_attr_pointer (enum kind_of_key kk)
206 {
207   if (kk == GPG_KEY_FOR_SIGNING)
208     return &algo_attr_sig_p;
209   else if (kk == GPG_KEY_FOR_DECRYPTION)
210     return &algo_attr_dec_p;
211   else
212     return &algo_attr_aut_p;
213 }
214
215 static int
216 kk_to_nr (enum kind_of_key kk)
217 {
218   int nr;
219
220   if (kk == GPG_KEY_FOR_SIGNING)
221     nr = NR_KEY_ALGO_ATTR_SIG;
222   else if (kk == GPG_KEY_FOR_DECRYPTION)
223     nr = NR_KEY_ALGO_ATTR_DEC;
224   else
225     nr = NR_KEY_ALGO_ATTR_AUT;
226
227   return nr;
228 }
229
230 int
231 gpg_get_algo_attr (enum kind_of_key kk)
232 {
233   const uint8_t *algo_attr_p = *get_algo_attr_pointer (kk);
234
235   if (algo_attr_p == NULL)
236     return ALGO_RSA2K;
237
238   return algo_attr_p[1];
239 }
240
241 static const uint8_t *
242 get_algo_attr_data_object (enum kind_of_key kk)
243 {
244   const uint8_t *algo_attr_p = *get_algo_attr_pointer (kk);
245
246   if (algo_attr_p == NULL)
247     return algorithm_attr_rsa2k;
248
249   if (algo_attr_p[1] == ALGO_RSA4K)
250     return algorithm_attr_rsa4k;
251   else if (algo_attr_p[1] == ALGO_NISTP256R1)
252     return algorithm_attr_p256r1;
253   else if (algo_attr_p[1] == ALGO_SECP256K1)
254     return algorithm_attr_p256k1;
255   else if (algo_attr_p[1] == ALGO_ED25519)
256     return algorithm_attr_ed25519;
257
258   return algorithm_attr_rsa2k;
259 }
260
261 int
262 gpg_get_algo_attr_key_size (enum kind_of_key kk, enum size_of_key s)
263 {
264   const uint8_t *algo_attr_p = *get_algo_attr_pointer (kk);
265
266   if (algo_attr_p == NULL)
267     if (s == GPG_KEY_STORAGE)
268       return 512;
269     else
270       return 256;
271   else if (algo_attr_p[1] == ALGO_RSA4K)
272     if (s == GPG_KEY_STORAGE)
273       return 1024;
274     else
275       return 512;
276   else if (algo_attr_p[1] == ALGO_NISTP256R1 || algo_attr_p[1] == ALGO_SECP256K1)
277     if (s == GPG_KEY_STORAGE)
278       return 128;
279     else if (s == GPG_KEY_PUBLIC)
280       return 64;
281     else
282       return 32;
283   else                          /* ED25519 */
284     if (s == GPG_KEY_STORAGE)
285       return 128;
286     else if (s == GPG_KEY_PUBLIC)
287       return 32;
288     else
289       return 64;
290 }
291
292
293 static uint32_t digital_signature_counter;
294
295 static const uint8_t *
296 gpg_write_digital_signature_counter (const uint8_t *p, uint32_t dsc)
297 {
298   uint16_t hw0, hw1;
299
300   if ((dsc >> 10) == 0)
301     { /* no upper bits */
302       hw1 = NR_COUNTER_DS_LSB | ((dsc & 0x0300) >> 8) | ((dsc & 0x00ff) << 8);
303       flash_put_data_internal (p, hw1);
304       return p+2;
305     }
306   else
307     {
308       hw0 = NR_COUNTER_DS | ((dsc & 0xfc0000) >> 18) | ((dsc & 0x03fc00) >> 2);
309       hw1 = NR_COUNTER_DS_LSB;
310       flash_put_data_internal (p, hw0);
311       flash_put_data_internal (p+2, hw1);
312       return p+4;
313     }
314 }
315
316 static void
317 gpg_reset_digital_signature_counter (void)
318 {
319   if (digital_signature_counter != 0)
320     {
321       flash_put_data (NR_COUNTER_DS);
322       flash_put_data (NR_COUNTER_DS_LSB);
323       digital_signature_counter = 0;
324     }
325 }
326
327 void
328 gpg_increment_digital_signature_counter (void)
329 {
330   uint16_t hw0, hw1;
331   uint32_t dsc = (digital_signature_counter + 1) & 0x00ffffff;
332
333   if ((dsc & 0x03ff) == 0)
334     { /* carry occurs from l10 to h14 */
335       hw0 = NR_COUNTER_DS | ((dsc & 0xfc0000) >> 18) | ((dsc & 0x03fc00) >> 2);
336       hw1 = NR_COUNTER_DS_LSB;  /* zero */
337       flash_put_data (hw0);
338       flash_put_data (hw1);
339     }
340   else
341     {
342       hw1 = NR_COUNTER_DS_LSB | ((dsc & 0x0300) >> 8) | ((dsc & 0x00ff) << 8);
343       flash_put_data (hw1);
344     }
345
346   digital_signature_counter = dsc;
347
348   if (gpg_get_pw1_lifetime () == 0)
349     ac_reset_pso_cds ();
350 }
351
352
353 #define SIZE_FINGER_PRINT 20
354 #define SIZE_KEYGEN_TIME 4      /* RFC4880 */
355
356 enum do_type {
357   DO_FIXED,
358   DO_VAR,
359   DO_CMP_READ,
360   DO_PROC_READ,
361   DO_PROC_WRITE,
362   DO_PROC_READWRITE,
363 };
364
365 struct do_table_entry {
366   uint16_t tag;
367   enum do_type do_type;
368   uint8_t ac_read;
369   uint8_t ac_write;
370   const void *obj;
371 };
372
373 static uint8_t *res_p;
374
375 static void copy_do_1 (uint16_t tag, const uint8_t *do_data, int with_tag);
376 static const struct do_table_entry *get_do_entry (uint16_t tag);
377
378 #define GPG_DO_AID              0x004f
379 #define GPG_DO_NAME             0x005b
380 #define GPG_DO_LOGIN_DATA       0x005e
381 #define GPG_DO_CH_DATA          0x0065
382 #define GPG_DO_APP_DATA         0x006e
383 #define GPG_DO_DISCRETIONARY    0x0073
384 #define GPG_DO_SS_TEMP          0x007a
385 #define GPG_DO_DS_COUNT         0x0093
386 #define GPG_DO_EXTCAP           0x00c0
387 #define GPG_DO_ALG_SIG          0x00c1
388 #define GPG_DO_ALG_DEC          0x00c2
389 #define GPG_DO_ALG_AUT          0x00c3
390 #define GPG_DO_PW_STATUS        0x00c4
391 #define GPG_DO_FP_ALL           0x00c5
392 #define GPG_DO_CAFP_ALL         0x00c6
393 #define GPG_DO_FP_SIG           0x00c7
394 #define GPG_DO_FP_DEC           0x00c8
395 #define GPG_DO_FP_AUT           0x00c9
396 #define GPG_DO_CAFP_1           0x00ca
397 #define GPG_DO_CAFP_2           0x00cb
398 #define GPG_DO_CAFP_3           0x00cc
399 #define GPG_DO_KGTIME_ALL       0x00cd
400 #define GPG_DO_KGTIME_SIG       0x00ce
401 #define GPG_DO_KGTIME_DEC       0x00cf
402 #define GPG_DO_KGTIME_AUT       0x00d0
403 #define GPG_DO_RESETTING_CODE   0x00d3
404 #define GPG_DO_KEY_IMPORT       0x3fff
405 #define GPG_DO_LANGUAGE         0x5f2d
406 #define GPG_DO_SEX              0x5f35
407 #define GPG_DO_URL              0x5f50
408 #define GPG_DO_HIST_BYTES       0x5f52
409 #define GPG_DO_CH_CERTIFICATE   0x7f21
410
411 static const uint8_t *do_ptr[NR_DO__LAST__];
412
413 static int
414 do_tag_to_nr (uint16_t tag)
415 {
416   switch (tag)
417     {
418     case GPG_DO_SEX:
419       return NR_DO_SEX;
420     case GPG_DO_FP_SIG:
421       return NR_DO_FP_SIG;
422     case GPG_DO_FP_DEC:
423       return NR_DO_FP_DEC;
424     case GPG_DO_FP_AUT:
425       return NR_DO_FP_AUT;
426     case GPG_DO_CAFP_1:
427       return NR_DO_CAFP_1;
428     case GPG_DO_CAFP_2:
429       return NR_DO_CAFP_2;
430     case GPG_DO_CAFP_3:
431       return NR_DO_CAFP_3;
432     case GPG_DO_KGTIME_SIG:
433       return NR_DO_KGTIME_SIG;
434     case GPG_DO_KGTIME_DEC:
435       return NR_DO_KGTIME_DEC;
436     case GPG_DO_KGTIME_AUT:
437       return NR_DO_KGTIME_AUT;
438     case GPG_DO_LOGIN_DATA:
439       return NR_DO_LOGIN_DATA;
440     case GPG_DO_URL:
441       return NR_DO_URL;
442     case GPG_DO_NAME:
443       return NR_DO_NAME;
444     case GPG_DO_LANGUAGE:
445       return NR_DO_LANGUAGE;
446     default:
447       return -1;
448     }
449 }
450
451 static void
452 copy_tag (uint16_t tag)
453 {
454   if (tag < 0x0100)
455     *res_p++ = (tag & 0xff);
456   else
457     {
458       *res_p++ = (tag >> 8);
459       *res_p++ = (tag & 0xff);
460     }
461 }
462
463 static int
464 do_hist_bytes (uint16_t tag, int with_tag)
465 {
466   /*
467    * Currently, we support no life cycle management.
468    * In case of Gnuk, user could flash the MCU, instead.
469    * Thus, just return the template as is.
470    *
471    * In future (when Gnuk will be onn the real smartcard),
472    * we can support life cycle management by implementing
473    * TERMINATE DF / ACTIVATE FILE and fix code around here.
474    */
475   copy_do_1 (tag, historical_bytes, with_tag);
476   return 1;
477 }
478
479 #define SIZE_FP 20
480 #define SIZE_KGTIME 4
481
482 static int
483 do_fp_all (uint16_t tag, int with_tag)
484 {
485   const uint8_t *data;
486
487   if (with_tag)
488     {
489       copy_tag (tag);
490       *res_p++ = SIZE_FP*3;
491     }
492
493   data = gpg_do_read_simple (NR_DO_FP_SIG);
494   if (data)
495     memcpy (res_p, data, SIZE_FP);
496   else
497     memset (res_p, 0, SIZE_FP);
498   res_p += SIZE_FP;
499
500   data = gpg_do_read_simple (NR_DO_FP_DEC);
501   if (data)
502     memcpy (res_p, data, SIZE_FP);
503   else
504     memset (res_p, 0, SIZE_FP);
505   res_p += SIZE_FP;
506
507   data = gpg_do_read_simple (NR_DO_FP_AUT);
508   if (data)
509     memcpy (res_p, data, SIZE_FP);
510   else
511     memset (res_p, 0, SIZE_FP);
512   res_p += SIZE_FP;
513   return 1;
514 }
515
516 static int
517 do_cafp_all (uint16_t tag, int with_tag)
518 {
519   const uint8_t *data;
520
521   if (with_tag)
522     {
523       copy_tag (tag);
524       *res_p++ = SIZE_FP*3;
525     }
526
527   data = gpg_do_read_simple (NR_DO_CAFP_1);
528   if (data)
529     memcpy (res_p, data, SIZE_FP);
530   else
531     memset (res_p, 0, SIZE_FP);
532   res_p += SIZE_FP;
533
534   data = gpg_do_read_simple (NR_DO_CAFP_2);
535   if (data)
536     memcpy (res_p, data, SIZE_FP);
537   else
538     memset (res_p, 0, SIZE_FP);
539   res_p += SIZE_FP;
540
541   data = gpg_do_read_simple (NR_DO_CAFP_2);
542   if (data)
543     memcpy (res_p, data, SIZE_FP);
544   else
545     memset (res_p, 0, SIZE_FP);
546   res_p += SIZE_FP;
547   return 1;
548 }
549
550 static int
551 do_kgtime_all (uint16_t tag, int with_tag)
552 {
553   const uint8_t *data;
554
555   if (with_tag)
556     {
557       copy_tag (tag);
558       *res_p++ = SIZE_KGTIME*3;
559     }
560
561   data = gpg_do_read_simple (NR_DO_KGTIME_SIG);
562   if (data)
563     memcpy (res_p, data, SIZE_KGTIME);
564   else
565     memset (res_p, 0, SIZE_KGTIME);
566   res_p += SIZE_KGTIME;
567
568   data = gpg_do_read_simple (NR_DO_KGTIME_DEC);
569   if (data)
570     memcpy (res_p, data, SIZE_KGTIME);
571   else
572     memset (res_p, 0, SIZE_KGTIME);
573   res_p += SIZE_KGTIME;
574
575   data = gpg_do_read_simple (NR_DO_KGTIME_AUT);
576   if (data)
577     memcpy (res_p, data, SIZE_KGTIME);
578   else
579     memset (res_p, 0, SIZE_KGTIME);
580   res_p += SIZE_KGTIME;
581   return 1;
582 }
583
584 const uint8_t openpgpcard_aid[] = {
585   0xd2, 0x76,               /* D: National, 276: DEU ISO 3166-1 */
586   0x00, 0x01, 0x24,         /* Registered Application Provider Identifier */
587   0x01,                     /* Application: OpenPGPcard */
588   0x02, 0x00,               /* Version 2.0 */
589   /* v. id */ /*   serial number   */
590   0xff, 0xff, 0xff, 0xff,  0xff, 0xff, /* To be overwritten */
591 };
592
593 static int
594 do_openpgpcard_aid (uint16_t tag, int with_tag)
595 {
596   const volatile uint8_t *p = openpgpcard_aid;
597   uint16_t vid = (p[8] << 8) | p[9];
598
599   if (with_tag)
600     {
601       copy_tag (tag);
602       *res_p++ = 16;
603     }
604
605   if (vid == 0xffff || vid == 0x0000)
606     {
607       const uint8_t *u = unique_device_id ();
608
609       memcpy (res_p, openpgpcard_aid, 8);
610       res_p += 8;
611
612       /* vid == 0xfffe: serial number is random byte */
613       *res_p++ = 0xff;
614       *res_p++ = 0xfe;
615       memcpy (res_p, u, 4);
616       res_p += 4;
617     }
618   else
619     {
620       memcpy (res_p, openpgpcard_aid, 14);
621       res_p += 14;
622     }
623
624   *res_p++ = 0;
625   *res_p++ = 0;
626
627   return 1;
628 }
629
630 static int
631 do_ds_count (uint16_t tag, int with_tag)
632 {
633   if (with_tag)
634     {
635       copy_tag (tag);
636       *res_p++ = 3;
637     }
638
639   *res_p++ = (digital_signature_counter >> 16) & 0xff;
640   *res_p++ = (digital_signature_counter >> 8) & 0xff;
641   *res_p++ = digital_signature_counter & 0xff;
642   return 1;
643 }
644
645 static int
646 rw_pw_status (uint16_t tag, int with_tag,
647               const uint8_t *data, int len, int is_write)
648 {
649   if (is_write)
650     {
651       if (len != 1)
652         return 0;               /* Failure */
653
654       /* The first byte of DATA specifies the lifetime.  */
655       if (data[0] == 0 && pw1_lifetime_p != NULL)
656         {
657           flash_bool_clear (&pw1_lifetime_p);
658           if (pw1_lifetime_p != NULL) /* No change after update */
659             return 0;
660         }
661       else if (pw1_lifetime_p == NULL)
662         {
663           pw1_lifetime_p = flash_bool_write (NR_BOOL_PW1_LIFETIME);
664           if (pw1_lifetime_p == NULL) /* No change after update */
665             return 0;
666         }
667
668       return 1;                 /* Success */
669     }
670   else
671     {
672       if (with_tag)
673         {
674           copy_tag (tag);
675           *res_p++ = SIZE_PW_STATUS_BYTES;
676         }
677
678       *res_p++ = gpg_get_pw1_lifetime ();
679       *res_p++ = PW_LEN_MAX;
680       *res_p++ = PW_LEN_MAX;
681       *res_p++ = PW_LEN_MAX;
682       *res_p++ = PASSWORD_ERRORS_MAX - gpg_pw_get_err_counter (PW_ERR_PW1);
683       *res_p++ = PASSWORD_ERRORS_MAX - gpg_pw_get_err_counter (PW_ERR_RC);
684       *res_p++ = PASSWORD_ERRORS_MAX - gpg_pw_get_err_counter (PW_ERR_PW3);
685       return 1;
686     }
687 }
688
689 static int
690 rw_algorithm_attr (uint16_t tag, int with_tag,
691                    const uint8_t *data, int len, int is_write)
692 {
693   enum kind_of_key kk;
694
695   if (tag == GPG_DO_ALG_SIG)
696     kk = GPG_KEY_FOR_SIGNING;
697   else if (tag == GPG_DO_ALG_DEC)
698     kk = GPG_KEY_FOR_DECRYPTION;
699   else
700     kk = GPG_KEY_FOR_AUTHENTICATION;
701
702   if (is_write)
703     {
704       int algo = -1;
705       const uint8_t **algo_attr_pp = get_algo_attr_pointer (kk);
706
707       if (len == 6)
708         {
709           if (memcmp (data, algorithm_attr_rsa2k+1, 6) == 0)
710             algo = ALGO_RSA2K;
711           else if (memcmp (data, algorithm_attr_rsa4k+1, 6) == 0)
712             algo = ALGO_RSA4K;
713           else if ((tag != GPG_DO_ALG_DEC
714                     && memcmp (data, algorithm_attr_p256k1+1, 6) == 0)
715                    || (tag == GPG_DO_ALG_DEC && data[0]==OPENPGP_ALGO_ECDH
716                        && memcmp (data+1, algorithm_attr_p256k1+2, 5) == 0))
717             algo = ALGO_SECP256K1;
718         }
719       else if (len == 9
720                && ((tag != GPG_DO_ALG_DEC
721                     && memcmp (data, algorithm_attr_p256r1+1, 9) == 0)
722                    || (tag == GPG_DO_ALG_DEC && data[0]==OPENPGP_ALGO_ECDH
723                        && memcmp (data+1, algorithm_attr_p256r1+2, 8) == 0)))
724         algo = ALGO_NISTP256R1;
725       else if (len == 10 && memcmp (data, algorithm_attr_ed25519+1, 10) == 0)
726         algo = ALGO_ED25519;
727
728       if (algo < 0)
729         return 0;               /* Error */
730       else if (algo == ALGO_RSA2K && *algo_attr_pp != NULL)
731         {
732           gpg_do_delete_prvkey (kk, CLEAN_PAGE_FULL);
733           flash_enum_clear (algo_attr_pp);
734           if (*algo_attr_pp != NULL)
735             return 0;
736         }
737       else if (*algo_attr_pp == NULL || (*algo_attr_pp)[1] != algo)
738         {
739           gpg_do_delete_prvkey (kk, CLEAN_PAGE_FULL);
740           *algo_attr_pp = flash_enum_write (kk_to_nr (kk), algo);
741           if (*algo_attr_pp == NULL)
742             return 0;
743         }
744
745       return 1;
746     }
747   else
748     {
749       const uint8_t *algo_attr_do = get_algo_attr_data_object (kk);
750
751       copy_do_1 (tag, algo_attr_do, with_tag);
752       /* Override the byte when GPG_DO_ALG_DEC.  */
753       if (tag == GPG_DO_ALG_DEC && algo_attr_do[1] == OPENPGP_ALGO_ECDSA)
754         *(res_p - algo_attr_do[0]) = OPENPGP_ALGO_ECDH;
755       return 1;
756     }
757 }
758
759 static int
760 proc_resetting_code (const uint8_t *data, int len)
761 {
762   const uint8_t *old_ks = keystring_md_pw3;
763   uint8_t new_ks0[KEYSTRING_SIZE];
764   uint8_t *new_ks = KS_GET_KEYSTRING (new_ks0);
765   const uint8_t *newpw;
766   int newpw_len;
767   int r;
768   uint8_t *salt = KS_GET_SALT (new_ks0);
769
770   DEBUG_INFO ("Resetting Code!\r\n");
771
772   newpw_len = len;
773   newpw = data;
774   new_ks0[0] = newpw_len;
775   random_get_salt (salt);
776   s2k (salt, SALT_SIZE, newpw, newpw_len, new_ks);
777   r = gpg_change_keystring (admin_authorized, old_ks, BY_RESETCODE, new_ks);
778   if (r <= -2)
779     {
780       DEBUG_INFO ("memory error.\r\n");
781       return 0;
782     }
783   else if (r < 0)
784     {
785       DEBUG_INFO ("security error.\r\n");
786       return 0;
787     }
788   else if (r == 0)
789     {
790       DEBUG_INFO ("error (no prvkey).\r\n");
791       return 0;
792     }
793   else
794     {
795       DEBUG_INFO ("done.\r\n");
796       gpg_do_write_simple (NR_DO_KEYSTRING_RC, new_ks0, KS_META_SIZE);
797     }
798
799   gpg_pw_reset_err_counter (PW_ERR_RC);
800   return 1;
801 }
802
803 static void
804 encrypt (const uint8_t *key, const uint8_t *iv, uint8_t *data, int len)
805 {
806   aes_context aes;
807   uint8_t iv0[INITIAL_VECTOR_SIZE];
808   unsigned int iv_offset;
809
810   DEBUG_INFO ("ENC\r\n");
811   DEBUG_BINARY (data, len);
812
813   aes_setkey_enc (&aes, key, 128);
814   memcpy (iv0, iv, INITIAL_VECTOR_SIZE);
815   iv_offset = 0;
816   aes_crypt_cfb128 (&aes, AES_ENCRYPT, len, &iv_offset, iv0, data, data);
817 }
818
819 /* For three keys: Signing, Decryption, and Authentication */
820 struct key_data kd[3];
821
822 static void
823 decrypt (const uint8_t *key, const uint8_t *iv, uint8_t *data, int len)
824 {
825   aes_context aes;
826   uint8_t iv0[INITIAL_VECTOR_SIZE];
827   unsigned int iv_offset;
828
829   aes_setkey_enc (&aes, key, 128); /* This is setkey_enc, because of CFB.  */
830   memcpy (iv0, iv, INITIAL_VECTOR_SIZE);
831   iv_offset = 0;
832   aes_crypt_cfb128 (&aes, AES_DECRYPT, len, &iv_offset, iv0, data, data);
833
834   DEBUG_INFO ("DEC\r\n");
835   DEBUG_BINARY (data, len);
836 }
837
838 static void
839 encrypt_dek (const uint8_t *key_string, uint8_t *dek)
840 {
841   aes_context aes;
842
843   aes_setkey_enc (&aes, key_string, 128);
844   aes_crypt_ecb (&aes, AES_ENCRYPT, dek, dek);
845 }
846
847 static void
848 decrypt_dek (const uint8_t *key_string, uint8_t *dek)
849 {
850   aes_context aes;
851
852   aes_setkey_dec (&aes, key_string, 128);
853   aes_crypt_ecb (&aes, AES_DECRYPT, dek, dek);
854 }
855
856 static uint8_t
857 get_do_ptr_nr_for_kk (enum kind_of_key kk)
858 {
859   switch (kk)
860     {
861     case GPG_KEY_FOR_SIGNING:
862       return NR_DO_PRVKEY_SIG;
863     case GPG_KEY_FOR_DECRYPTION:
864       return NR_DO_PRVKEY_DEC;
865     case GPG_KEY_FOR_AUTHENTICATION:
866       return NR_DO_PRVKEY_AUT;
867     }
868   return NR_DO_PRVKEY_SIG;
869 }
870
871 void
872 gpg_do_clear_prvkey (enum kind_of_key kk)
873 {
874   memset (kd[kk].data, 0, MAX_PRVKEY_LEN);
875 }
876
877
878 #define CHECKSUM_ADDR(kdi,prvkey_len) \
879         (&(kdi).data[prvkey_len / sizeof (uint32_t)])
880 #define kdi_len(prvkey_len) (prvkey_len+DATA_ENCRYPTION_KEY_SIZE)
881 struct key_data_internal {
882   uint32_t data[(MAX_PRVKEY_LEN+DATA_ENCRYPTION_KEY_SIZE) / sizeof (uint32_t)];
883   /*
884    * Secret key data.
885    * RSA: p and q, ECDSA/ECDH: d, EdDSA: a+seed
886    */
887   /* Checksum */
888 };
889
890 #define CKDC_CALC  0
891 #define CKDC_CHECK 1
892 static int
893 compute_key_data_checksum (struct key_data_internal *kdi, int prvkey_len,
894                            int check_or_calc)
895 {
896   unsigned int i;
897   uint32_t d[4] = { 0, 0, 0, 0 };
898   uint32_t *checksum = CHECKSUM_ADDR (*kdi, prvkey_len);
899
900   for (i = 0; i < prvkey_len / sizeof (uint32_t); i++)
901     d[i&3] ^= kdi->data[i];
902
903   if (check_or_calc == CKDC_CALC)       /* store */
904     {
905       memcpy (checksum, d, DATA_ENCRYPTION_KEY_SIZE);
906       return 0;
907     }
908   else                          /* check */
909     return memcmp (checksum, d, DATA_ENCRYPTION_KEY_SIZE) == 0;
910 }
911
912 /*
913  * Return  1 on success,
914  *         0 if none,
915  *        -1 on error,
916  */
917 int
918 gpg_do_load_prvkey (enum kind_of_key kk, int who, const uint8_t *keystring)
919 {
920   uint8_t nr = get_do_ptr_nr_for_kk (kk);
921   int prvkey_len = gpg_get_algo_attr_key_size (kk, GPG_KEY_PRIVATE);
922   const uint8_t *do_data = do_ptr[nr];
923   const uint8_t *key_addr;
924   uint8_t dek[DATA_ENCRYPTION_KEY_SIZE];
925   const uint8_t *iv;
926   struct key_data_internal kdi;
927
928   DEBUG_INFO ("Loading private key: ");
929   DEBUG_BYTE (kk);
930
931   if (do_data == NULL)
932     return 0;
933
934   key_addr = kd[kk].pubkey - prvkey_len;
935   memcpy (kdi.data, key_addr, prvkey_len);
936   iv = &do_data[1];
937   memcpy (CHECKSUM_ADDR (kdi, prvkey_len),
938           iv + INITIAL_VECTOR_SIZE, DATA_ENCRYPTION_KEY_SIZE);
939
940   memcpy (dek, iv + DATA_ENCRYPTION_KEY_SIZE*(who+1), DATA_ENCRYPTION_KEY_SIZE);
941   decrypt_dek (keystring, dek);
942
943   decrypt (dek, iv, (uint8_t *)&kdi, kdi_len (prvkey_len));
944   memset (dek, 0, DATA_ENCRYPTION_KEY_SIZE);
945   if (!compute_key_data_checksum (&kdi, prvkey_len, CKDC_CHECK))
946     {
947       DEBUG_INFO ("gpg_do_load_prvkey failed.\r\n");
948       return -1;
949     }
950
951   memcpy (kd[kk].data, kdi.data, prvkey_len);
952   DEBUG_BINARY (kd[kk].data, prvkey_len);
953   return 1;
954 }
955
956
957 static int8_t num_prv_keys;
958
959 static void
960 gpg_do_delete_prvkey (enum kind_of_key kk, int clean_page_full)
961 {
962   uint8_t nr = get_do_ptr_nr_for_kk (kk);
963   const uint8_t *do_data = do_ptr[nr];
964   uint8_t *key_addr;
965   int prvkey_len = gpg_get_algo_attr_key_size (kk, GPG_KEY_PRIVATE);
966   int key_size = gpg_get_algo_attr_key_size (kk, GPG_KEY_STORAGE);
967
968   if (do_data == NULL)
969     {
970       if (clean_page_full)
971         flash_key_release_page (kk);
972       return;
973     }
974
975   do_ptr[nr] = NULL;
976   flash_do_release (do_data);
977   key_addr = (uint8_t *)kd[kk].pubkey - prvkey_len;
978   kd[kk].pubkey = NULL;
979   if (clean_page_full)
980     flash_key_release_page (kk);
981   else
982     flash_key_release (key_addr, key_size);
983
984   if (admin_authorized == BY_ADMIN && kk == GPG_KEY_FOR_SIGNING)
985     {                   /* Recover admin keystring DO.  */
986       const uint8_t *ks_pw3 = gpg_do_read_simple (NR_DO_KEYSTRING_PW3);
987
988       if (ks_pw3 != NULL)
989         {
990           uint8_t ks0[KEYSTRING_SIZE];
991
992           ks0[0] = ks_pw3[0] | PW_LEN_KEYSTRING_BIT;
993           memcpy (KS_GET_SALT (ks0), KS_GET_SALT (ks_pw3), SALT_SIZE);
994           memcpy (KS_GET_KEYSTRING (ks0), keystring_md_pw3, KEYSTRING_MD_SIZE);
995           gpg_do_write_simple (NR_DO_KEYSTRING_PW3, ks0, KEYSTRING_SIZE);
996         }
997     }
998
999   if (--num_prv_keys == 0)
1000     {
1001       /* Delete PW1 and RC if any.  */
1002       gpg_do_write_simple (NR_DO_KEYSTRING_PW1, NULL, 0);
1003       gpg_do_write_simple (NR_DO_KEYSTRING_RC, NULL, 0);
1004
1005       ac_reset_pso_cds ();
1006       ac_reset_other ();
1007       if (admin_authorized == BY_USER)
1008         ac_reset_admin ();
1009     }
1010 }
1011
1012 static int
1013 gpg_do_write_prvkey (enum kind_of_key kk, const uint8_t *key_data,
1014                      int prvkey_len, const uint8_t *keystring_admin,
1015                      const uint8_t *pubkey)
1016 {
1017   uint8_t nr = get_do_ptr_nr_for_kk (kk);
1018   int attr = gpg_get_algo_attr (kk);;
1019   const uint8_t *p;
1020   int r;
1021   struct prvkey_data *pd;
1022   uint8_t *key_addr;
1023   const uint8_t *dek, *iv;
1024   struct key_data_internal kdi;
1025   uint8_t *pubkey_allocated_here = NULL;
1026   int pubkey_len;
1027   uint8_t ks[KEYSTRING_MD_SIZE];
1028   enum kind_of_key kk0;
1029
1030   DEBUG_INFO ("Key import\r\n");
1031   DEBUG_SHORT (prvkey_len);
1032
1033   /* Delete it first, if any.  */
1034   gpg_do_delete_prvkey (kk, CLEAN_SINGLE);
1035
1036   pd = (struct prvkey_data *)malloc (sizeof (struct prvkey_data));
1037   if (pd == NULL)
1038     return -1;
1039
1040   if (attr == ALGO_NISTP256R1 || attr == ALGO_SECP256K1)
1041     {
1042       pubkey_len = prvkey_len * 2;
1043       if (prvkey_len != 32)
1044         return -1;
1045     }
1046   else if (attr == ALGO_ED25519)
1047     {
1048       pubkey_len = prvkey_len / 2;
1049       if (prvkey_len != 64)
1050         return -1;
1051     }
1052   else                          /* RSA */
1053     {
1054       int key_size = gpg_get_algo_attr_key_size (kk, GPG_KEY_STORAGE);
1055
1056       pubkey_len = prvkey_len;
1057       if (prvkey_len + pubkey_len != key_size)
1058         return -1;
1059     }
1060
1061   if (pubkey == NULL)
1062     {
1063       if (attr == ALGO_SECP256K1)
1064         pubkey_allocated_here = ecc_compute_public_p256k1 (key_data);
1065       else if (attr == ALGO_NISTP256R1)
1066         pubkey_allocated_here = ecc_compute_public_p256r1 (key_data);
1067       else if (attr == ALGO_ED25519)
1068         pubkey_allocated_here = eddsa_compute_public_25519 (key_data);
1069       else                              /* RSA */
1070         pubkey_allocated_here = modulus_calc (key_data, prvkey_len);
1071
1072       if (pubkey_allocated_here == NULL)
1073         {
1074           free (pd);
1075           return -1;
1076         }
1077     }
1078
1079   DEBUG_INFO ("Getting keystore address...\r\n");
1080   key_addr = flash_key_alloc (kk);
1081   if (key_addr == NULL)
1082     {
1083       if (pubkey_allocated_here)
1084         {
1085           memset (pubkey_allocated_here, 0, pubkey_len);
1086           free (pubkey_allocated_here);
1087         }
1088       free (pd);
1089       return -1;
1090     }
1091   kd[kk].pubkey = key_addr + prvkey_len;
1092
1093   num_prv_keys++;
1094
1095   DEBUG_INFO ("key_addr: ");
1096   DEBUG_WORD ((uint32_t)key_addr);
1097
1098   memcpy (kdi.data, key_data, prvkey_len);
1099   memset ((uint8_t *)kdi.data + prvkey_len, 0, MAX_PRVKEY_LEN - prvkey_len);
1100
1101   compute_key_data_checksum (&kdi, prvkey_len, CKDC_CALC);
1102
1103   dek = random_bytes_get (); /* 32-byte random bytes */
1104   iv = dek + DATA_ENCRYPTION_KEY_SIZE;
1105   memcpy (pd->dek_encrypted_1, dek, DATA_ENCRYPTION_KEY_SIZE);
1106   memcpy (pd->dek_encrypted_2, dek, DATA_ENCRYPTION_KEY_SIZE);
1107   memcpy (pd->dek_encrypted_3, dek, DATA_ENCRYPTION_KEY_SIZE);
1108
1109   s2k (NULL, 0, (const uint8_t *)OPENPGP_CARD_INITIAL_PW1,
1110        strlen (OPENPGP_CARD_INITIAL_PW1), ks);
1111
1112   /* Handle existing keys and keystring DOs.  */
1113   gpg_do_write_simple (NR_DO_KEYSTRING_PW1, NULL, 0);
1114   gpg_do_write_simple (NR_DO_KEYSTRING_RC, NULL, 0);
1115   for (kk0 = 0; kk0 <= GPG_KEY_FOR_AUTHENTICATION; kk0++)
1116     if (kk0 != kk)
1117       {
1118         gpg_do_chks_prvkey (kk0, admin_authorized, keystring_md_pw3,
1119                             BY_USER, ks);
1120         gpg_do_chks_prvkey (kk0, BY_RESETCODE, NULL, 0, NULL);
1121       }
1122
1123   encrypt (dek, iv, (uint8_t *)&kdi, kdi_len (prvkey_len));
1124
1125   r = flash_key_write (key_addr, (const uint8_t *)kdi.data, prvkey_len,
1126                        pubkey_allocated_here? pubkey_allocated_here: pubkey,
1127                        pubkey_len);
1128   if (pubkey_allocated_here)
1129     {
1130       memset (pubkey_allocated_here, 0, pubkey_len);
1131       free (pubkey_allocated_here);
1132     }
1133
1134   if (r < 0)
1135     {
1136       random_bytes_free (dek);
1137       memset (pd, 0, sizeof (struct prvkey_data));
1138       free (pd);
1139       return r;
1140     }
1141
1142   memcpy (pd->iv, iv, INITIAL_VECTOR_SIZE);
1143   memcpy (pd->checksum_encrypted, CHECKSUM_ADDR (kdi, prvkey_len),
1144           DATA_ENCRYPTION_KEY_SIZE);
1145
1146   encrypt_dek (ks, pd->dek_encrypted_1);
1147
1148   memset (pd->dek_encrypted_2, 0, DATA_ENCRYPTION_KEY_SIZE);
1149
1150   if (keystring_admin)
1151     encrypt_dek (keystring_admin, pd->dek_encrypted_3);
1152   else
1153     memset (pd->dek_encrypted_3, 0, DATA_ENCRYPTION_KEY_SIZE);
1154
1155   p = flash_do_write (nr, (const uint8_t *)pd, sizeof (struct prvkey_data));
1156   do_ptr[nr] = p;
1157
1158   random_bytes_free (dek);
1159   memset (pd, 0, sizeof (struct prvkey_data));
1160   free (pd);
1161   if (p == NULL)
1162     return -1;
1163
1164   if (keystring_admin && kk == GPG_KEY_FOR_SIGNING)
1165     {
1166       const uint8_t *ks_admin = gpg_do_read_simple (NR_DO_KEYSTRING_PW3);
1167       uint8_t ks_info[KS_META_SIZE];
1168
1169       if (ks_admin != NULL && (ks_admin[0] & PW_LEN_KEYSTRING_BIT))
1170         {
1171           ks_info[0] = ks_admin[0] & PW_LEN_MASK;
1172           memcpy (KS_GET_SALT (ks_info), KS_GET_SALT (ks_admin), SALT_SIZE);
1173           gpg_do_write_simple (NR_DO_KEYSTRING_PW3, ks_info, KS_META_SIZE);
1174         }
1175       else
1176         {
1177           DEBUG_INFO ("No admin keystring!\r\n");
1178         }
1179     }
1180
1181   return 0;
1182 }
1183
1184 int
1185 gpg_do_chks_prvkey (enum kind_of_key kk,
1186                     int who_old, const uint8_t *old_ks,
1187                     int who_new, const uint8_t *new_ks)
1188 {
1189   uint8_t nr = get_do_ptr_nr_for_kk (kk);
1190   const uint8_t *do_data = do_ptr[nr];
1191   uint8_t dek[DATA_ENCRYPTION_KEY_SIZE];
1192   struct prvkey_data *pd;
1193   const uint8_t *p;
1194   uint8_t *dek_p;
1195   int update_needed = 0;
1196
1197   if (do_data == NULL)
1198     return 0;                   /* No private key */
1199
1200   pd = (struct prvkey_data *)malloc (sizeof (struct prvkey_data));
1201   if (pd == NULL)
1202     return -1;
1203
1204   memcpy (pd, &do_data[1], sizeof (struct prvkey_data));
1205
1206   dek_p = ((uint8_t *)pd) + INITIAL_VECTOR_SIZE
1207     + DATA_ENCRYPTION_KEY_SIZE * who_old;
1208   memcpy (dek, dek_p, DATA_ENCRYPTION_KEY_SIZE);
1209   if (who_new == 0)             /* Remove */
1210     {
1211       int i;
1212
1213       for (i = 0; i < DATA_ENCRYPTION_KEY_SIZE; i++)
1214         if (dek_p[i] != 0)
1215           {
1216             update_needed = 1;
1217             dek_p[i] = 0;
1218           }
1219     }
1220   else
1221     {
1222       decrypt_dek (old_ks, dek);
1223       encrypt_dek (new_ks, dek);
1224       dek_p += DATA_ENCRYPTION_KEY_SIZE * (who_new - who_old);
1225       if (memcmp (dek_p, dek, DATA_ENCRYPTION_KEY_SIZE) != 0)
1226         {
1227           memcpy (dek_p, dek, DATA_ENCRYPTION_KEY_SIZE);
1228           update_needed = 1;
1229         }
1230     }
1231
1232   if (update_needed)
1233     {
1234       flash_do_release (do_data);
1235       do_ptr[nr] = NULL;
1236       p = flash_do_write (nr, (const uint8_t *)pd, sizeof (struct prvkey_data));
1237       do_ptr[nr] = p;
1238     }
1239
1240   memset (pd, 0, sizeof (struct prvkey_data));
1241   free (pd);
1242   if (update_needed && p == NULL)
1243     return -1;
1244
1245   return 1;
1246 }
1247
1248
1249 static enum kind_of_key
1250 kkb_to_kk (uint8_t kk_byte)
1251 {
1252   enum kind_of_key kk;
1253
1254   if (kk_byte == 0xb6)
1255     kk = GPG_KEY_FOR_SIGNING;
1256   else if (kk_byte == 0xb8)
1257     kk = GPG_KEY_FOR_DECRYPTION;
1258   else                          /* 0xa4 */
1259     kk = GPG_KEY_FOR_AUTHENTICATION;
1260   return kk;
1261 }
1262
1263 /*
1264  * RSA-2048:
1265  * 4d, xx, xx, xx:    Extended Header List
1266  *   b6 00 (SIG) / b8 00 (DEC) / a4 00 (AUT)
1267  *   7f48, xx: cardholder private key template
1268  *       91 L<E>:        91=tag of E, L<E>: length of E
1269  *       92 Lh<P> Ll<P>: 92=tag of P, L<P>: length of P
1270  *       93 Lh<Q> Ll<Q>: 93=tag of Q, L<Q>: length of Q
1271  *   5f48, xx xx xx: cardholder private key
1272  *       <E: 4-byte>, <P: 128-byte>, <Q: 128-byte>
1273  *
1274  * RSA-4096:
1275  * 4d, 82, 02, 18:    Extended Header List
1276  *   b6 00 (SIG) / b8 00 (DEC) / a4 00 (AUT)
1277  *   7f48, 0a: cardholder private key template
1278  *       91 L<E>:        91=tag of E, L<E>: length of E
1279  *       92 82 Lh<P> Ll<P>: 92=tag of P, L<P>: length of P
1280  *       93 82 Lh<Q> Ll<Q>: 93=tag of Q, L<Q>: length of Q
1281  *   5f48, 82 02 04: cardholder private key
1282  *       <E: 4-byte>, <P: 256-byte>, <Q: 256-byte>
1283  *
1284  * ECDSA / ECDH / EdDSA:
1285  * 4d, 2a:    Extended Header List
1286  *   b6 00 (SIG) / b8 00 (DEC) / a4 00 (AUT)
1287  *   7f48, 02: cardholder private key template
1288  *       9x LEN: 9x=tag of private key d,  LEN=length of d
1289  *   5f48, 20: cardholder private key
1290  * <d: 32-byte>
1291  */
1292 static int
1293 proc_key_import (const uint8_t *data, int len)
1294 {
1295   int r;
1296   enum kind_of_key kk;
1297   const uint8_t *keystring_admin;
1298   int attr;
1299   const uint8_t *p = data;
1300
1301   if (admin_authorized == BY_ADMIN)
1302     keystring_admin = keystring_md_pw3;
1303   else
1304     keystring_admin = NULL;
1305
1306   DEBUG_BINARY (data, len);
1307
1308   if (*p++ != 0x4d)
1309     return 0;
1310
1311   /* length field */
1312   if (*p == 0x82)
1313     p += 3;
1314   else if (*p == 0x81)
1315     p += 2;
1316   else
1317     p += 1;
1318
1319   kk = kkb_to_kk (*p);
1320   if (kk == GPG_KEY_FOR_SIGNING)
1321     {
1322       ac_reset_pso_cds ();
1323       gpg_reset_digital_signature_counter ();
1324     }
1325   else
1326     ac_reset_other ();
1327
1328   attr = gpg_get_algo_attr (kk);
1329
1330   if ((len <= 12 && (attr == ALGO_NISTP256R1 || attr == ALGO_SECP256K1
1331                      || attr == ALGO_ED25519))
1332       || (len <= 22 && attr == ALGO_RSA2K) || (len <= 24 && attr == ALGO_RSA4K))
1333     {                                       /* Deletion of the key */
1334       gpg_do_delete_prvkey (kk, CLEAN_SINGLE);
1335       return 1;
1336     }
1337
1338   if (attr == ALGO_RSA2K)
1339     /* It should starts with 00 01 00 01 (E), skiping E (4-byte) */
1340     r = gpg_do_write_prvkey (kk, &data[26], len - 26, keystring_admin, NULL);
1341   else if (attr == ALGO_RSA4K)
1342     /* It should starts with 00 01 00 01 (E), skiping E (4-byte) */
1343     r = gpg_do_write_prvkey (kk, &data[28], len - 28, keystring_admin, NULL);
1344   else if (attr == ALGO_NISTP256R1 || attr == ALGO_SECP256K1)
1345     r = gpg_do_write_prvkey (kk, &data[12], len - 12, keystring_admin, NULL);
1346   else /* if (attr == ALGO_ED25519) */
1347     {
1348       uint8_t hash[64];
1349
1350       if (len - 12 != 32)
1351         return 1;               /* Error.  */
1352
1353       sha512 (&data[12], 32, hash);
1354       hash[0] &= 248;
1355       hash[31] &= 127;
1356       hash[31] |= 64;
1357       r = gpg_do_write_prvkey (kk, hash, 64, keystring_admin, NULL);
1358     }
1359
1360   if (r < 0)
1361     return 0;
1362   else
1363     return 1;
1364 }
1365
1366 static const uint16_t cmp_ch_data[] = {
1367   3,
1368   GPG_DO_NAME,
1369   GPG_DO_LANGUAGE,
1370   GPG_DO_SEX,
1371 };
1372
1373 static const uint16_t cmp_app_data[] = {
1374   3,
1375   GPG_DO_AID,
1376   GPG_DO_HIST_BYTES,
1377   GPG_DO_DISCRETIONARY,
1378 };
1379
1380 static const uint16_t cmp_discretionary[] = {
1381   8,
1382   GPG_DO_EXTCAP,
1383   GPG_DO_ALG_SIG, GPG_DO_ALG_DEC, GPG_DO_ALG_AUT,
1384   GPG_DO_PW_STATUS,
1385   GPG_DO_FP_ALL, GPG_DO_CAFP_ALL, GPG_DO_KGTIME_ALL
1386 };
1387
1388 static const uint16_t cmp_ss_temp[] = { 1, GPG_DO_DS_COUNT };
1389
1390 static const struct do_table_entry
1391 gpg_do_table[] = {
1392   /* Variables: Fixed size */
1393   { GPG_DO_SEX, DO_VAR, AC_ALWAYS, AC_ADMIN_AUTHORIZED, &do_ptr[0] },
1394   { GPG_DO_FP_SIG, DO_VAR, AC_ALWAYS, AC_ADMIN_AUTHORIZED, &do_ptr[1] },
1395   { GPG_DO_FP_DEC, DO_VAR, AC_ALWAYS, AC_ADMIN_AUTHORIZED, &do_ptr[2] },
1396   { GPG_DO_FP_AUT, DO_VAR, AC_ALWAYS, AC_ADMIN_AUTHORIZED, &do_ptr[3] },
1397   { GPG_DO_CAFP_1, DO_VAR, AC_ALWAYS, AC_ADMIN_AUTHORIZED, &do_ptr[4] },
1398   { GPG_DO_CAFP_2, DO_VAR, AC_ALWAYS, AC_ADMIN_AUTHORIZED, &do_ptr[5] },
1399   { GPG_DO_CAFP_3, DO_VAR, AC_ALWAYS, AC_ADMIN_AUTHORIZED, &do_ptr[6] },
1400   { GPG_DO_KGTIME_SIG, DO_VAR, AC_ALWAYS, AC_ADMIN_AUTHORIZED, &do_ptr[7] },
1401   { GPG_DO_KGTIME_DEC, DO_VAR, AC_ALWAYS, AC_ADMIN_AUTHORIZED, &do_ptr[8] },
1402   { GPG_DO_KGTIME_AUT, DO_VAR, AC_ALWAYS, AC_ADMIN_AUTHORIZED, &do_ptr[9] },
1403   /* Variables: Variable size */
1404   { GPG_DO_LOGIN_DATA, DO_VAR, AC_ALWAYS, AC_ADMIN_AUTHORIZED, &do_ptr[10] },
1405   { GPG_DO_URL, DO_VAR, AC_ALWAYS, AC_ADMIN_AUTHORIZED, &do_ptr[11] },
1406   { GPG_DO_NAME, DO_VAR, AC_ALWAYS, AC_ADMIN_AUTHORIZED, &do_ptr[12] },
1407   { GPG_DO_LANGUAGE, DO_VAR, AC_ALWAYS, AC_ADMIN_AUTHORIZED, &do_ptr[13] },
1408   /* Pseudo DO READ: calculated */
1409   { GPG_DO_HIST_BYTES, DO_PROC_READ, AC_ALWAYS, AC_NEVER, do_hist_bytes },
1410   { GPG_DO_FP_ALL, DO_PROC_READ, AC_ALWAYS, AC_NEVER, do_fp_all },
1411   { GPG_DO_CAFP_ALL, DO_PROC_READ, AC_ALWAYS, AC_NEVER, do_cafp_all },
1412   { GPG_DO_KGTIME_ALL, DO_PROC_READ, AC_ALWAYS, AC_NEVER, do_kgtime_all },
1413   /* Pseudo DO READ: calculated, not changeable by user */
1414   { GPG_DO_DS_COUNT, DO_PROC_READ, AC_ALWAYS, AC_NEVER, do_ds_count },
1415   { GPG_DO_AID, DO_PROC_READ, AC_ALWAYS, AC_NEVER, do_openpgpcard_aid },
1416   /* Pseudo DO READ/WRITE: calculated */
1417   { GPG_DO_PW_STATUS, DO_PROC_READWRITE, AC_ALWAYS, AC_ADMIN_AUTHORIZED,
1418     rw_pw_status },
1419   { GPG_DO_ALG_SIG, DO_PROC_READWRITE, AC_ALWAYS, AC_ADMIN_AUTHORIZED,
1420     rw_algorithm_attr },
1421   { GPG_DO_ALG_DEC, DO_PROC_READWRITE, AC_ALWAYS, AC_ADMIN_AUTHORIZED,
1422     rw_algorithm_attr },
1423   { GPG_DO_ALG_AUT, DO_PROC_READWRITE, AC_ALWAYS, AC_ADMIN_AUTHORIZED,
1424     rw_algorithm_attr },
1425   /* Fixed data */
1426   { GPG_DO_EXTCAP, DO_FIXED, AC_ALWAYS, AC_NEVER, extended_capabilities },
1427   /* Compound data: Read access only */
1428   { GPG_DO_CH_DATA, DO_CMP_READ, AC_ALWAYS, AC_NEVER, cmp_ch_data },
1429   { GPG_DO_APP_DATA, DO_CMP_READ, AC_ALWAYS, AC_NEVER, cmp_app_data },
1430   { GPG_DO_DISCRETIONARY, DO_CMP_READ, AC_ALWAYS, AC_NEVER, cmp_discretionary },
1431   { GPG_DO_SS_TEMP, DO_CMP_READ, AC_ALWAYS, AC_NEVER, cmp_ss_temp },
1432   /* Simple data: write access only */
1433   { GPG_DO_RESETTING_CODE, DO_PROC_WRITE, AC_NEVER, AC_ADMIN_AUTHORIZED,
1434     proc_resetting_code },
1435   /* Compound data: Write access only */
1436   { GPG_DO_KEY_IMPORT, DO_PROC_WRITE, AC_NEVER, AC_ADMIN_AUTHORIZED,
1437     proc_key_import },
1438 #if 0
1439   /* Card holder certificate is handled in special way, as its size is big */
1440   { GPG_DO_CH_CERTIFICATE, DO_VAR, AC_ALWAYS, AC_ADMIN_AUTHORIZED, NULL },
1441 #endif
1442 };
1443
1444 #define NUM_DO_ENTRIES (int)(sizeof (gpg_do_table) \
1445                              / sizeof (struct do_table_entry))
1446
1447 /*
1448  * Reading data from Flash ROM, initialize DO_PTR, PW_ERR_COUNTERS, etc.
1449  */
1450 void
1451 gpg_data_scan (const uint8_t *p_start)
1452 {
1453   const uint8_t *p;
1454   int i;
1455   const uint8_t *dsc_h14_p, *dsc_l10_p;
1456   int dsc_h14, dsc_l10;
1457
1458   dsc_h14_p = dsc_l10_p = NULL;
1459   pw1_lifetime_p = NULL;
1460   pw_err_counter_p[PW_ERR_PW1] = NULL;
1461   pw_err_counter_p[PW_ERR_RC] = NULL;
1462   pw_err_counter_p[PW_ERR_PW3] = NULL;
1463   algo_attr_sig_p = algo_attr_dec_p = algo_attr_aut_p = NULL;
1464
1465   /* Traverse DO, counters, etc. in DATA pool */
1466   p = p_start;
1467   while (*p != NR_EMPTY)
1468     {
1469       uint8_t nr = *p++;
1470       uint8_t second_byte = *p;
1471
1472       if (nr == 0x00 && second_byte == 0x00)
1473         p++;                    /* Skip released word */
1474       else
1475         {
1476           if (nr < 0x80)
1477             {
1478               /* It's Data Object */
1479               do_ptr[nr] = p;
1480               p += second_byte + 1; /* second_byte has length */
1481
1482               if (((uint32_t)p & 1))
1483                 p++;
1484             }
1485           else if (nr >= 0x80 && nr <= 0xbf)
1486             /* Encoded data of Digital Signature Counter: upper 14-bit */
1487             {
1488               dsc_h14_p = p - 1;
1489               p++;
1490             }
1491           else if (nr >= 0xc0 && nr <= 0xc3)
1492             /* Encoded data of Digital Signature Counter: lower 10-bit */
1493             {
1494               dsc_l10_p = p - 1;
1495               p++;
1496             }
1497           else
1498             switch (nr)
1499               {
1500               case NR_BOOL_PW1_LIFETIME:
1501                 pw1_lifetime_p = p - 1;
1502                 p++;
1503                 break;
1504               case NR_KEY_ALGO_ATTR_SIG:
1505                 algo_attr_sig_p = p - 1;
1506                 p++;
1507                 break;
1508               case NR_KEY_ALGO_ATTR_DEC:
1509                 algo_attr_dec_p = p - 1;
1510                 p++;
1511                 break;
1512               case NR_KEY_ALGO_ATTR_AUT:
1513                 algo_attr_aut_p = p - 1;
1514                 p++;
1515                 break;
1516               case NR_COUNTER_123:
1517                 p++;
1518                 if (second_byte <= PW_ERR_PW3)
1519                   pw_err_counter_p[second_byte] = p;
1520                 p += 2;
1521                 break;
1522               default:
1523                 /* Something going wrong.  ignore this word. */
1524                 p++;
1525                 break;
1526               }
1527         }
1528     }
1529
1530   flash_set_data_pool_last (p);
1531
1532   num_prv_keys = 0;
1533   if (do_ptr[NR_DO_PRVKEY_SIG] != NULL)
1534     num_prv_keys++;
1535   if (do_ptr[NR_DO_PRVKEY_DEC] != NULL)
1536     num_prv_keys++;
1537   if (do_ptr[NR_DO_PRVKEY_AUT] != NULL)
1538     num_prv_keys++;
1539
1540   data_objects_number_of_bytes = 0;
1541   for (i = 0; i < NR_DO__LAST__; i++)
1542     if (do_ptr[i] != NULL)
1543       data_objects_number_of_bytes += *do_ptr[i];
1544
1545   if (dsc_l10_p == NULL)
1546     dsc_l10 = 0;
1547   else
1548     dsc_l10 = ((*dsc_l10_p - 0xc0) << 8) | *(dsc_l10_p + 1);
1549
1550   if (dsc_h14_p == NULL)
1551     dsc_h14 = 0;
1552   else
1553     {
1554       dsc_h14 = ((*dsc_h14_p - 0x80) << 8) | *(dsc_h14_p + 1);
1555       if (dsc_l10_p == NULL)
1556         DEBUG_INFO ("something wrong in DSC\r\n"); /* weird??? */
1557       else if (dsc_l10_p < dsc_h14_p)
1558         /* Possibly, power off during writing dsc_l10 */
1559         dsc_l10 = 0;
1560     }
1561
1562   digital_signature_counter = (dsc_h14 << 10) | dsc_l10;
1563 }
1564
1565 /*
1566  * Write all data to newly allocated Flash ROM page (from P_START),
1567  * updating PW1_LIFETIME_P, PW_ERR_COUNTER_P, and DO_PTR.
1568  * Called by flash_copying_gc.
1569  */
1570 void
1571 gpg_data_copy (const uint8_t *p_start)
1572 {
1573   const uint8_t *p;
1574   int i;
1575   int v;
1576
1577   p = gpg_write_digital_signature_counter (p_start, digital_signature_counter);
1578
1579   if (pw1_lifetime_p != NULL)
1580     {
1581       flash_bool_write_internal (p, NR_BOOL_PW1_LIFETIME);
1582       pw1_lifetime_p = p;
1583       p += 2;
1584     }
1585
1586   if (algo_attr_sig_p != NULL)
1587     {
1588       flash_enum_write_internal (p, NR_KEY_ALGO_ATTR_SIG, algo_attr_sig_p[1]);
1589       algo_attr_sig_p = p;
1590       p += 2;
1591     }
1592
1593   if (algo_attr_dec_p != NULL)
1594     {
1595       flash_enum_write_internal (p, NR_KEY_ALGO_ATTR_DEC, algo_attr_dec_p[1]);
1596       algo_attr_dec_p = p;
1597       p += 2;
1598     }
1599
1600   if (algo_attr_aut_p != NULL)
1601     {
1602       flash_enum_write_internal (p, NR_KEY_ALGO_ATTR_AUT, algo_attr_aut_p[1]);
1603       algo_attr_aut_p = p;
1604       p += 2;
1605     }
1606
1607   for (i = 0; i < 3; i++)
1608     if ((v = flash_cnt123_get_value (pw_err_counter_p[i])) != 0)
1609       {
1610         flash_cnt123_write_internal (p, i, v);
1611         pw_err_counter_p[i] = p + 2;
1612         p += 4;
1613       }
1614
1615   data_objects_number_of_bytes = 0;
1616   for (i = 0; i < NR_DO__LAST__; i++)
1617     if (do_ptr[i] != NULL)
1618       {
1619         const uint8_t *do_data = do_ptr[i];
1620         int len = do_data[0];
1621
1622         flash_do_write_internal (p, i, &do_data[1], len);
1623         do_ptr[i] = p + 1;
1624         p += 2 + ((len + 1) & ~1);
1625         data_objects_number_of_bytes += len;
1626       }
1627
1628   flash_set_data_pool_last (p);
1629 }
1630
1631 static const struct do_table_entry *
1632 get_do_entry (uint16_t tag)
1633 {
1634   int i;
1635
1636   for (i = 0; i < NUM_DO_ENTRIES; i++)
1637     if (gpg_do_table[i].tag == tag)
1638       return &gpg_do_table[i];
1639
1640   return NULL;
1641 }
1642
1643 static void
1644 copy_do_1 (uint16_t tag, const uint8_t *do_data, int with_tag)
1645 {
1646   int len;
1647
1648   if (with_tag)
1649     {
1650       copy_tag (tag);
1651
1652       if (do_data[0] >= 128)
1653         *res_p++ = 0x81;
1654
1655       len = do_data[0] + 1;
1656     }
1657   else
1658     {
1659       len = do_data[0];
1660       do_data++;
1661     }
1662
1663   memcpy (res_p, do_data, len);
1664   res_p += len;
1665 }
1666
1667 static int
1668 copy_do (const struct do_table_entry *do_p, int with_tag)
1669 {
1670   if (do_p == NULL)
1671     return 0;
1672
1673   if (!ac_check_status (do_p->ac_read))
1674     return -1;
1675
1676   switch (do_p->do_type)
1677     {
1678     case DO_FIXED:
1679       {
1680         const uint8_t *do_data = (const uint8_t *)do_p->obj;
1681         if (do_data == NULL)
1682           return 0;
1683         else
1684           copy_do_1 (do_p->tag, do_data, with_tag);
1685         break;
1686       }
1687     case DO_VAR:
1688       {
1689         const uint8_t *do_data = *(const uint8_t **)do_p->obj;
1690         if (do_data == NULL)
1691           return 0;
1692         else
1693           copy_do_1 (do_p->tag, do_data, with_tag);
1694         break;
1695       }
1696     case DO_CMP_READ:
1697       {
1698         int i;
1699         const uint16_t *cmp_data = (const uint16_t *)do_p->obj;
1700         int num_components = cmp_data[0];
1701         uint8_t *len_p = NULL;
1702
1703         if (with_tag)
1704           {
1705             copy_tag (do_p->tag);
1706             *res_p++ = 0x81;    /* Assume it's less than 256 */
1707             len_p = res_p;
1708             *res_p++ = 0;       /* for now */
1709           }
1710
1711         for (i = 0; i < num_components; i++)
1712           {
1713             uint16_t tag0;
1714             const struct do_table_entry *do0_p;
1715
1716             tag0 = cmp_data[i+1];
1717             do0_p = get_do_entry (tag0);
1718             if (copy_do (do0_p, 1) < 0)
1719               return -1;
1720           }
1721
1722         if (len_p)
1723           *len_p = res_p - len_p - 1;
1724         break;
1725       }
1726     case DO_PROC_READ:
1727       {
1728         int (*do_func)(uint16_t, int) = (int (*)(uint16_t, int))do_p->obj;
1729
1730         return do_func (do_p->tag, with_tag);
1731       }
1732     case DO_PROC_READWRITE:
1733       {
1734         int (*rw_func)(uint16_t, int, const uint8_t *, int, int)
1735           = (int (*)(uint16_t, int, const uint8_t *, int, int))do_p->obj;
1736
1737         return rw_func (do_p->tag, with_tag, NULL, 0, 0);
1738       }
1739     case DO_PROC_WRITE:
1740       return -1;
1741     }
1742
1743   return 1;
1744 }
1745
1746 /*
1747  * Process GET_DATA request on Data Object specified by TAG
1748  *   Call write_res_adpu to fill data returned
1749  */
1750 void
1751 gpg_do_get_data (uint16_t tag, int with_tag)
1752 {
1753 #if defined(CERTDO_SUPPORT)
1754   if (tag == GPG_DO_CH_CERTIFICATE)
1755     {
1756       apdu.res_apdu_data = &ch_certificate_start;
1757       apdu.res_apdu_data_len = ((apdu.res_apdu_data[2] << 8) | apdu.res_apdu_data[3]);
1758       if (apdu.res_apdu_data_len == 0xffff)
1759         {
1760           apdu.res_apdu_data_len = 0;
1761           GPG_NO_RECORD ();
1762         }
1763       else
1764         /* Add length of (tag+len) */
1765         apdu.res_apdu_data_len += 4;
1766     }
1767   else
1768 #endif
1769     {
1770       const struct do_table_entry *do_p = get_do_entry (tag);
1771
1772       res_p = res_APDU;
1773
1774       DEBUG_INFO ("   ");
1775       DEBUG_SHORT (tag);
1776
1777       if (do_p)
1778         {
1779           if (copy_do (do_p, with_tag) < 0)
1780             /* Overwriting partially written result  */
1781             GPG_SECURITY_FAILURE ();
1782           else
1783             {
1784               res_APDU_size = res_p - res_APDU;
1785               GPG_SUCCESS ();
1786             }
1787         }
1788       else
1789         GPG_NO_RECORD ();
1790     }
1791 }
1792
1793 void
1794 gpg_do_put_data (uint16_t tag, const uint8_t *data, int len)
1795 {
1796   const struct do_table_entry *do_p = get_do_entry (tag);
1797
1798   DEBUG_INFO ("   ");
1799   DEBUG_SHORT (tag);
1800
1801   if (do_p)
1802     {
1803       if (!ac_check_status (do_p->ac_write))
1804         {
1805           GPG_SECURITY_FAILURE ();
1806           return;
1807         }
1808
1809       switch (do_p->do_type)
1810         {
1811         case DO_FIXED:
1812         case DO_CMP_READ:
1813         case DO_PROC_READ:
1814           GPG_SECURITY_FAILURE ();
1815           break;
1816         case DO_VAR:
1817           {
1818             const uint8_t **do_data_p = (const uint8_t **)do_p->obj;
1819
1820             if (*do_data_p)
1821               flash_do_release (*do_data_p);
1822
1823             if (len == 0)
1824               {
1825                 /* make DO empty */
1826                 *do_data_p = NULL;
1827                 GPG_SUCCESS ();
1828               }
1829             else if (len > 255)
1830               GPG_MEMORY_FAILURE ();
1831             else
1832               {
1833                 int nr = do_tag_to_nr (tag);
1834
1835                 if (nr < 0)
1836                   GPG_MEMORY_FAILURE ();
1837                 else
1838                   {
1839                     *do_data_p = NULL;
1840                     *do_data_p = flash_do_write (nr, data, len);
1841                     if (*do_data_p)
1842                       GPG_SUCCESS ();
1843                     else
1844                       GPG_MEMORY_FAILURE ();
1845                   }
1846               }
1847             break;
1848           }
1849         case DO_PROC_READWRITE:
1850           {
1851             int (*rw_func)(uint16_t, int, const uint8_t *, int, int)
1852               = (int (*)(uint16_t, int, const uint8_t *, int, int))do_p->obj;
1853
1854             if (rw_func (tag, 0, data, len, 1))
1855               GPG_SUCCESS ();
1856             else
1857               GPG_ERROR ();
1858             break;
1859           }
1860         case DO_PROC_WRITE:
1861           {
1862             int (*proc_func)(const uint8_t *, int)
1863               = (int (*)(const uint8_t *, int))do_p->obj;
1864
1865             if (proc_func (data, len))
1866               GPG_SUCCESS ();
1867             else
1868               GPG_ERROR ();
1869             break;
1870           }
1871         }
1872     }
1873   else
1874     GPG_NO_RECORD ();
1875 }
1876
1877 void
1878 gpg_do_public_key (uint8_t kk_byte)
1879 {
1880   enum kind_of_key kk = kkb_to_kk (kk_byte);
1881   int attr = gpg_get_algo_attr (kk);
1882   int pubkey_len = gpg_get_algo_attr_key_size (kk, GPG_KEY_PUBLIC);
1883   const uint8_t *pubkey = kd[kk].pubkey;
1884
1885   DEBUG_INFO ("Public key\r\n");
1886   DEBUG_BYTE (kk_byte);
1887
1888   if (pubkey == NULL)
1889     {
1890       DEBUG_INFO ("none.\r\n");
1891       GPG_NO_RECORD ();
1892       return;
1893     }
1894
1895   res_p = res_APDU;
1896
1897   /* TAG */
1898   *res_p++ = 0x7f; *res_p++ = 0x49;
1899
1900   if (attr == ALGO_NISTP256R1 || attr == ALGO_SECP256K1)
1901     {                           /* ECDSA or ECDH */
1902       /* LEN */
1903       *res_p++ = 2 + 1 + 64;
1904       {
1905         /*TAG*/          /* LEN = 1+64 */
1906         *res_p++ = 0x86; *res_p++ = 0x41;
1907         *res_p++ = 0x04;        /* No compression of EC point.  */
1908         /* 64-byte binary (big endian): X || Y */
1909         memcpy (res_p, pubkey, 64);
1910         res_p += 64;
1911       }
1912     }
1913   else if (attr == ALGO_ED25519)
1914     {                           /* EdDSA */
1915       /* LEN */
1916       *res_p++ = 2 + 32;
1917       {
1918         /*TAG*/          /* LEN = 32 */
1919         *res_p++ = 0x86; *res_p++ = 0x20;
1920         /* 32-byte binary (little endian): Y with parity */
1921         memcpy (res_p, pubkey, 32);
1922         res_p += 32;
1923       }
1924     }
1925   else
1926     {                           /* RSA */
1927       /* LEN = 9+256or512 */
1928       *res_p++ = 0x82; *res_p++ = pubkey_len > 256? 0x02: 0x01; *res_p++ = 0x09;
1929
1930       {
1931         /*TAG*/          /* LEN = 256or512 */
1932         *res_p++ = 0x81;
1933         *res_p++ = 0x82; *res_p++ = pubkey_len > 256? 0x02: 0x01;*res_p++ = 0x00;
1934         /* PUBKEY_LEN-byte binary (big endian) */
1935         memcpy (res_p, pubkey, pubkey_len);
1936         res_p += pubkey_len;
1937       }
1938       {
1939         /*TAG*/          /* LEN= 3 */
1940         *res_p++ = 0x82; *res_p++ = 3;
1941         /* 3-byte E=0x10001 (big endian) */
1942         *res_p++ = 0x01; *res_p++ = 0x00; *res_p++ = 0x01;
1943       }
1944     }
1945
1946   /* Success */
1947   res_APDU_size = res_p - res_APDU;
1948   GPG_SUCCESS ();
1949
1950   DEBUG_INFO ("done.\r\n");
1951   return;
1952 }
1953
1954 const uint8_t *
1955 gpg_do_read_simple (uint8_t nr)
1956 {
1957   const uint8_t *do_data;
1958
1959   do_data = do_ptr[nr];
1960   if (do_data == NULL)
1961     return NULL;
1962
1963   return do_data+1;
1964 }
1965
1966 void
1967 gpg_do_write_simple (uint8_t nr, const uint8_t *data, int size)
1968 {
1969   const uint8_t **do_data_p;
1970
1971   do_data_p = (const uint8_t **)&do_ptr[nr];
1972   if (*do_data_p)
1973     flash_do_release (*do_data_p);
1974
1975   if (data != NULL)
1976     {
1977       *do_data_p = NULL;
1978       *do_data_p = flash_do_write (nr, data, size);
1979       if (*do_data_p == NULL)
1980         flash_warning ("DO WRITE ERROR");
1981     }
1982   else
1983     *do_data_p = NULL;
1984 }
1985
1986 #ifdef KEYGEN_SUPPORT
1987 void
1988 gpg_do_keygen (uint8_t kk_byte)
1989 {
1990   enum kind_of_key kk = kkb_to_kk (kk_byte);
1991   int pubkey_len = gpg_get_algo_attr_key_size (kk, GPG_KEY_PUBLIC);
1992   const uint8_t *keystring_admin;
1993   uint8_t *p_q_modulus;
1994   const uint8_t *p_q;
1995   const uint8_t *modulus;
1996   int r;
1997
1998   DEBUG_INFO ("Keygen\r\n");
1999   DEBUG_BYTE (kk_byte);
2000
2001   if (admin_authorized == BY_ADMIN)
2002     keystring_admin = keystring_md_pw3;
2003   else
2004     keystring_admin = NULL;
2005
2006   p_q_modulus = rsa_genkey (pubkey_len);
2007   if (p_q_modulus == NULL)
2008     {
2009       GPG_MEMORY_FAILURE ();
2010       return;
2011     }
2012
2013   p_q = p_q_modulus;
2014   modulus = p_q_modulus + pubkey_len;
2015
2016   r = gpg_do_write_prvkey (kk, p_q, pubkey_len, keystring_admin, modulus);
2017   memset (p_q_modulus, 0, pubkey_len * 2);
2018   free (p_q_modulus);
2019   if (r < 0)
2020     {
2021       GPG_ERROR ();
2022       return;
2023     }
2024
2025   DEBUG_INFO ("Calling gpg_do_public_key...\r\n");
2026
2027   if (kk == GPG_KEY_FOR_SIGNING)
2028     {
2029       const uint8_t *pw = (const uint8_t *)OPENPGP_CARD_INITIAL_PW1;
2030       uint8_t keystring[KEYSTRING_MD_SIZE];
2031
2032       /* GnuPG expects it's ready for signing. */
2033       /* Don't call ac_reset_pso_cds here, but load the private key */
2034
2035       gpg_reset_digital_signature_counter ();
2036       s2k (NULL, 0, pw, strlen (OPENPGP_CARD_INITIAL_PW1), keystring);
2037       gpg_do_load_prvkey (GPG_KEY_FOR_SIGNING, BY_USER, keystring);
2038     }
2039   else
2040     ac_reset_other ();
2041
2042   gpg_do_public_key (kk_byte);
2043 }
2044 #endif