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