Fix flash initialization
[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 uint8_t file_selection;
105
106 static void
107 gpg_init (void)
108 {
109   const uint8_t *flash_data_start;
110
111   flash_data_start = flash_init ();
112
113   if (flash_data_start == NULL)
114     file_selection = FILE_CARD_TERMINATED;
115   else
116     file_selection = FILE_NONE;
117
118   gpg_data_scan (flash_data_start);
119   flash_init_keys ();
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
769       /* Behave just like original OpenPGP card.  */
770       GPG_SUCCESS ();
771     }
772   else if (apdu.cmd_apdu_data_len == 2
773            && apdu.cmd_apdu_data[0] == 0x2f && apdu.cmd_apdu_data[1] == 0x02)
774     {
775       DEBUG_INFO (" - select 0x2f02 EF\r\n");
776       /*
777        * MF.EF-GDO -- Serial number of the card and name of the owner
778        */
779       GPG_SUCCESS ();
780       file_selection = FILE_EF_SERIAL_NO;
781     }
782   else if (apdu.cmd_apdu_data_len == 2
783            && apdu.cmd_apdu_data[0] == 0x3f && apdu.cmd_apdu_data[1] == 0x00)
784     {
785       DEBUG_INFO (" - select ROOT MF\r\n");
786       if (P2 (apdu) == 0x0c)
787         {
788           GPG_SUCCESS ();
789         }
790       else
791         {
792           int len = sizeof (select_file_TOP_result);
793
794           res_APDU_size = len;
795           memcpy (res_APDU, select_file_TOP_result, len);
796           res_APDU[2] = (data_objects_number_of_bytes & 0xff);
797           res_APDU[3] = (data_objects_number_of_bytes >> 8);
798           GPG_SUCCESS ();
799         }
800
801       file_selection = FILE_MF;
802       ac_fini ();               /* Reset authentication */
803     }
804   else
805     {
806       DEBUG_INFO (" - select ?? \r\n");
807
808       file_selection = FILE_NONE;
809       GPG_NO_FILE ();
810     }
811 }
812
813 static void
814 cmd_get_data (void)
815 {
816   uint16_t tag = ((P1 (apdu)<<8) | P2 (apdu));
817
818   DEBUG_INFO (" - Get Data\r\n");
819
820   gpg_do_get_data (tag, 0);
821 }
822
823 #define ECDSA_HASH_LEN 32
824 #define ECDSA_SIGNATURE_LENGTH 64
825
826 #define EDDSA_HASH_LEN_MAX 256
827 #define EDDSA_SIGNATURE_LENGTH 64
828
829 #define ECC_CIPHER_DO_HEADER_SIZE 7
830
831 static void
832 cmd_pso (void)
833 {
834   int len = apdu.cmd_apdu_data_len;
835   int r = -1;
836   int attr;
837   int pubkey_len;
838   unsigned int result_len = 0;
839   int cs;
840
841   DEBUG_INFO (" - PSO: ");
842   DEBUG_WORD ((uint32_t)&r);
843   DEBUG_BINARY (apdu.cmd_apdu_data, apdu.cmd_apdu_data_len);
844   DEBUG_SHORT (len);
845
846   if (P1 (apdu) == 0x9e && P2 (apdu) == 0x9a)
847     {
848       attr = gpg_get_algo_attr (GPG_KEY_FOR_SIGNING);
849       pubkey_len = gpg_get_algo_attr_key_size (GPG_KEY_FOR_SIGNING,
850                                                GPG_KEY_PUBLIC);
851
852       if (!ac_check_status (AC_PSO_CDS_AUTHORIZED))
853         {
854           DEBUG_INFO ("security error.");
855           GPG_SECURITY_FAILURE ();
856           return;
857         }
858
859       if (attr == ALGO_RSA2K || attr == ALGO_RSA4K)
860         {
861           /* Check size of digestInfo */
862           if (len != 34         /* MD5 */
863               && len != 35              /* SHA1 / RIPEMD-160 */
864               && len != 47              /* SHA224 */
865               && len != 51              /* SHA256 */
866               && len != 67              /* SHA384 */
867               && len != 83)             /* SHA512 */
868             {
869               DEBUG_INFO (" wrong length");
870               GPG_CONDITION_NOT_SATISFIED ();
871               return;
872             }
873
874           DEBUG_BINARY (kd[GPG_KEY_FOR_SIGNING].data, pubkey_len);
875
876           result_len = pubkey_len;
877           r = rsa_sign (apdu.cmd_apdu_data, res_APDU, len,
878                         &kd[GPG_KEY_FOR_SIGNING], pubkey_len);
879         }
880       else if (attr == ALGO_NISTP256R1 || attr == ALGO_SECP256K1)
881         {
882           /* ECDSA with p256r1/p256k1 for signature */
883           if (len != ECDSA_HASH_LEN)
884             {
885               DEBUG_INFO (" wrong length");
886               GPG_CONDITION_NOT_SATISFIED ();
887               return;
888             }
889
890           cs = chopstx_setcancelstate (0);
891           result_len = ECDSA_SIGNATURE_LENGTH;
892           if (attr == ALGO_NISTP256R1)
893             r = ecdsa_sign_p256r1 (apdu.cmd_apdu_data, res_APDU,
894                                    kd[GPG_KEY_FOR_SIGNING].data);
895           else                  /* ALGO_SECP256K1 */
896             r = ecdsa_sign_p256k1 (apdu.cmd_apdu_data, res_APDU,
897                                    kd[GPG_KEY_FOR_SIGNING].data);
898           chopstx_setcancelstate (cs);
899         }
900       else if (attr == ALGO_ED25519)
901         {
902           uint32_t output[64/4];        /* Require 4-byte alignment. */
903
904           if (len > EDDSA_HASH_LEN_MAX)
905             {
906               DEBUG_INFO ("wrong hash length.");
907               GPG_CONDITION_NOT_SATISFIED ();
908               return;
909             }
910
911           cs = chopstx_setcancelstate (0);
912           result_len = EDDSA_SIGNATURE_LENGTH;
913           r = eddsa_sign_25519 (apdu.cmd_apdu_data, len, output,
914                                 kd[GPG_KEY_FOR_SIGNING].data,
915                                 kd[GPG_KEY_FOR_SIGNING].data+32,
916                                 kd[GPG_KEY_FOR_SIGNING].pubkey);
917           chopstx_setcancelstate (cs);
918           memcpy (res_APDU, output, EDDSA_SIGNATURE_LENGTH);
919         }
920       else
921         {
922           DEBUG_INFO ("unknown algo.");
923           GPG_FUNCTION_NOT_SUPPORTED ();
924           return;
925         }
926
927       if (r == 0)
928         {
929           res_APDU_size = result_len;
930           gpg_increment_digital_signature_counter ();
931         }
932       else   /* Failure */
933         ac_reset_pso_cds ();
934     }
935   else if (P1 (apdu) == 0x80 && P2 (apdu) == 0x86)
936     {
937       attr = gpg_get_algo_attr (GPG_KEY_FOR_DECRYPTION);
938       pubkey_len = gpg_get_algo_attr_key_size (GPG_KEY_FOR_DECRYPTION,
939                                                GPG_KEY_PUBLIC);
940
941       DEBUG_BINARY (kd[GPG_KEY_FOR_DECRYPTION].data, pubkey_len);
942
943       if (!ac_check_status (AC_OTHER_AUTHORIZED))
944         {
945           DEBUG_INFO ("security error.");
946           GPG_SECURITY_FAILURE ();
947           return;
948         }
949
950       if (attr == ALGO_RSA2K || attr == ALGO_RSA4K)
951         {
952           /* Skip padding 0x00 */
953           len--;
954           if (len != pubkey_len)
955             {
956               GPG_CONDITION_NOT_SATISFIED ();
957               return;
958             }
959           r = rsa_decrypt (apdu.cmd_apdu_data+1, res_APDU, len,
960                            &kd[GPG_KEY_FOR_DECRYPTION], &result_len);
961         }
962       else if (attr == ALGO_NISTP256R1 || attr == ALGO_SECP256K1)
963         {
964           int header = ECC_CIPHER_DO_HEADER_SIZE;
965
966           /* Format is in big endian MPI: 04 || x || y */
967           if (len != 65 + ECC_CIPHER_DO_HEADER_SIZE
968               || apdu.cmd_apdu_data[header] != 0x04)
969             {
970               GPG_CONDITION_NOT_SATISFIED ();
971               return;
972             }
973
974           cs = chopstx_setcancelstate (0);
975           result_len = 65;
976           if (attr == ALGO_NISTP256R1)
977             r = ecdh_decrypt_p256r1 (apdu.cmd_apdu_data + header, res_APDU,
978                                      kd[GPG_KEY_FOR_DECRYPTION].data);
979           else
980             r = ecdh_decrypt_p256k1 (apdu.cmd_apdu_data + header, res_APDU,
981                                      kd[GPG_KEY_FOR_DECRYPTION].data);
982           chopstx_setcancelstate (cs);
983         }
984       else if (attr == ALGO_CURVE25519)
985         {
986           int header = ECC_CIPHER_DO_HEADER_SIZE;
987
988           if (len != 32 + ECC_CIPHER_DO_HEADER_SIZE)
989             {
990               GPG_CONDITION_NOT_SATISFIED ();
991               return;
992             }
993
994           cs = chopstx_setcancelstate (0);
995           result_len = 32;
996           r = ecdh_decrypt_curve25519 (apdu.cmd_apdu_data + header, res_APDU,
997                                        kd[GPG_KEY_FOR_DECRYPTION].data);
998           chopstx_setcancelstate (cs);
999         }
1000       else
1001         {
1002           DEBUG_INFO ("unknown algo.");
1003           GPG_FUNCTION_NOT_SUPPORTED ();
1004           return;
1005         }
1006
1007       if (r == 0)
1008         res_APDU_size = result_len;
1009     }
1010
1011   if (r < 0)
1012     {
1013       DEBUG_INFO (" - ??");
1014       DEBUG_BYTE (P1 (apdu));
1015       DEBUG_INFO (" - ??");
1016       DEBUG_BYTE (P2 (apdu));
1017       GPG_ERROR ();
1018     }
1019
1020   DEBUG_INFO ("PSO done.\r\n");
1021 }
1022
1023
1024 #define MAX_RSA_DIGEST_INFO_LEN 102 /* 40% */
1025 static void
1026 cmd_internal_authenticate (void)
1027 {
1028   int attr = gpg_get_algo_attr (GPG_KEY_FOR_AUTHENTICATION);
1029   int pubkey_len = gpg_get_algo_attr_key_size (GPG_KEY_FOR_AUTHENTICATION,
1030                                                GPG_KEY_PUBLIC);
1031   int len = apdu.cmd_apdu_data_len;
1032   int r = -1;
1033   unsigned int result_len = 0;
1034   int cs;
1035
1036   DEBUG_INFO (" - INTERNAL AUTHENTICATE\r\n");
1037
1038   if (P1 (apdu) != 0x00 || P2 (apdu) != 0x00)
1039     {
1040       DEBUG_INFO (" - ??");
1041       DEBUG_BYTE (P1 (apdu));
1042       DEBUG_INFO (" - ??");
1043       DEBUG_BYTE (P2 (apdu));
1044       GPG_CONDITION_NOT_SATISFIED ();
1045       return;
1046     }
1047
1048   DEBUG_SHORT (len);
1049   if (!ac_check_status (AC_OTHER_AUTHORIZED))
1050     {
1051       DEBUG_INFO ("security error.");
1052       GPG_SECURITY_FAILURE ();
1053       return;
1054     }
1055
1056   if (attr == ALGO_RSA2K || attr == ALGO_RSA4K)
1057     {
1058       if (len > MAX_RSA_DIGEST_INFO_LEN)
1059         {
1060           DEBUG_INFO ("input is too long.");
1061           GPG_CONDITION_NOT_SATISFIED ();
1062           return;
1063         }
1064
1065       result_len = pubkey_len;
1066       r = rsa_sign (apdu.cmd_apdu_data, res_APDU, len,
1067                     &kd[GPG_KEY_FOR_AUTHENTICATION], pubkey_len);
1068     }
1069   else if (attr == ALGO_NISTP256R1)
1070     {
1071       if (len != ECDSA_HASH_LEN)
1072         {
1073           DEBUG_INFO ("wrong hash length.");
1074           GPG_CONDITION_NOT_SATISFIED ();
1075           return;
1076         }
1077
1078       cs = chopstx_setcancelstate (0);
1079       result_len = ECDSA_SIGNATURE_LENGTH;
1080       r = ecdsa_sign_p256r1 (apdu.cmd_apdu_data, res_APDU,
1081                              kd[GPG_KEY_FOR_AUTHENTICATION].data);
1082       chopstx_setcancelstate (cs);
1083     }
1084   else if (attr == ALGO_SECP256K1)
1085     {
1086       if (len != ECDSA_HASH_LEN)
1087         {
1088           DEBUG_INFO ("wrong hash length.");
1089           GPG_CONDITION_NOT_SATISFIED ();
1090           return;
1091         }
1092
1093       cs = chopstx_setcancelstate (0);
1094       result_len = ECDSA_SIGNATURE_LENGTH;
1095       r = ecdsa_sign_p256k1 (apdu.cmd_apdu_data, res_APDU,
1096                              kd[GPG_KEY_FOR_AUTHENTICATION].data);
1097       chopstx_setcancelstate (cs);
1098     }
1099   else if (attr == ALGO_ED25519)
1100     {
1101       uint32_t output[64/4];    /* Require 4-byte alignment. */
1102
1103       if (len > EDDSA_HASH_LEN_MAX)
1104         {
1105           DEBUG_INFO ("wrong hash length.");
1106           GPG_CONDITION_NOT_SATISFIED ();
1107           return;
1108         }
1109
1110       cs = chopstx_setcancelstate (0);
1111       result_len = EDDSA_SIGNATURE_LENGTH;
1112       r = eddsa_sign_25519 (apdu.cmd_apdu_data, len, output,
1113                             kd[GPG_KEY_FOR_AUTHENTICATION].data,
1114                             kd[GPG_KEY_FOR_AUTHENTICATION].data+32,
1115                             kd[GPG_KEY_FOR_AUTHENTICATION].pubkey);
1116       chopstx_setcancelstate (cs);
1117       memcpy (res_APDU, output, EDDSA_SIGNATURE_LENGTH);
1118     }
1119
1120   if (r == 0)
1121     res_APDU_size = result_len;
1122   else
1123     GPG_ERROR ();
1124
1125   DEBUG_INFO ("INTERNAL AUTHENTICATE done.\r\n");
1126 }
1127
1128
1129 #define MBD_OPRATION_WRITE  0
1130 #define MBD_OPRATION_UPDATE 1
1131
1132 static void
1133 modify_binary (uint8_t op, uint8_t p1, uint8_t p2, int len)
1134 {
1135   uint8_t file_id;
1136   uint16_t offset;
1137   int is_short_EF = (p1 & 0x80) != 0;
1138   int r;
1139
1140   if (!ac_check_status (AC_ADMIN_AUTHORIZED))
1141     {
1142       DEBUG_INFO ("security error.");
1143       GPG_SECURITY_FAILURE ();
1144       return;
1145     }
1146
1147   if (is_short_EF)
1148     file_id = (p1 & 0x1f);
1149   else
1150     file_id = file_selection - FILE_EF_SERIAL_NO + FILEID_SERIAL_NO;
1151
1152   if (!FILEID_CH_CERTIFICATE_IS_VALID && file_id == FILEID_CH_CERTIFICATE)
1153     {
1154       GPG_NO_FILE ();
1155       return;
1156     }
1157
1158   if (op == MBD_OPRATION_UPDATE && file_id != FILEID_CH_CERTIFICATE)
1159     {
1160       GPG_CONDITION_NOT_SATISFIED ();
1161       return;
1162     }
1163
1164   if (file_id > FILEID_CH_CERTIFICATE)
1165     {
1166       GPG_NO_FILE ();
1167       return;
1168     }
1169
1170   if (is_short_EF)
1171     {
1172       file_selection = file_id - FILEID_SERIAL_NO + FILE_EF_SERIAL_NO;
1173       offset = p2;
1174
1175       if (op == MBD_OPRATION_UPDATE)
1176         {
1177           r = flash_erase_binary (file_id);
1178           if (r < 0)
1179             {
1180               DEBUG_INFO ("memory error.\r\n");
1181               GPG_MEMORY_FAILURE ();
1182               return;
1183             }
1184         }
1185     }
1186   else
1187     offset = (p1 << 8) | p2;
1188
1189   DEBUG_SHORT (len);
1190   DEBUG_SHORT (offset);
1191
1192   if (file_id == FILEID_CH_CERTIFICATE && (len&1))
1193     /* It's OK the size of last write is odd.  */
1194     apdu.cmd_apdu_data[len++] = 0xff;
1195
1196   r = flash_write_binary (file_id, apdu.cmd_apdu_data, len, offset);
1197   if (r < 0)
1198     {
1199       DEBUG_INFO ("memory error.\r\n");
1200       GPG_MEMORY_FAILURE ();
1201       return;
1202     }
1203
1204   if (file_id >= FILEID_UPDATE_KEY_0 && file_id <= FILEID_UPDATE_KEY_3
1205       && len == 0 && offset == 0)
1206     {
1207       int i;
1208       const uint8_t *p;
1209
1210       for (i = 0; i < 4; i++)
1211         {
1212           p = gpg_get_firmware_update_key (i);
1213           if (p[0] != 0x00 || p[1] != 0x00) /* still valid */
1214             break;
1215         }
1216
1217       if (i == 4)                       /* all update keys are removed */
1218         {
1219           p = gpg_get_firmware_update_key (0);
1220           flash_erase_page ((uint32_t)p);
1221         }
1222     }
1223
1224   GPG_SUCCESS ();
1225 }
1226
1227
1228 #if defined(CERTDO_SUPPORT)
1229 static void
1230 cmd_update_binary (void)
1231 {
1232   int len = apdu.cmd_apdu_data_len;
1233
1234   DEBUG_INFO (" - UPDATE BINARY\r\n");
1235   modify_binary (MBD_OPRATION_UPDATE, P1 (apdu), P2 (apdu), len);
1236   DEBUG_INFO ("UPDATE BINARY done.\r\n");
1237 }
1238 #endif
1239
1240
1241 static void
1242 cmd_write_binary (void)
1243 {
1244   int len = apdu.cmd_apdu_data_len;
1245
1246   DEBUG_INFO (" - WRITE BINARY\r\n");
1247   modify_binary (MBD_OPRATION_WRITE, P1 (apdu), P2 (apdu), len);
1248   DEBUG_INFO ("WRITE BINARY done.\r\n");
1249 }
1250
1251
1252 static void
1253 cmd_external_authenticate (void)
1254 {
1255   const uint8_t *pubkey;
1256   const uint8_t *signature = apdu.cmd_apdu_data;
1257   int len = apdu.cmd_apdu_data_len;
1258   uint8_t keyno = P2 (apdu);
1259   int r;
1260
1261   DEBUG_INFO (" - EXTERNAL AUTHENTICATE\r\n");
1262
1263   if (keyno >= 4)
1264     {
1265       GPG_CONDITION_NOT_SATISFIED ();
1266       return;
1267     }
1268
1269   pubkey = gpg_get_firmware_update_key (keyno);
1270   if (len != 256
1271       || (pubkey[0] == 0xff && pubkey[1] == 0xff) /* not registered */
1272       || (pubkey[0] == 0x00 && pubkey[1] == 0x00) /* removed */)
1273     {
1274       GPG_CONDITION_NOT_SATISFIED ();
1275       return;
1276     }
1277
1278   r = rsa_verify (pubkey, FIRMWARE_UPDATE_KEY_CONTENT_LEN,
1279                   challenge, signature);
1280   random_bytes_free (challenge);
1281   challenge = NULL;
1282
1283   if (r < 0)
1284     {
1285       GPG_SECURITY_FAILURE ();
1286       return;
1287     }
1288
1289   eventflag_signal (openpgp_comm, EV_EXIT); /* signal to self.  */
1290   set_res_sw (0xff, 0xff);
1291   DEBUG_INFO ("EXTERNAL AUTHENTICATE done.\r\n");
1292 }
1293
1294 static void
1295 cmd_get_challenge (void)
1296 {
1297   int len = apdu.expected_res_size;
1298
1299   DEBUG_INFO (" - GET CHALLENGE\r\n");
1300
1301   if (len > CHALLENGE_LEN)
1302     {
1303       GPG_CONDITION_NOT_SATISFIED ();
1304       return;
1305     }
1306   else if (len == 0)
1307     /* Le is not specified.  Return full-sized challenge by GET_RESPONSE.  */
1308     len = CHALLENGE_LEN;
1309
1310   if (challenge)
1311     random_bytes_free (challenge);
1312
1313   challenge = random_bytes_get ();
1314   memcpy (res_APDU, challenge, len);
1315   res_APDU_size = len;
1316   GPG_SUCCESS ();
1317   DEBUG_INFO ("GET CHALLENGE done.\r\n");
1318 }
1319
1320
1321 #ifdef LIFE_CYCLE_MANAGEMENT_SUPPORT
1322 static void
1323 cmd_activate_file (void)
1324 {
1325   if (file_selection != FILE_CARD_TERMINATED_OPENPGP)
1326     {
1327       GPG_NO_RECORD();
1328       return;
1329     }
1330
1331   flash_activate ();
1332   file_selection = FILE_DF_OPENPGP;
1333   GPG_SUCCESS ();
1334 }
1335
1336 static void
1337 cmd_terminate_df (void)
1338 {
1339   uint8_t p1 = P1 (apdu);
1340   uint8_t p2 = P2 (apdu);
1341
1342   if (file_selection != FILE_DF_OPENPGP)
1343     {
1344       GPG_NO_RECORD();
1345       return;
1346     }
1347
1348   if (p1 != 0 || p2 != 0)
1349     {
1350       GPG_BAD_P1_P2();
1351       return;
1352     }
1353
1354   if (apdu.cmd_apdu_data_len != 0)
1355     {
1356       GPG_WRONG_LENGTH();
1357       return;
1358     }
1359
1360
1361   if (!ac_check_status (AC_ADMIN_AUTHORIZED) && !gpg_pw_locked (PW_ERR_PW3))
1362     {
1363       /* Only allow the case admin authorized, or, admin pass is locked.  */
1364       GPG_SECURITY_FAILURE();
1365       return;
1366     }
1367
1368   ac_reset_admin ();
1369   ac_reset_pso_cds ();
1370   ac_reset_other ();
1371   gpg_do_terminate ();
1372   flash_terminate ();
1373   file_selection = FILE_CARD_TERMINATED;
1374   GPG_SUCCESS ();
1375 }
1376 #endif
1377
1378
1379 struct command
1380 {
1381   uint8_t command;
1382   void (*cmd_handler) (void);
1383 };
1384
1385 const struct command cmds[] = {
1386   { INS_VERIFY, cmd_verify },
1387   { INS_CHANGE_REFERENCE_DATA, cmd_change_password },
1388   { INS_PSO, cmd_pso },
1389   { INS_RESET_RETRY_COUNTER, cmd_reset_user_password },
1390 #ifdef LIFE_CYCLE_MANAGEMENT_SUPPORT
1391   { INS_ACTIVATE_FILE, cmd_activate_file },
1392 #endif
1393   { INS_PGP_GENERATE_ASYMMETRIC_KEY_PAIR, cmd_pgp_gakp },
1394   { INS_EXTERNAL_AUTHENTICATE,              /* Not in OpenPGP card protocol */
1395     cmd_external_authenticate },
1396   { INS_GET_CHALLENGE, cmd_get_challenge }, /* Not in OpenPGP card protocol */
1397   { INS_INTERNAL_AUTHENTICATE, cmd_internal_authenticate },
1398   { INS_SELECT_FILE, cmd_select_file },
1399   { INS_READ_BINARY, cmd_read_binary },     /* Not in OpenPGP card protocol */
1400   { INS_GET_DATA, cmd_get_data },
1401   { INS_WRITE_BINARY, cmd_write_binary},    /* Not in OpenPGP card protocol */
1402 #if defined(CERTDO_SUPPORT)
1403   { INS_UPDATE_BINARY, cmd_update_binary }, /* Not in OpenPGP card protocol */
1404 #endif
1405   { INS_PUT_DATA, cmd_put_data },
1406   { INS_PUT_DATA_ODD, cmd_put_data },
1407 #ifdef LIFE_CYCLE_MANAGEMENT_SUPPORT
1408   { INS_TERMINATE_DF, cmd_terminate_df},
1409 #endif
1410 };
1411 #define NUM_CMDS ((int)(sizeof (cmds) / sizeof (struct command)))
1412
1413 static void
1414 process_command_apdu (void)
1415 {
1416   int i;
1417   uint8_t cmd = INS (apdu);
1418
1419   for (i = 0; i < NUM_CMDS; i++)
1420     if (cmds[i].command == cmd)
1421       break;
1422
1423   if (i < NUM_CMDS)
1424     {
1425       if (file_selection == FILE_CARD_TERMINATED
1426           && cmd != INS_SELECT_FILE && cmd != INS_ACTIVATE_FILE
1427           && cmd != INS_GET_CHALLENGE && cmd != INS_EXTERNAL_AUTHENTICATE)
1428         GPG_APPLICATION_TERMINATED();
1429       else if (file_selection != FILE_DF_OPENPGP
1430                && cmd != INS_SELECT_FILE && cmd != INS_ACTIVATE_FILE
1431                && cmd != INS_GET_CHALLENGE && cmd != INS_EXTERNAL_AUTHENTICATE
1432                && cmd != INS_WRITE_BINARY && cmd != INS_UPDATE_BINARY
1433                && cmd != INS_READ_BINARY)
1434         GPG_NO_RECORD();
1435       else
1436         {
1437           chopstx_setcancelstate (1);
1438           cmds[i].cmd_handler ();
1439           chopstx_setcancelstate (0);
1440         }
1441     }
1442   else
1443     {
1444       DEBUG_INFO (" - ??");
1445       DEBUG_BYTE (cmd);
1446       GPG_NO_INS ();
1447     }
1448 }
1449
1450 void *
1451 openpgp_card_thread (void *arg)
1452 {
1453   struct eventflag *ccid_comm = (struct eventflag *)arg;
1454
1455   openpgp_comm = ccid_comm + 1;
1456
1457   gpg_init ();
1458
1459   while (1)
1460     {
1461 #if defined(PINPAD_SUPPORT)
1462       int len, pw_len, newpw_len;
1463 #endif
1464       eventmask_t m = eventflag_wait (openpgp_comm);
1465
1466       DEBUG_INFO ("GPG!: ");
1467
1468       if (m == EV_VERIFY_CMD_AVAILABLE)
1469         {
1470 #if defined(PINPAD_SUPPORT)
1471           if (INS (apdu) != INS_VERIFY)
1472             {
1473               GPG_CONDITION_NOT_SATISFIED ();
1474               goto done;
1475             }
1476
1477           pw_len = get_pinpad_input (PIN_INPUT_CURRENT);
1478           if (pw_len < 0)
1479             {
1480               GPG_ERROR ();
1481               goto done;
1482             }
1483           memcpy (apdu.cmd_apdu_data, pin_input_buffer, pw_len);
1484           apdu.cmd_apdu_data_len = pw_len;
1485 #else
1486           GPG_ERROR ();
1487           goto done;
1488 #endif
1489         }
1490       else if (m == EV_MODIFY_CMD_AVAILABLE)
1491         {
1492 #if defined(PINPAD_SUPPORT)
1493           uint8_t bConfirmPIN = apdu.cmd_apdu_data[0];
1494           uint8_t *p = apdu.cmd_apdu_data;
1495
1496           if (INS (apdu) != INS_CHANGE_REFERENCE_DATA
1497               && INS (apdu) != INS_RESET_RETRY_COUNTER
1498               && INS (apdu) != INS_PUT_DATA)
1499             {
1500               GPG_CONDITION_NOT_SATISFIED ();
1501               goto done;
1502             }
1503
1504           if ((bConfirmPIN & 2))        /* Require old PIN */
1505             {
1506               pw_len = get_pinpad_input (PIN_INPUT_CURRENT);
1507               if (pw_len < 0)
1508                 {
1509                   GPG_ERROR ();
1510                   goto done;
1511                 }
1512               memcpy (p, pin_input_buffer, pw_len);
1513               p += pw_len;
1514             }
1515           else
1516             pw_len = 0;
1517
1518           newpw_len = get_pinpad_input (PIN_INPUT_NEW);
1519           if (newpw_len < 0)
1520             {
1521               GPG_ERROR ();
1522               goto done;
1523             }
1524           memcpy (p, pin_input_buffer, newpw_len);
1525
1526           if ((bConfirmPIN & 1))        /* New PIN twice */
1527             {
1528               len = get_pinpad_input (PIN_INPUT_CONFIRM);
1529               if (len < 0)
1530                 {
1531                   GPG_ERROR ();
1532                   goto done;
1533                 }
1534
1535               if (len != newpw_len || memcmp (p, pin_input_buffer, len) != 0)
1536                 {
1537                   GPG_SECURITY_FAILURE ();
1538                   goto done;
1539                 }
1540             }
1541
1542           apdu.cmd_apdu_data_len = pw_len + newpw_len;
1543 #else
1544           GPG_ERROR ();
1545           goto done;
1546 #endif
1547         }
1548       else if (m == EV_EXIT)
1549         break;
1550
1551       led_blink (LED_START_COMMAND);
1552       process_command_apdu ();
1553       led_blink (LED_FINISH_COMMAND);
1554     done:
1555       eventflag_signal (ccid_comm, EV_EXEC_FINISHED);
1556     }
1557
1558   gpg_fini ();
1559   return NULL;
1560 }