add factory reset support (not-full yet)
[gnuk/gnuk.git] / src / openpgp.c
1 /*
2  * openpgp.c -- OpenPGP card protocol support
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 <chopstx.h>
28 #include <eventflag.h>
29
30 #include "config.h"
31
32 #include "gnuk.h"
33 #include "sys.h"
34 #include "status-code.h"
35 #include "sha256.h"
36 #include "random.h"
37
38 static struct eventflag *openpgp_comm;
39
40 #define ADMIN_PASSWD_MINLEN 8
41
42 #define CLS(a) a.cmd_apdu_head[0]
43 #define INS(a) a.cmd_apdu_head[1]
44 #define P1(a) a.cmd_apdu_head[2]
45 #define P2(a) a.cmd_apdu_head[3]
46
47 #define INS_VERIFY                              0x20
48 #define INS_CHANGE_REFERENCE_DATA               0x24
49 #define INS_PSO                                 0x2a
50 #define INS_RESET_RETRY_COUNTER                 0x2c
51 #define INS_ACTIVATE_FILE                       0x44
52 #define INS_PGP_GENERATE_ASYMMETRIC_KEY_PAIR    0x47
53 #define INS_EXTERNAL_AUTHENTICATE               0x82
54 #define INS_GET_CHALLENGE                       0x84
55 #define INS_INTERNAL_AUTHENTICATE               0x88
56 #define INS_SELECT_FILE                         0xa4
57 #define INS_READ_BINARY                         0xb0
58 #define INS_GET_DATA                            0xca
59 #define INS_WRITE_BINARY                        0xd0
60 #define INS_UPDATE_BINARY                       0xd6
61 #define INS_PUT_DATA                            0xda
62 #define INS_PUT_DATA_ODD                        0xdb    /* For key import */
63 #define INS_TERMINATE_DF                        0xe6
64
65 static const uint8_t *challenge; /* Random bytes */
66
67 static const uint8_t
68 select_file_TOP_result[] __attribute__ ((aligned (1))) = {
69   0x00, 0x00,        /* unused */
70   0x00, 0x00,        /* number of bytes in this directory: to be filled */
71   0x3f, 0x00,        /* field of selected file: MF, 3f00 */
72   0x38,                 /* it's DF */
73   0xff,                 /* unused */
74   0xff, 0x44, 0x44,     /* access conditions */
75   0x01,                 /* status of the selected file (OK, unblocked) */
76   0x05,                 /* number of bytes of data follow */
77     0x03,                       /* Features: unused */
78     0x01,                       /* number of subdirectories (OpenPGP) */
79     0x01,                       /* number of elementary files (SerialNo) */
80     0x00,                       /* number of secret codes */
81     0x00,                       /* Unused */
82   0x00, 0x00            /* PIN status: OK, PIN blocked?: No */
83 };
84
85 void
86 set_res_sw (uint8_t sw1, uint8_t sw2)
87 {
88   apdu.sw = (sw1 << 8) | sw2;
89 }
90
91 #define FILE_NONE       0
92 #define FILE_DF_OPENPGP 1
93 #define FILE_MF         2
94 #define FILE_EF_DIR     3
95 #define FILE_EF_SERIAL_NO       4
96 #define FILE_EF_UPDATE_KEY_0    5
97 #define FILE_EF_UPDATE_KEY_1    6
98 #define FILE_EF_UPDATE_KEY_2    7
99 #define FILE_EF_UPDATE_KEY_3    8
100 #define FILE_EF_CH_CERTIFICATE  9
101 #define FILE_CARD_TERMINATED_OPENPGP    254
102 #define FILE_CARD_TERMINATED    255
103
104 static uint8_t file_selection;
105
106 static void
107 gpg_init (void)
108 {
109   const uint8_t *flash_data_start;
110
111   flash_init_keys ();
112   flash_data_start = flash_init ();
113
114   if (flash_data_start == NULL)
115     file_selection = FILE_CARD_TERMINATED;
116   else
117     file_selection = FILE_NONE;
118
119   gpg_data_scan (flash_data_start);
120 }
121
122 static void
123 gpg_fini (void)
124 {
125   ac_fini ();
126 }
127
128 #if defined(PINPAD_SUPPORT)
129 /*
130  * Let user input PIN string.
131  * Return length of the string.
132  * The string itself is in PIN_INPUT_BUFFER.
133  */
134 static int
135 get_pinpad_input (int msg_code)
136 {
137   int r;
138
139   led_blink (LED_START_COMMAND);
140   r = pinpad_getline (msg_code, 8000000);
141   led_blink (LED_FINISH_COMMAND);
142   return r;
143 }
144 #endif
145
146 static void
147 cmd_verify (void)
148 {
149   int len;
150   uint8_t p1 = P1 (apdu);
151   uint8_t p2 = P2 (apdu);
152   int r;
153   const uint8_t *pw;
154
155   DEBUG_INFO (" - VERIFY\r\n");
156   DEBUG_BYTE (p2);
157
158   len = apdu.cmd_apdu_data_len;
159   pw = apdu.cmd_apdu_data;
160
161   if (len == 0)
162     {
163       if (p1 == 0)
164         {                       /* This is to examine status.  */
165           if (p2 == 0x81)
166             r = ac_check_status (AC_PSO_CDS_AUTHORIZED);
167           else if (p2 == 0x82)
168             r = ac_check_status (AC_OTHER_AUTHORIZED);
169           else
170             r = ac_check_status (AC_ADMIN_AUTHORIZED);
171
172           if (r)
173             GPG_SUCCESS ();     /* If authentication done already, return success.  */
174           else
175             {            /* If not, return retry counter, encoded.  */
176               r = gpg_pw_get_retry_counter (p2);
177               set_res_sw (0x63, 0xc0 | (r&0x0f));
178             }
179         }
180       else if (p1 == 0xff)
181         {                       /* Reset the status.  */
182           if (p2 == 0x81)
183             ac_reset_pso_cds ();
184           else if (p2 == 0x82)
185             ac_reset_other ();
186           else
187             ac_reset_admin ();
188           GPG_SUCCESS ();
189         }
190       else
191         GPG_BAD_P1_P2 ();
192       return;
193     }
194
195   /* This is real authentication.  */
196   if (p2 == 0x81)
197     r = verify_pso_cds (pw, len);
198   else if (p2 == 0x82)
199     r = verify_other (pw, len);
200   else
201     r = verify_admin (pw, len);
202
203   if (r < 0)
204     {
205       DEBUG_INFO ("failed\r\n");
206       GPG_SECURITY_FAILURE ();
207     }
208   else if (r == 0)
209     {
210       DEBUG_INFO ("blocked\r\n");
211       GPG_SECURITY_AUTH_BLOCKED ();
212     }
213   else
214     {
215       DEBUG_INFO ("good\r\n");
216       GPG_SUCCESS ();
217     }
218 }
219
220 int
221 gpg_change_keystring (int who_old, const uint8_t *old_ks,
222                       int who_new, const uint8_t *new_ks)
223 {
224   int r;
225   int prv_keys_exist = 0;
226
227   r = gpg_do_load_prvkey (GPG_KEY_FOR_SIGNING, who_old, old_ks);
228   if (r < 0)
229     return r;
230
231   if (r > 0)
232     prv_keys_exist++;
233
234   r = gpg_do_chks_prvkey (GPG_KEY_FOR_SIGNING, who_old, old_ks,
235                           who_new, new_ks);
236   if (r < 0)
237     return -2;
238
239   r = gpg_do_load_prvkey (GPG_KEY_FOR_DECRYPTION, who_old, old_ks);
240   if (r < 0)
241     return r;
242
243   if (r > 0)
244     prv_keys_exist++;
245
246   r = gpg_do_chks_prvkey (GPG_KEY_FOR_DECRYPTION, who_old, old_ks,
247                           who_new, new_ks);
248   if (r < 0)
249     return -2;
250
251   r = gpg_do_load_prvkey (GPG_KEY_FOR_AUTHENTICATION, who_old, old_ks);
252   if (r < 0)
253     return r;
254
255   if (r > 0)
256     prv_keys_exist++;
257
258   r = gpg_do_chks_prvkey (GPG_KEY_FOR_AUTHENTICATION, who_old, old_ks,
259                           who_new, new_ks);
260   if (r < 0)
261     return -2;
262
263   if (prv_keys_exist)
264     return 1;
265   else
266     return 0;
267 }
268
269 static void
270 cmd_change_password (void)
271 {
272   uint8_t old_ks[KEYSTRING_MD_SIZE];
273   uint8_t new_ks0[KEYSTRING_SIZE];
274   uint8_t *new_salt = KS_GET_SALT (new_ks0);
275   int newsalt_len = SALT_SIZE;
276   uint8_t *new_ks = KS_GET_KEYSTRING (new_ks0);
277   uint8_t p1 = P1 (apdu);       /* 0: change (old+new), 1: exchange (new) */
278   uint8_t p2 = P2 (apdu);
279   int len;
280   uint8_t *pw, *newpw;
281   int pw_len, newpw_len;
282   int who = p2 - 0x80;
283   int who_old;
284   int r;
285   int pw3_null = 0;
286   const uint8_t *salt;
287   int salt_len;
288   const uint8_t *ks_pw3;
289
290   DEBUG_INFO ("Change PW\r\n");
291   DEBUG_BYTE (who);
292
293   len = apdu.cmd_apdu_data_len;
294   pw = apdu.cmd_apdu_data;
295
296   if (p1 != 0)
297     {
298       GPG_FUNCTION_NOT_SUPPORTED ();
299       return;
300     }
301
302   if (who == BY_USER)                   /* PW1 */
303     {
304       const uint8_t *ks_pw1 = gpg_do_read_simple (NR_DO_KEYSTRING_PW1);
305
306       who_old = who;
307       pw_len = verify_user_0 (AC_PSO_CDS_AUTHORIZED, pw, len, -1, ks_pw1, 0);
308
309       if (ks_pw1 == NULL)
310         {
311           salt = NULL;
312           salt_len = 0;
313         }
314       else
315         {
316           salt = KS_GET_SALT (ks_pw1);
317           salt_len = SALT_SIZE;
318         }
319
320       if (pw_len < 0)
321         {
322           DEBUG_INFO ("permission denied.\r\n");
323           GPG_SECURITY_FAILURE ();
324           return;
325         }
326       else if (pw_len == 0)
327         {
328           DEBUG_INFO ("blocked.\r\n");
329           GPG_SECURITY_AUTH_BLOCKED ();
330           return;
331         }
332       else
333         {
334           newpw = pw + pw_len;
335           newpw_len = len - pw_len;
336           ks_pw3 = gpg_do_read_simple (NR_DO_KEYSTRING_PW3);
337
338           /* Check length of password for admin-less mode.  */
339           if (ks_pw3 == NULL && newpw_len < ADMIN_PASSWD_MINLEN)
340             {
341               DEBUG_INFO ("new password length is too short.");
342               GPG_CONDITION_NOT_SATISFIED ();
343               return;
344             }
345         }
346     }
347   else                          /* PW3 (0x83) */
348     {
349       ks_pw3 = gpg_do_read_simple (NR_DO_KEYSTRING_PW3);
350       pw_len = verify_admin_0 (pw, len, -1, ks_pw3, 0);
351
352       if (ks_pw3 == NULL)
353         {
354           salt = NULL;
355           salt_len = 0;
356         }
357       else
358         {
359           salt = KS_GET_SALT (ks_pw3);
360           salt_len = SALT_SIZE;
361         }
362
363       if (pw_len < 0)
364         {
365           DEBUG_INFO ("permission denied.\r\n");
366           GPG_SECURITY_FAILURE ();
367           return;
368         }
369       else if (pw_len == 0)
370         {
371           DEBUG_INFO ("blocked.\r\n");
372           GPG_SECURITY_AUTH_BLOCKED ();
373           return;
374         }
375       else
376         {
377           newpw = pw + pw_len;
378           newpw_len = len - pw_len;
379           if (newpw_len == 0 && admin_authorized == BY_ADMIN)
380             {
381               newpw_len = strlen (OPENPGP_CARD_INITIAL_PW3);
382               memcpy (newpw, OPENPGP_CARD_INITIAL_PW3, newpw_len);
383               newsalt_len = 0;
384               pw3_null = 1;
385             }
386
387           who_old = admin_authorized;
388         }
389     }
390
391   if (newsalt_len != 0)
392     random_get_salt (new_salt);
393   s2k (salt, salt_len, pw, pw_len, old_ks);
394   s2k (new_salt, newsalt_len, newpw, newpw_len, new_ks);
395   new_ks0[0] = newpw_len;
396
397   r = gpg_change_keystring (who_old, old_ks, who, new_ks);
398   if (r <= -2)
399     {
400       DEBUG_INFO ("memory error.\r\n");
401       GPG_MEMORY_FAILURE ();
402     }
403   else if (r < 0)
404     {
405       DEBUG_INFO ("security error.\r\n");
406       GPG_SECURITY_FAILURE ();
407     }
408   else if (r == 0 && who == BY_USER)    /* no prvkey */
409     {
410       DEBUG_INFO ("user pass change not supported with no keys.\r\n");
411       GPG_CONDITION_NOT_SATISFIED ();
412     }
413   else if (r > 0 && who == BY_USER)
414     {
415       gpg_do_write_simple (NR_DO_KEYSTRING_PW1, new_ks0, KS_META_SIZE);
416       ac_reset_pso_cds ();
417       ac_reset_other ();
418       if (admin_authorized == BY_USER)
419         ac_reset_admin ();
420       DEBUG_INFO ("Changed length of DO_KEYSTRING_PW1.\r\n");
421       GPG_SUCCESS ();
422     }
423   else if (r > 0 && who == BY_ADMIN)
424     {
425       if (pw3_null)
426         gpg_do_write_simple (NR_DO_KEYSTRING_PW3, NULL, 0);
427       else
428         gpg_do_write_simple (NR_DO_KEYSTRING_PW3, new_ks0, KS_META_SIZE);
429
430       ac_reset_admin ();
431       DEBUG_INFO ("Changed length of DO_KEYSTRING_PW3.\r\n");
432       GPG_SUCCESS ();
433     }
434   else /* r == 0 && who == BY_ADMIN */  /* no prvkey */
435     {
436       if (pw3_null)
437         gpg_do_write_simple (NR_DO_KEYSTRING_PW3, NULL, 0);
438       else
439         {
440           new_ks0[0] |= PW_LEN_KEYSTRING_BIT;
441           gpg_do_write_simple (NR_DO_KEYSTRING_PW3, new_ks0, KEYSTRING_SIZE);
442         }
443       DEBUG_INFO ("Changed DO_KEYSTRING_PW3.\r\n");
444       ac_reset_admin ();
445       GPG_SUCCESS ();
446     }
447 }
448
449
450 #ifndef S2KCOUNT
451 /*
452  * OpenPGP uses the value 65535 for the key on disk.
453  * Given the condition that the access to flash ROM is harder than disk,
454  * that is, the threat model is different, we chose the default value 192.
455  */
456 #define S2KCOUNT 192
457 #endif
458 void
459 s2k (const unsigned char *salt, size_t slen,
460      const unsigned char *input, size_t ilen, unsigned char output[32])
461 {
462   sha256_context ctx;
463   size_t count = S2KCOUNT;
464   const uint8_t *unique = unique_device_id ();
465
466   sha256_start (&ctx);
467
468   sha256_update (&ctx, unique, 12);
469
470   while (count > slen + ilen)
471     {
472       if (slen)
473         sha256_update (&ctx, salt, slen);
474       sha256_update (&ctx, input, ilen);
475       count -= slen + ilen;
476     }
477
478   if (count <= slen)
479     sha256_update (&ctx, salt, count);
480   else
481     {
482       if (slen)
483         {
484           sha256_update (&ctx, salt, slen);
485           count -= slen;
486         }
487       sha256_update (&ctx, input, count);
488     }
489
490   sha256_finish (&ctx, output);
491 }
492
493
494 static void
495 cmd_reset_user_password (void)
496 {
497   uint8_t p1 = P1 (apdu);
498   int len;
499   const uint8_t *pw;
500   const uint8_t *newpw;
501   int pw_len, newpw_len;
502   int r;
503   uint8_t new_ks0[KEYSTRING_SIZE];
504   uint8_t *new_ks = KS_GET_KEYSTRING (new_ks0);
505   uint8_t *new_salt = KS_GET_SALT (new_ks0);
506   const uint8_t *salt;
507   int salt_len;
508
509   DEBUG_INFO ("Reset PW1\r\n");
510   DEBUG_BYTE (p1);
511
512   len = apdu.cmd_apdu_data_len;
513   pw = apdu.cmd_apdu_data;
514
515   if (p1 == 0x00)               /* by User with Reseting Code */
516     {
517       const uint8_t *ks_rc = gpg_do_read_simple (NR_DO_KEYSTRING_RC);
518       uint8_t old_ks[KEYSTRING_MD_SIZE];
519
520       if (gpg_pw_locked (PW_ERR_RC))
521         {
522           DEBUG_INFO ("blocked.\r\n");
523           GPG_SECURITY_AUTH_BLOCKED ();
524           return;
525         }
526
527       if (ks_rc == NULL)
528         {
529           DEBUG_INFO ("security error.\r\n");
530           GPG_SECURITY_FAILURE ();
531           return;
532         }
533
534       pw_len = ks_rc[0] & PW_LEN_MASK;
535       salt = KS_GET_SALT (ks_rc);
536       salt_len = SALT_SIZE;
537       newpw = pw + pw_len;
538       newpw_len = len - pw_len;
539       random_get_salt (new_salt);
540       s2k (salt, salt_len, pw, pw_len, old_ks);
541       s2k (new_salt, SALT_SIZE, newpw, newpw_len, new_ks);
542       new_ks0[0] = newpw_len;
543       r = gpg_change_keystring (BY_RESETCODE, old_ks, BY_USER, new_ks);
544       if (r <= -2)
545         {
546           DEBUG_INFO ("memory error.\r\n");
547           GPG_MEMORY_FAILURE ();
548         }
549       else if (r < 0)
550         {
551           DEBUG_INFO ("failed.\r\n");
552           gpg_pw_increment_err_counter (PW_ERR_RC);
553           GPG_SECURITY_FAILURE ();
554         }
555       else if (r == 0)
556         {
557           DEBUG_INFO ("user pass change not supported with no keys.\r\n");
558           GPG_CONDITION_NOT_SATISFIED ();
559         }
560       else
561         {
562           DEBUG_INFO ("done.\r\n");
563           gpg_do_write_simple (NR_DO_KEYSTRING_PW1, new_ks0, KS_META_SIZE);
564           ac_reset_pso_cds ();
565           ac_reset_other ();
566           if (admin_authorized == BY_USER)
567             ac_reset_admin ();
568           gpg_pw_reset_err_counter (PW_ERR_RC);
569           gpg_pw_reset_err_counter (PW_ERR_PW1);
570           GPG_SUCCESS ();
571         }
572     }
573   else                          /* by Admin (p1 == 0x02) */
574     {
575       const uint8_t *old_ks = keystring_md_pw3;
576
577       if (!ac_check_status (AC_ADMIN_AUTHORIZED))
578         {
579           DEBUG_INFO ("permission denied.\r\n");
580           GPG_SECURITY_FAILURE ();
581           return;
582         }
583
584       newpw_len = len;
585       newpw = pw;
586       random_get_salt (new_salt);
587       s2k (new_salt, SALT_SIZE, newpw, newpw_len, new_ks);
588       new_ks0[0] = newpw_len;
589       r = gpg_change_keystring (admin_authorized, old_ks, BY_USER, new_ks);
590       if (r <= -2)
591         {
592           DEBUG_INFO ("memory error.\r\n");
593           GPG_MEMORY_FAILURE ();
594         }
595       else if (r < 0)
596         {
597           DEBUG_INFO ("security error.\r\n");
598           GPG_SECURITY_FAILURE ();
599         }
600       else if (r == 0)
601         {
602           DEBUG_INFO ("user pass change not supported with no keys.\r\n");
603           GPG_CONDITION_NOT_SATISFIED ();
604         }
605       else
606         {
607           DEBUG_INFO ("done.\r\n");
608           gpg_do_write_simple (NR_DO_KEYSTRING_PW1, new_ks0, KS_META_SIZE);
609           ac_reset_pso_cds ();
610           ac_reset_other ();
611           if (admin_authorized == BY_USER)
612             ac_reset_admin ();
613           gpg_pw_reset_err_counter (PW_ERR_PW1);
614           GPG_SUCCESS ();
615         }
616     }
617 }
618
619 static void
620 cmd_put_data (void)
621 {
622   uint8_t *data;
623   uint16_t tag;
624   int len;
625
626   DEBUG_INFO (" - PUT DATA\r\n");
627
628   tag = ((P1 (apdu)<<8) | P2 (apdu));
629   len = apdu.cmd_apdu_data_len;
630   data = apdu.cmd_apdu_data;
631   gpg_do_put_data (tag, data, len);
632 }
633
634 static void
635 cmd_pgp_gakp (void)
636 {
637   DEBUG_INFO (" - Generate Asymmetric Key Pair\r\n");
638   DEBUG_BYTE (P1 (apdu));
639
640   if (P1 (apdu) == 0x81)
641     /* Get public key */
642     gpg_do_public_key (apdu.cmd_apdu_data[0]);
643   else
644     {
645       if (!ac_check_status (AC_ADMIN_AUTHORIZED))
646         GPG_SECURITY_FAILURE ();
647       gpg_do_keygen (apdu.cmd_apdu_data[0]);
648     }
649 }
650
651 const uint8_t *
652 gpg_get_firmware_update_key (uint8_t keyno)
653 {
654   extern uint8_t _updatekey_store;
655   const uint8_t *p;
656
657   p = &_updatekey_store + keyno * FIRMWARE_UPDATE_KEY_CONTENT_LEN;
658   return p;
659 }
660
661 #ifdef CERTDO_SUPPORT
662 #define FILEID_CH_CERTIFICATE_IS_VALID 1
663 #else
664 #define FILEID_CH_CERTIFICATE_IS_VALID 0
665 #endif
666
667 static void
668 cmd_read_binary (void)
669 {
670   int is_short_EF = (P1 (apdu) & 0x80) != 0;
671   uint8_t file_id;
672   const uint8_t *p;
673   uint16_t offset;
674
675   DEBUG_INFO (" - Read binary\r\n");
676
677   if (is_short_EF)
678     file_id = (P1 (apdu) & 0x1f);
679   else
680     file_id = file_selection - FILE_EF_SERIAL_NO + FILEID_SERIAL_NO;
681
682   if ((!FILEID_CH_CERTIFICATE_IS_VALID && file_id == FILEID_CH_CERTIFICATE)
683       || file_id > FILEID_CH_CERTIFICATE)
684     {
685       GPG_NO_FILE ();
686       return;
687     }
688
689   if (is_short_EF)
690     {
691       file_selection = file_id - FILEID_SERIAL_NO + FILE_EF_SERIAL_NO;
692       offset = P2 (apdu);
693     }
694   else
695     offset = (P1 (apdu) << 8) | P2 (apdu);
696
697   if (file_id == FILEID_SERIAL_NO)
698     {
699       if (offset != 0)
700         GPG_BAD_P1_P2 ();
701       else
702         {
703           gpg_do_get_data (0x004f, 1); /* Get AID... */
704           res_APDU[0] = 0x5a; /* ... and overwrite the first byte of data. */
705         }
706       return;
707     }
708
709   if (file_id >= FILEID_UPDATE_KEY_0 && file_id <= FILEID_UPDATE_KEY_3)
710     {
711       if (offset != 0)
712         GPG_MEMORY_FAILURE ();
713       else
714         {
715           p = gpg_get_firmware_update_key (file_id - FILEID_UPDATE_KEY_0);
716           res_APDU_size = FIRMWARE_UPDATE_KEY_CONTENT_LEN;
717           memcpy (res_APDU, p, FIRMWARE_UPDATE_KEY_CONTENT_LEN);
718           GPG_SUCCESS ();
719         }
720     }
721 #if defined(CERTDO_SUPPORT)
722   else /* file_id == FILEID_CH_CERTIFICATE */
723     {
724       uint16_t len = 256;
725
726       p = &ch_certificate_start;
727       if (offset >= FLASH_CH_CERTIFICATE_SIZE)
728         GPG_MEMORY_FAILURE ();
729       else
730         {
731           if (offset + len >= FLASH_CH_CERTIFICATE_SIZE)
732             len = FLASH_CH_CERTIFICATE_SIZE - offset;
733
734           res_APDU_size = len;
735           memcpy (res_APDU, p + offset, len);
736           GPG_SUCCESS ();
737         }
738     }
739 #endif
740 }
741
742 static void
743 cmd_select_file (void)
744 {
745   if (P1 (apdu) == 4)   /* Selection by DF name */
746     {
747       DEBUG_INFO (" - select DF by name\r\n");
748
749       /* name = D2 76 00 01 24 01 */
750       if (apdu.cmd_apdu_data_len != 6
751           || memcmp (openpgpcard_aid, apdu.cmd_apdu_data, 6) != 0)
752         {
753           DEBUG_SHORT (apdu.cmd_apdu_data_len);
754           DEBUG_BINARY (apdu.cmd_apdu_data, apdu.cmd_apdu_data_len);
755
756           GPG_NO_FILE ();
757           return;
758         }
759
760       if (file_selection == FILE_CARD_TERMINATED)
761         {
762           file_selection = FILE_CARD_TERMINATED_OPENPGP;
763           GPG_APPLICATION_TERMINATED();
764           return;
765         }
766
767       file_selection = FILE_DF_OPENPGP;
768       if ((P2 (apdu) & 0x0c) == 0x0c)   /* No FCI */
769         GPG_SUCCESS ();
770       else
771         {
772           gpg_do_get_data (0x004f, 1); /* AID */
773           memmove (res_APDU+2, res_APDU, res_APDU_size);
774           res_APDU[0] = 0x6f;
775           res_APDU[1] = 0x12;
776           res_APDU[2] = 0x84;   /* overwrite: DF name */
777           res_APDU_size += 2;
778           GPG_SUCCESS ();
779         }
780     }
781   else if (apdu.cmd_apdu_data_len == 2
782            && apdu.cmd_apdu_data[0] == 0x2f && apdu.cmd_apdu_data[1] == 0x02)
783     {
784       DEBUG_INFO (" - select 0x2f02 EF\r\n");
785       /*
786        * MF.EF-GDO -- Serial number of the card and name of the owner
787        */
788       GPG_SUCCESS ();
789       file_selection = FILE_EF_SERIAL_NO;
790     }
791   else if (apdu.cmd_apdu_data_len == 2
792            && apdu.cmd_apdu_data[0] == 0x3f && apdu.cmd_apdu_data[1] == 0x00)
793     {
794       DEBUG_INFO (" - select ROOT MF\r\n");
795       if (P2 (apdu) == 0x0c)
796         {
797           GPG_SUCCESS ();
798         }
799       else
800         {
801           int len = sizeof (select_file_TOP_result);
802
803           res_APDU_size = len;
804           memcpy (res_APDU, select_file_TOP_result, len);
805           res_APDU[2] = (data_objects_number_of_bytes & 0xff);
806           res_APDU[3] = (data_objects_number_of_bytes >> 8);
807           GPG_SUCCESS ();
808         }
809
810       file_selection = FILE_MF;
811       ac_fini ();               /* Reset authentication */
812     }
813   else
814     {
815       DEBUG_INFO (" - select ?? \r\n");
816
817       file_selection = FILE_NONE;
818       GPG_NO_FILE ();
819     }
820 }
821
822 static void
823 cmd_get_data (void)
824 {
825   uint16_t tag = ((P1 (apdu)<<8) | P2 (apdu));
826
827   DEBUG_INFO (" - Get Data\r\n");
828
829   gpg_do_get_data (tag, 0);
830 }
831
832 #define ECDSA_HASH_LEN 32
833 #define ECDSA_SIGNATURE_LENGTH 64
834
835 #define EDDSA_HASH_LEN_MAX 256
836 #define EDDSA_SIGNATURE_LENGTH 64
837
838 #define ECC_CIPHER_DO_HEADER_SIZE 7
839
840 static void
841 cmd_pso (void)
842 {
843   int len = apdu.cmd_apdu_data_len;
844   int r = -1;
845   int attr;
846   int pubkey_len;
847   unsigned int result_len = 0;
848   int cs;
849
850   DEBUG_INFO (" - PSO: ");
851   DEBUG_WORD ((uint32_t)&r);
852   DEBUG_BINARY (apdu.cmd_apdu_data, apdu.cmd_apdu_data_len);
853   DEBUG_SHORT (len);
854
855   if (P1 (apdu) == 0x9e && P2 (apdu) == 0x9a)
856     {
857       attr = gpg_get_algo_attr (GPG_KEY_FOR_SIGNING);
858       pubkey_len = gpg_get_algo_attr_key_size (GPG_KEY_FOR_SIGNING,
859                                                GPG_KEY_PUBLIC);
860
861       if (!ac_check_status (AC_PSO_CDS_AUTHORIZED))
862         {
863           DEBUG_INFO ("security error.");
864           GPG_SECURITY_FAILURE ();
865           return;
866         }
867
868       if (attr == ALGO_RSA2K || attr == ALGO_RSA4K)
869         {
870           /* Check size of digestInfo */
871           if (len != 34         /* MD5 */
872               && len != 35              /* SHA1 / RIPEMD-160 */
873               && len != 47              /* SHA224 */
874               && len != 51              /* SHA256 */
875               && len != 67              /* SHA384 */
876               && len != 83)             /* SHA512 */
877             {
878               DEBUG_INFO (" wrong length");
879               GPG_CONDITION_NOT_SATISFIED ();
880               return;
881             }
882
883           DEBUG_BINARY (kd[GPG_KEY_FOR_SIGNING].data, pubkey_len);
884
885           result_len = pubkey_len;
886           r = rsa_sign (apdu.cmd_apdu_data, res_APDU, len,
887                         &kd[GPG_KEY_FOR_SIGNING], pubkey_len);
888         }
889       else if (attr == ALGO_NISTP256R1 || attr == ALGO_SECP256K1)
890         {
891           /* ECDSA with p256r1/p256k1 for signature */
892           if (len != ECDSA_HASH_LEN)
893             {
894               DEBUG_INFO (" wrong length");
895               GPG_CONDITION_NOT_SATISFIED ();
896               return;
897             }
898
899           cs = chopstx_setcancelstate (0);
900           result_len = ECDSA_SIGNATURE_LENGTH;
901           if (attr == ALGO_NISTP256R1)
902             r = ecdsa_sign_p256r1 (apdu.cmd_apdu_data, res_APDU,
903                                    kd[GPG_KEY_FOR_SIGNING].data);
904           else                  /* ALGO_SECP256K1 */
905             r = ecdsa_sign_p256k1 (apdu.cmd_apdu_data, res_APDU,
906                                    kd[GPG_KEY_FOR_SIGNING].data);
907           chopstx_setcancelstate (cs);
908         }
909       else if (attr == ALGO_ED25519)
910         {
911           uint32_t output[64/4];        /* Require 4-byte alignment. */
912
913           if (len > EDDSA_HASH_LEN_MAX)
914             {
915               DEBUG_INFO ("wrong hash length.");
916               GPG_CONDITION_NOT_SATISFIED ();
917               return;
918             }
919
920           cs = chopstx_setcancelstate (0);
921           result_len = EDDSA_SIGNATURE_LENGTH;
922           r = eddsa_sign_25519 (apdu.cmd_apdu_data, len, output,
923                                 kd[GPG_KEY_FOR_SIGNING].data,
924                                 kd[GPG_KEY_FOR_SIGNING].data+32,
925                                 kd[GPG_KEY_FOR_SIGNING].pubkey);
926           chopstx_setcancelstate (cs);
927           memcpy (res_APDU, output, EDDSA_SIGNATURE_LENGTH);
928         }
929       else
930         {
931           DEBUG_INFO ("unknown algo.");
932           GPG_FUNCTION_NOT_SUPPORTED ();
933           return;
934         }
935
936       if (r == 0)
937         {
938           res_APDU_size = result_len;
939           gpg_increment_digital_signature_counter ();
940         }
941       else   /* Failure */
942         ac_reset_pso_cds ();
943     }
944   else if (P1 (apdu) == 0x80 && P2 (apdu) == 0x86)
945     {
946       attr = gpg_get_algo_attr (GPG_KEY_FOR_DECRYPTION);
947       pubkey_len = gpg_get_algo_attr_key_size (GPG_KEY_FOR_DECRYPTION,
948                                                GPG_KEY_PUBLIC);
949
950       DEBUG_BINARY (kd[GPG_KEY_FOR_DECRYPTION].data, pubkey_len);
951
952       if (!ac_check_status (AC_OTHER_AUTHORIZED))
953         {
954           DEBUG_INFO ("security error.");
955           GPG_SECURITY_FAILURE ();
956           return;
957         }
958
959       if (attr == ALGO_RSA2K || attr == ALGO_RSA4K)
960         {
961           /* Skip padding 0x00 */
962           len--;
963           if (len != pubkey_len)
964             {
965               GPG_CONDITION_NOT_SATISFIED ();
966               return;
967             }
968           r = rsa_decrypt (apdu.cmd_apdu_data+1, res_APDU, len,
969                            &kd[GPG_KEY_FOR_DECRYPTION], &result_len);
970         }
971       else if (attr == ALGO_NISTP256R1 || attr == ALGO_SECP256K1)
972         {
973           int header = ECC_CIPHER_DO_HEADER_SIZE;
974
975           /* Format is in big endian MPI: 04 || x || y */
976           if (len != 65 + ECC_CIPHER_DO_HEADER_SIZE
977               || apdu.cmd_apdu_data[header] != 0x04)
978             {
979               GPG_CONDITION_NOT_SATISFIED ();
980               return;
981             }
982
983           cs = chopstx_setcancelstate (0);
984           result_len = 65;
985           if (attr == ALGO_NISTP256R1)
986             r = ecdh_decrypt_p256r1 (apdu.cmd_apdu_data + header, res_APDU,
987                                      kd[GPG_KEY_FOR_DECRYPTION].data);
988           else
989             r = ecdh_decrypt_p256k1 (apdu.cmd_apdu_data + header, res_APDU,
990                                      kd[GPG_KEY_FOR_DECRYPTION].data);
991           chopstx_setcancelstate (cs);
992         }
993       else if (attr == ALGO_CURVE25519)
994         {
995           int header = ECC_CIPHER_DO_HEADER_SIZE;
996
997           if (len != 32 + ECC_CIPHER_DO_HEADER_SIZE)
998             {
999               GPG_CONDITION_NOT_SATISFIED ();
1000               return;
1001             }
1002
1003           cs = chopstx_setcancelstate (0);
1004           result_len = 32;
1005           r = ecdh_decrypt_curve25519 (apdu.cmd_apdu_data + header, res_APDU,
1006                                        kd[GPG_KEY_FOR_DECRYPTION].data);
1007           chopstx_setcancelstate (cs);
1008         }
1009       else
1010         {
1011           DEBUG_INFO ("unknown algo.");
1012           GPG_FUNCTION_NOT_SUPPORTED ();
1013           return;
1014         }
1015
1016       if (r == 0)
1017         res_APDU_size = result_len;
1018     }
1019
1020   if (r < 0)
1021     {
1022       DEBUG_INFO (" - ??");
1023       DEBUG_BYTE (P1 (apdu));
1024       DEBUG_INFO (" - ??");
1025       DEBUG_BYTE (P2 (apdu));
1026       GPG_ERROR ();
1027     }
1028
1029   DEBUG_INFO ("PSO done.\r\n");
1030 }
1031
1032
1033 #define MAX_RSA_DIGEST_INFO_LEN 102 /* 40% */
1034 static void
1035 cmd_internal_authenticate (void)
1036 {
1037   int attr = gpg_get_algo_attr (GPG_KEY_FOR_AUTHENTICATION);
1038   int pubkey_len = gpg_get_algo_attr_key_size (GPG_KEY_FOR_AUTHENTICATION,
1039                                                GPG_KEY_PUBLIC);
1040   int len = apdu.cmd_apdu_data_len;
1041   int r = -1;
1042   unsigned int result_len = 0;
1043   int cs;
1044
1045   DEBUG_INFO (" - INTERNAL AUTHENTICATE\r\n");
1046
1047   if (P1 (apdu) != 0x00 || P2 (apdu) != 0x00)
1048     {
1049       DEBUG_INFO (" - ??");
1050       DEBUG_BYTE (P1 (apdu));
1051       DEBUG_INFO (" - ??");
1052       DEBUG_BYTE (P2 (apdu));
1053       GPG_CONDITION_NOT_SATISFIED ();
1054       return;
1055     }
1056
1057   DEBUG_SHORT (len);
1058   if (!ac_check_status (AC_OTHER_AUTHORIZED))
1059     {
1060       DEBUG_INFO ("security error.");
1061       GPG_SECURITY_FAILURE ();
1062       return;
1063     }
1064
1065   if (attr == ALGO_RSA2K || attr == ALGO_RSA4K)
1066     {
1067       if (len > MAX_RSA_DIGEST_INFO_LEN)
1068         {
1069           DEBUG_INFO ("input is too long.");
1070           GPG_CONDITION_NOT_SATISFIED ();
1071           return;
1072         }
1073
1074       result_len = pubkey_len;
1075       r = rsa_sign (apdu.cmd_apdu_data, res_APDU, len,
1076                     &kd[GPG_KEY_FOR_AUTHENTICATION], pubkey_len);
1077     }
1078   else if (attr == ALGO_NISTP256R1)
1079     {
1080       if (len != ECDSA_HASH_LEN)
1081         {
1082           DEBUG_INFO ("wrong hash length.");
1083           GPG_CONDITION_NOT_SATISFIED ();
1084           return;
1085         }
1086
1087       cs = chopstx_setcancelstate (0);
1088       result_len = ECDSA_SIGNATURE_LENGTH;
1089       r = ecdsa_sign_p256r1 (apdu.cmd_apdu_data, res_APDU,
1090                              kd[GPG_KEY_FOR_AUTHENTICATION].data);
1091       chopstx_setcancelstate (cs);
1092     }
1093   else if (attr == ALGO_SECP256K1)
1094     {
1095       if (len != ECDSA_HASH_LEN)
1096         {
1097           DEBUG_INFO ("wrong hash length.");
1098           GPG_CONDITION_NOT_SATISFIED ();
1099           return;
1100         }
1101
1102       cs = chopstx_setcancelstate (0);
1103       result_len = ECDSA_SIGNATURE_LENGTH;
1104       r = ecdsa_sign_p256k1 (apdu.cmd_apdu_data, res_APDU,
1105                              kd[GPG_KEY_FOR_AUTHENTICATION].data);
1106       chopstx_setcancelstate (cs);
1107     }
1108   else if (attr == ALGO_ED25519)
1109     {
1110       uint32_t output[64/4];    /* Require 4-byte alignment. */
1111
1112       if (len > EDDSA_HASH_LEN_MAX)
1113         {
1114           DEBUG_INFO ("wrong hash length.");
1115           GPG_CONDITION_NOT_SATISFIED ();
1116           return;
1117         }
1118
1119       cs = chopstx_setcancelstate (0);
1120       result_len = EDDSA_SIGNATURE_LENGTH;
1121       r = eddsa_sign_25519 (apdu.cmd_apdu_data, len, output,
1122                             kd[GPG_KEY_FOR_AUTHENTICATION].data,
1123                             kd[GPG_KEY_FOR_AUTHENTICATION].data+32,
1124                             kd[GPG_KEY_FOR_AUTHENTICATION].pubkey);
1125       chopstx_setcancelstate (cs);
1126       memcpy (res_APDU, output, EDDSA_SIGNATURE_LENGTH);
1127     }
1128
1129   if (r == 0)
1130     res_APDU_size = result_len;
1131   else
1132     GPG_ERROR ();
1133
1134   DEBUG_INFO ("INTERNAL AUTHENTICATE done.\r\n");
1135 }
1136
1137
1138 #define MBD_OPRATION_WRITE  0
1139 #define MBD_OPRATION_UPDATE 1
1140
1141 static void
1142 modify_binary (uint8_t op, uint8_t p1, uint8_t p2, int len)
1143 {
1144   uint8_t file_id;
1145   uint16_t offset;
1146   int is_short_EF = (p1 & 0x80) != 0;
1147   int r;
1148
1149   if (!ac_check_status (AC_ADMIN_AUTHORIZED))
1150     {
1151       DEBUG_INFO ("security error.");
1152       GPG_SECURITY_FAILURE ();
1153       return;
1154     }
1155
1156   if (is_short_EF)
1157     file_id = (p1 & 0x1f);
1158   else
1159     file_id = file_selection - FILE_EF_SERIAL_NO + FILEID_SERIAL_NO;
1160
1161   if (!FILEID_CH_CERTIFICATE_IS_VALID && file_id == FILEID_CH_CERTIFICATE)
1162     {
1163       GPG_NO_FILE ();
1164       return;
1165     }
1166
1167   if (op == MBD_OPRATION_UPDATE && file_id != FILEID_CH_CERTIFICATE)
1168     {
1169       GPG_CONDITION_NOT_SATISFIED ();
1170       return;
1171     }
1172
1173   if (file_id > FILEID_CH_CERTIFICATE)
1174     {
1175       GPG_NO_FILE ();
1176       return;
1177     }
1178
1179   if (is_short_EF)
1180     {
1181       file_selection = file_id - FILEID_SERIAL_NO + FILE_EF_SERIAL_NO;
1182       offset = p2;
1183
1184       if (op == MBD_OPRATION_UPDATE)
1185         {
1186           r = flash_erase_binary (file_id);
1187           if (r < 0)
1188             {
1189               DEBUG_INFO ("memory error.\r\n");
1190               GPG_MEMORY_FAILURE ();
1191               return;
1192             }
1193         }
1194     }
1195   else
1196     offset = (p1 << 8) | p2;
1197
1198   DEBUG_SHORT (len);
1199   DEBUG_SHORT (offset);
1200
1201   if (file_id == FILEID_CH_CERTIFICATE && (len&1))
1202     /* It's OK the size of last write is odd.  */
1203     apdu.cmd_apdu_data[len++] = 0xff;
1204
1205   r = flash_write_binary (file_id, apdu.cmd_apdu_data, len, offset);
1206   if (r < 0)
1207     {
1208       DEBUG_INFO ("memory error.\r\n");
1209       GPG_MEMORY_FAILURE ();
1210       return;
1211     }
1212
1213   if (file_id >= FILEID_UPDATE_KEY_0 && file_id <= FILEID_UPDATE_KEY_3
1214       && len == 0 && offset == 0)
1215     {
1216       int i;
1217       const uint8_t *p;
1218
1219       for (i = 0; i < 4; i++)
1220         {
1221           p = gpg_get_firmware_update_key (i);
1222           if (p[0] != 0x00 || p[1] != 0x00) /* still valid */
1223             break;
1224         }
1225
1226       if (i == 4)                       /* all update keys are removed */
1227         {
1228           p = gpg_get_firmware_update_key (0);
1229           flash_erase_page ((uint32_t)p);
1230         }
1231     }
1232
1233   GPG_SUCCESS ();
1234 }
1235
1236
1237 #if defined(CERTDO_SUPPORT)
1238 static void
1239 cmd_update_binary (void)
1240 {
1241   int len = apdu.cmd_apdu_data_len;
1242
1243   DEBUG_INFO (" - UPDATE BINARY\r\n");
1244   modify_binary (MBD_OPRATION_UPDATE, P1 (apdu), P2 (apdu), len);
1245   DEBUG_INFO ("UPDATE BINARY done.\r\n");
1246 }
1247 #endif
1248
1249
1250 static void
1251 cmd_write_binary (void)
1252 {
1253   int len = apdu.cmd_apdu_data_len;
1254
1255   DEBUG_INFO (" - WRITE BINARY\r\n");
1256   modify_binary (MBD_OPRATION_WRITE, P1 (apdu), P2 (apdu), len);
1257   DEBUG_INFO ("WRITE BINARY done.\r\n");
1258 }
1259
1260
1261 static void
1262 cmd_external_authenticate (void)
1263 {
1264   const uint8_t *pubkey;
1265   const uint8_t *signature = apdu.cmd_apdu_data;
1266   int len = apdu.cmd_apdu_data_len;
1267   uint8_t keyno = P2 (apdu);
1268   int r;
1269
1270   DEBUG_INFO (" - EXTERNAL AUTHENTICATE\r\n");
1271
1272   if (keyno >= 4)
1273     {
1274       GPG_CONDITION_NOT_SATISFIED ();
1275       return;
1276     }
1277
1278   pubkey = gpg_get_firmware_update_key (keyno);
1279   if (len != 256
1280       || (pubkey[0] == 0xff && pubkey[1] == 0xff) /* not registered */
1281       || (pubkey[0] == 0x00 && pubkey[1] == 0x00) /* removed */)
1282     {
1283       GPG_CONDITION_NOT_SATISFIED ();
1284       return;
1285     }
1286
1287   r = rsa_verify (pubkey, FIRMWARE_UPDATE_KEY_CONTENT_LEN,
1288                   challenge, signature);
1289   random_bytes_free (challenge);
1290   challenge = NULL;
1291
1292   if (r < 0)
1293     {
1294       GPG_SECURITY_FAILURE ();
1295       return;
1296     }
1297
1298   eventflag_signal (openpgp_comm, EV_EXIT); /* signal to self.  */
1299   set_res_sw (0xff, 0xff);
1300   DEBUG_INFO ("EXTERNAL AUTHENTICATE done.\r\n");
1301 }
1302
1303 static void
1304 cmd_get_challenge (void)
1305 {
1306   int len = apdu.expected_res_size;
1307
1308   DEBUG_INFO (" - GET CHALLENGE\r\n");
1309
1310   if (len > CHALLENGE_LEN)
1311     {
1312       GPG_CONDITION_NOT_SATISFIED ();
1313       return;
1314     }
1315   else if (len == 0)
1316     /* Le is not specified.  Return full-sized challenge by GET_RESPONSE.  */
1317     len = CHALLENGE_LEN;
1318
1319   if (challenge)
1320     random_bytes_free (challenge);
1321
1322   challenge = random_bytes_get ();
1323   memcpy (res_APDU, challenge, len);
1324   res_APDU_size = len;
1325   GPG_SUCCESS ();
1326   DEBUG_INFO ("GET CHALLENGE done.\r\n");
1327 }
1328
1329
1330 #ifdef LIFE_CYCLE_MANAGEMENT_SUPPORT
1331 static void
1332 cmd_activate_file (void)
1333 {
1334   if (file_selection != FILE_CARD_TERMINATED_OPENPGP)
1335     {
1336       GPG_NO_RECORD();
1337       return;
1338     }
1339
1340   flash_activate ();
1341   file_selection = FILE_DF_OPENPGP;
1342   GPG_SUCCESS ();
1343 }
1344
1345 static void
1346 cmd_terminate_df (void)
1347 {
1348   uint8_t p1 = P1 (apdu);
1349   uint8_t p2 = P2 (apdu);
1350
1351   if (file_selection != FILE_DF_OPENPGP)
1352     {
1353       GPG_NO_RECORD();
1354       return;
1355     }
1356
1357   if (p1 != 0 || p2 != 0)
1358     {
1359       GPG_BAD_P1_P2();
1360       return;
1361     }
1362
1363   if (apdu.cmd_apdu_data_len != 0)
1364     {
1365       GPG_WRONG_LENGTH();
1366       return;
1367     }
1368
1369
1370   if (!ac_check_status (AC_ADMIN_AUTHORIZED) && !gpg_pw_locked (PW_ERR_PW3))
1371     {
1372       /* Only allow the case admin authorized, or, admin pass is locked.  */
1373       GPG_SECURITY_FAILURE();
1374       return;
1375     }
1376
1377   ac_reset_admin ();
1378   ac_reset_pso_cds ();
1379   ac_reset_other ();
1380   gpg_do_terminate ();
1381   flash_terminate ();
1382   file_selection = FILE_CARD_TERMINATED;
1383   GPG_SUCCESS ();
1384 }
1385 #endif
1386
1387
1388 struct command
1389 {
1390   uint8_t command;
1391   void (*cmd_handler) (void);
1392 };
1393
1394 const struct command cmds[] = {
1395   { INS_VERIFY, cmd_verify },
1396   { INS_CHANGE_REFERENCE_DATA, cmd_change_password },
1397   { INS_PSO, cmd_pso },
1398   { INS_RESET_RETRY_COUNTER, cmd_reset_user_password },
1399 #ifdef LIFE_CYCLE_MANAGEMENT_SUPPORT
1400   { INS_ACTIVATE_FILE, cmd_activate_file },
1401 #endif
1402   { INS_PGP_GENERATE_ASYMMETRIC_KEY_PAIR, cmd_pgp_gakp },
1403   { INS_EXTERNAL_AUTHENTICATE,              /* Not in OpenPGP card protocol */
1404     cmd_external_authenticate },
1405   { INS_GET_CHALLENGE, cmd_get_challenge }, /* Not in OpenPGP card protocol */
1406   { INS_INTERNAL_AUTHENTICATE, cmd_internal_authenticate },
1407   { INS_SELECT_FILE, cmd_select_file },
1408   { INS_READ_BINARY, cmd_read_binary },     /* Not in OpenPGP card protocol */
1409   { INS_GET_DATA, cmd_get_data },
1410   { INS_WRITE_BINARY, cmd_write_binary},    /* Not in OpenPGP card protocol */
1411 #if defined(CERTDO_SUPPORT)
1412   { INS_UPDATE_BINARY, cmd_update_binary }, /* Not in OpenPGP card protocol */
1413 #endif
1414   { INS_PUT_DATA, cmd_put_data },
1415   { INS_PUT_DATA_ODD, cmd_put_data },
1416 #ifdef LIFE_CYCLE_MANAGEMENT_SUPPORT
1417   { INS_TERMINATE_DF, cmd_terminate_df},
1418 #endif
1419 };
1420 #define NUM_CMDS ((int)(sizeof (cmds) / sizeof (struct command)))
1421
1422 static void
1423 process_command_apdu (void)
1424 {
1425   int i;
1426   uint8_t cmd = INS (apdu);
1427
1428   for (i = 0; i < NUM_CMDS; i++)
1429     if (cmds[i].command == cmd)
1430       break;
1431
1432   if (i < NUM_CMDS)
1433     {
1434       if (file_selection == FILE_CARD_TERMINATED
1435           && cmd != INS_SELECT_FILE && cmd != INS_ACTIVATE_FILE
1436           && cmd != INS_GET_CHALLENGE && cmd != INS_EXTERNAL_AUTHENTICATE)
1437         GPG_APPLICATION_TERMINATED();
1438       else if (file_selection != FILE_DF_OPENPGP
1439                && cmd != INS_SELECT_FILE && cmd != INS_ACTIVATE_FILE
1440                && cmd != INS_GET_CHALLENGE && cmd != INS_EXTERNAL_AUTHENTICATE
1441                && cmd != INS_WRITE_BINARY && cmd != INS_UPDATE_BINARY
1442                && cmd != INS_READ_BINARY)
1443         GPG_NO_RECORD();
1444       else
1445         {
1446           chopstx_setcancelstate (1);
1447           cmds[i].cmd_handler ();
1448           chopstx_setcancelstate (0);
1449         }
1450     }
1451   else
1452     {
1453       DEBUG_INFO (" - ??");
1454       DEBUG_BYTE (cmd);
1455       GPG_NO_INS ();
1456     }
1457 }
1458
1459 void *
1460 openpgp_card_thread (void *arg)
1461 {
1462   struct eventflag *ccid_comm = (struct eventflag *)arg;
1463
1464   openpgp_comm = ccid_comm + 1;
1465
1466   gpg_init ();
1467
1468   while (1)
1469     {
1470 #if defined(PINPAD_SUPPORT)
1471       int len, pw_len, newpw_len;
1472 #endif
1473       eventmask_t m = eventflag_wait (openpgp_comm);
1474
1475       DEBUG_INFO ("GPG!: ");
1476
1477       if (m == EV_VERIFY_CMD_AVAILABLE)
1478         {
1479 #if defined(PINPAD_SUPPORT)
1480           if (INS (apdu) != INS_VERIFY)
1481             {
1482               GPG_CONDITION_NOT_SATISFIED ();
1483               goto done;
1484             }
1485
1486           pw_len = get_pinpad_input (PIN_INPUT_CURRENT);
1487           if (pw_len < 0)
1488             {
1489               GPG_ERROR ();
1490               goto done;
1491             }
1492           memcpy (apdu.cmd_apdu_data, pin_input_buffer, pw_len);
1493           apdu.cmd_apdu_data_len = pw_len;
1494 #else
1495           GPG_ERROR ();
1496           goto done;
1497 #endif
1498         }
1499       else if (m == EV_MODIFY_CMD_AVAILABLE)
1500         {
1501 #if defined(PINPAD_SUPPORT)
1502           uint8_t bConfirmPIN = apdu.cmd_apdu_data[0];
1503           uint8_t *p = apdu.cmd_apdu_data;
1504
1505           if (INS (apdu) != INS_CHANGE_REFERENCE_DATA
1506               && INS (apdu) != INS_RESET_RETRY_COUNTER
1507               && INS (apdu) != INS_PUT_DATA)
1508             {
1509               GPG_CONDITION_NOT_SATISFIED ();
1510               goto done;
1511             }
1512
1513           if ((bConfirmPIN & 2))        /* Require old PIN */
1514             {
1515               pw_len = get_pinpad_input (PIN_INPUT_CURRENT);
1516               if (pw_len < 0)
1517                 {
1518                   GPG_ERROR ();
1519                   goto done;
1520                 }
1521               memcpy (p, pin_input_buffer, pw_len);
1522               p += pw_len;
1523             }
1524           else
1525             pw_len = 0;
1526
1527           newpw_len = get_pinpad_input (PIN_INPUT_NEW);
1528           if (newpw_len < 0)
1529             {
1530               GPG_ERROR ();
1531               goto done;
1532             }
1533           memcpy (p, pin_input_buffer, newpw_len);
1534
1535           if ((bConfirmPIN & 1))        /* New PIN twice */
1536             {
1537               len = get_pinpad_input (PIN_INPUT_CONFIRM);
1538               if (len < 0)
1539                 {
1540                   GPG_ERROR ();
1541                   goto done;
1542                 }
1543
1544               if (len != newpw_len || memcmp (p, pin_input_buffer, len) != 0)
1545                 {
1546                   GPG_SECURITY_FAILURE ();
1547                   goto done;
1548                 }
1549             }
1550
1551           apdu.cmd_apdu_data_len = pw_len + newpw_len;
1552 #else
1553           GPG_ERROR ();
1554           goto done;
1555 #endif
1556         }
1557       else if (m == EV_EXIT)
1558         break;
1559
1560       led_blink (LED_START_COMMAND);
1561       process_command_apdu ();
1562       led_blink (LED_FINISH_COMMAND);
1563     done:
1564       eventflag_signal (ccid_comm, EV_EXEC_FINISHED);
1565     }
1566
1567   gpg_fini ();
1568   return NULL;
1569 }