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