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