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