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