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