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