change of S2K
[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 "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   const uint8_t *unique = unique_device_id ();
441
442   sha256_start (&ctx);
443
444   sha256_update (&ctx, unique, 12);
445
446   while (count > slen + ilen)
447     {
448       if (slen)
449         sha256_update (&ctx, salt, slen);
450       sha256_update (&ctx, input, ilen);
451       count -= slen + ilen;
452     }
453
454   if (count <= slen)
455     sha256_update (&ctx, salt, count);
456   else
457     {
458       if (slen)
459         {
460           sha256_update (&ctx, salt, slen);
461           count -= slen;
462         }
463       sha256_update (&ctx, input, count);
464     }
465
466   sha256_finish (&ctx, output);
467 }
468
469
470 static void
471 cmd_reset_user_password (void)
472 {
473   uint8_t p1 = P1 (apdu);
474   int len;
475   const uint8_t *pw;
476   const uint8_t *newpw;
477   int pw_len, newpw_len;
478   int r;
479   uint8_t new_ks0[KEYSTRING_SIZE];
480   uint8_t *new_ks = KS_GET_KEYSTRING (new_ks0);
481   uint8_t *new_salt = KS_GET_SALT (new_ks0);
482   const uint8_t *salt;
483   int salt_len;
484
485   DEBUG_INFO ("Reset PW1\r\n");
486   DEBUG_BYTE (p1);
487
488   len = apdu.cmd_apdu_data_len;
489   pw = apdu.cmd_apdu_data;
490
491   if (p1 == 0x00)               /* by User with Reseting Code */
492     {
493       const uint8_t *ks_rc = gpg_do_read_simple (NR_DO_KEYSTRING_RC);
494       uint8_t old_ks[KEYSTRING_MD_SIZE];
495
496       if (gpg_pw_locked (PW_ERR_RC))
497         {
498           DEBUG_INFO ("blocked.\r\n");
499           GPG_SECURITY_AUTH_BLOCKED ();
500           return;
501         }
502
503       if (ks_rc == NULL)
504         {
505           DEBUG_INFO ("security error.\r\n");
506           GPG_SECURITY_FAILURE ();
507           return;
508         }
509
510       pw_len = ks_rc[0] & PW_LEN_MASK;
511       salt = KS_GET_SALT (ks_rc);
512       salt_len = SALT_SIZE;
513       newpw = pw + pw_len;
514       newpw_len = len - pw_len;
515       random_get_salt (new_salt);
516       s2k (salt, salt_len, pw, pw_len, old_ks);
517       s2k (new_salt, SALT_SIZE, newpw, newpw_len, new_ks);
518       new_ks0[0] = newpw_len;
519       r = gpg_change_keystring (BY_RESETCODE, old_ks, BY_USER, new_ks);
520       if (r <= -2)
521         {
522           DEBUG_INFO ("memory error.\r\n");
523           GPG_MEMORY_FAILURE ();
524         }
525       else if (r < 0)
526         {
527           DEBUG_INFO ("failed.\r\n");
528           gpg_pw_increment_err_counter (PW_ERR_RC);
529           GPG_SECURITY_FAILURE ();
530         }
531       else if (r == 0)
532         {
533           DEBUG_INFO ("user pass change not supported with no keys.\r\n");
534           GPG_CONDITION_NOT_SATISFIED ();
535         }
536       else
537         {
538           DEBUG_INFO ("done.\r\n");
539           gpg_do_write_simple (NR_DO_KEYSTRING_PW1, new_ks0, KS_META_SIZE);
540           ac_reset_pso_cds ();
541           ac_reset_other ();
542           if (admin_authorized == BY_USER)
543             ac_reset_admin ();
544           gpg_pw_reset_err_counter (PW_ERR_RC);
545           gpg_pw_reset_err_counter (PW_ERR_PW1);
546           GPG_SUCCESS ();
547         }
548     }
549   else                          /* by Admin (p1 == 0x02) */
550     {
551       const uint8_t *old_ks = keystring_md_pw3;
552
553       if (!ac_check_status (AC_ADMIN_AUTHORIZED))
554         {
555           DEBUG_INFO ("permission denied.\r\n");
556           GPG_SECURITY_FAILURE ();
557           return;
558         }
559
560       newpw_len = len;
561       newpw = pw;
562       random_get_salt (new_salt);
563       s2k (new_salt, SALT_SIZE, newpw, newpw_len, new_ks);
564       new_ks0[0] = newpw_len;
565       r = gpg_change_keystring (admin_authorized, old_ks, BY_USER, new_ks);
566       if (r <= -2)
567         {
568           DEBUG_INFO ("memory error.\r\n");
569           GPG_MEMORY_FAILURE ();
570         }
571       else if (r < 0)
572         {
573           DEBUG_INFO ("security error.\r\n");
574           GPG_SECURITY_FAILURE ();
575         }
576       else if (r == 0)
577         {
578           DEBUG_INFO ("user pass change not supported with no keys.\r\n");
579           GPG_CONDITION_NOT_SATISFIED ();
580         }
581       else
582         {
583           DEBUG_INFO ("done.\r\n");
584           gpg_do_write_simple (NR_DO_KEYSTRING_PW1, new_ks0, KS_META_SIZE);
585           ac_reset_pso_cds ();
586           ac_reset_other ();
587           if (admin_authorized == BY_USER)
588             ac_reset_admin ();
589           gpg_pw_reset_err_counter (PW_ERR_PW1);
590           GPG_SUCCESS ();
591         }
592     }
593 }
594
595 static void
596 cmd_put_data (void)
597 {
598   uint8_t *data;
599   uint16_t tag;
600   int len;
601
602   DEBUG_INFO (" - PUT DATA\r\n");
603
604   if (file_selection != FILE_DF_OPENPGP)
605     GPG_NO_RECORD();
606
607   tag = ((P1 (apdu)<<8) | P2 (apdu));
608   len = apdu.cmd_apdu_data_len;
609   data = apdu.cmd_apdu_data;
610   gpg_do_put_data (tag, data, len);
611 }
612
613 static void
614 cmd_pgp_gakp (void)
615 {
616   DEBUG_INFO (" - Generate Asymmetric Key Pair\r\n");
617   DEBUG_BYTE (P1 (apdu));
618
619   if (P1 (apdu) == 0x81)
620     /* Get public key */
621     gpg_do_public_key (apdu.cmd_apdu_data[0]);
622   else
623     {
624       if (!ac_check_status (AC_ADMIN_AUTHORIZED))
625         GPG_SECURITY_FAILURE ();
626       gpg_do_keygen (apdu.cmd_apdu_data[0]);
627     }
628 }
629
630 const uint8_t *
631 gpg_get_firmware_update_key (uint8_t keyno)
632 {
633   extern uint8_t _updatekey_store;
634   const uint8_t *p;
635
636   p = &_updatekey_store + keyno * FIRMWARE_UPDATE_KEY_CONTENT_LEN;
637   return p;
638 }
639
640 #ifdef CERTDO_SUPPORT
641 #define FILEID_CH_CERTIFICATE_IS_VALID 1
642 #else
643 #define FILEID_CH_CERTIFICATE_IS_VALID 0
644 #endif
645
646 static void
647 cmd_read_binary (void)
648 {
649   int is_short_EF = (P1 (apdu) & 0x80) != 0;
650   uint8_t file_id;
651   const uint8_t *p;
652   uint16_t offset;
653
654   DEBUG_INFO (" - Read binary\r\n");
655
656   if (is_short_EF)
657     file_id = (P1 (apdu) & 0x1f);
658   else
659     file_id = file_selection - FILE_EF_SERIAL_NO + FILEID_SERIAL_NO;
660
661   if ((!FILEID_CH_CERTIFICATE_IS_VALID && file_id == FILEID_CH_CERTIFICATE)
662       || file_id > FILEID_CH_CERTIFICATE)
663     {
664       GPG_NO_FILE ();
665       return;
666     }
667
668   if (is_short_EF)
669     {
670       file_selection = file_id - FILEID_SERIAL_NO + FILE_EF_SERIAL_NO;
671       offset = P2 (apdu);
672     }
673   else
674     offset = (P1 (apdu) << 8) | P2 (apdu);
675
676   if (file_id == FILEID_SERIAL_NO)
677     {
678       if (offset != 0)
679         GPG_BAD_P1_P2 ();
680       else
681         {
682           gpg_do_get_data (0x004f, 1); /* Get AID... */
683           res_APDU[0] = 0x5a; /* ... and overwrite the first byte of data. */
684         }
685       return;
686     }
687
688   if (file_id >= FILEID_UPDATE_KEY_0 && file_id <= FILEID_UPDATE_KEY_3)
689     {
690       if (offset != 0)
691         GPG_MEMORY_FAILURE ();
692       else
693         {
694           p = gpg_get_firmware_update_key (file_id - FILEID_UPDATE_KEY_0);
695           res_APDU_size = FIRMWARE_UPDATE_KEY_CONTENT_LEN;
696           memcpy (res_APDU, p, FIRMWARE_UPDATE_KEY_CONTENT_LEN);
697           GPG_SUCCESS ();
698         }
699     }
700 #if defined(CERTDO_SUPPORT)
701   else /* file_id == FILEID_CH_CERTIFICATE */
702     {
703       uint16_t len = 256;
704
705       p = &ch_certificate_start;
706       if (offset >= FLASH_CH_CERTIFICATE_SIZE)
707         GPG_MEMORY_FAILURE ();
708       else
709         {
710           if (offset + len >= FLASH_CH_CERTIFICATE_SIZE)
711             len = FLASH_CH_CERTIFICATE_SIZE - offset;
712
713           res_APDU_size = len;
714           memcpy (res_APDU, p + offset, len);
715           GPG_SUCCESS ();
716         }
717     }
718 #endif
719 }
720
721 static void
722 cmd_select_file (void)
723 {
724   if (P1 (apdu) == 4)   /* Selection by DF name */
725     {
726       DEBUG_INFO (" - select DF by name\r\n");
727
728       /* name = D2 76 00 01 24 01 */
729       if (apdu.cmd_apdu_data_len != 6
730           || memcmp (openpgpcard_aid, apdu.cmd_apdu_data, 6) != 0)
731         {
732           DEBUG_SHORT (apdu.cmd_apdu_data_len);
733           DEBUG_BINARY (apdu.cmd_apdu_data, apdu.cmd_apdu_data_len);
734
735           GPG_NO_FILE ();
736           return;
737         }
738
739       file_selection = FILE_DF_OPENPGP;
740       if ((P2 (apdu) & 0x0c) == 0x0c)   /* No FCI */
741         GPG_SUCCESS ();
742       else
743         {
744           gpg_do_get_data (0x004f, 1); /* AID */
745           memmove (res_APDU+2, res_APDU, res_APDU_size);
746           res_APDU[0] = 0x6f;
747           res_APDU[1] = 0x12;
748           res_APDU[2] = 0x84;   /* overwrite: DF name */
749           res_APDU_size += 2;
750           GPG_SUCCESS ();
751         }
752     }
753   else if (apdu.cmd_apdu_data_len == 2
754            && apdu.cmd_apdu_data[0] == 0x2f && apdu.cmd_apdu_data[1] == 0x02)
755     {
756       DEBUG_INFO (" - select 0x2f02 EF\r\n");
757       /*
758        * MF.EF-GDO -- Serial number of the card and name of the owner
759        */
760       GPG_SUCCESS ();
761       file_selection = FILE_EF_SERIAL_NO;
762     }
763   else if (apdu.cmd_apdu_data_len == 2
764            && apdu.cmd_apdu_data[0] == 0x3f && apdu.cmd_apdu_data[1] == 0x00)
765     {
766       DEBUG_INFO (" - select ROOT MF\r\n");
767       if (P2 (apdu) == 0x0c)
768         {
769           GPG_SUCCESS ();
770         }
771       else
772         {
773           int len = sizeof (select_file_TOP_result);
774
775           res_APDU_size = len;
776           memcpy (res_APDU, select_file_TOP_result, len);
777           res_APDU[2] = (data_objects_number_of_bytes & 0xff);
778           res_APDU[3] = (data_objects_number_of_bytes >> 8);
779           GPG_SUCCESS ();
780         }
781
782       file_selection = FILE_MF;
783       ac_fini ();               /* Reset authentication */
784     }
785   else
786     {
787       DEBUG_INFO (" - select ?? \r\n");
788
789       file_selection = FILE_NONE;
790       GPG_NO_FILE ();
791     }
792 }
793
794 static void
795 cmd_get_data (void)
796 {
797   uint16_t tag = ((P1 (apdu)<<8) | P2 (apdu));
798
799   DEBUG_INFO (" - Get Data\r\n");
800
801   if (file_selection != FILE_DF_OPENPGP)
802     GPG_NO_RECORD ();
803
804   gpg_do_get_data (tag, 0);
805 }
806
807 #define ECDSA_HASH_LEN 32
808 #define ECDSA_SIGNATURE_LENGTH 64
809
810 #define EDDSA_HASH_LEN_MAX 256
811 #define EDDSA_SIGNATURE_LENGTH 64
812
813 #define ECC_CIPHER_DO_HEADER_SIZE 7
814
815 static void
816 cmd_pso (void)
817 {
818   int len = apdu.cmd_apdu_data_len;
819   int r = -1;
820   int attr;
821   int pubkey_len;
822   unsigned int result_len = 0;
823   int cs;
824
825   DEBUG_INFO (" - PSO: ");
826   DEBUG_WORD ((uint32_t)&r);
827   DEBUG_BINARY (apdu.cmd_apdu_data, apdu.cmd_apdu_data_len);
828   DEBUG_SHORT (len);
829
830   if (P1 (apdu) == 0x9e && P2 (apdu) == 0x9a)
831     {
832       attr = gpg_get_algo_attr (GPG_KEY_FOR_SIGNING);
833       pubkey_len = gpg_get_algo_attr_key_size (GPG_KEY_FOR_SIGNING,
834                                                GPG_KEY_PUBLIC);
835
836       if (!ac_check_status (AC_PSO_CDS_AUTHORIZED))
837         {
838           DEBUG_INFO ("security error.");
839           GPG_SECURITY_FAILURE ();
840           return;
841         }
842
843       if (attr == ALGO_RSA2K || attr == ALGO_RSA4K)
844         {
845           /* Check size of digestInfo */
846           if (len != 34         /* MD5 */
847               && len != 35              /* SHA1 / RIPEMD-160 */
848               && len != 47              /* SHA224 */
849               && len != 51              /* SHA256 */
850               && len != 67              /* SHA384 */
851               && len != 83)             /* SHA512 */
852             {
853               DEBUG_INFO (" wrong length");
854               GPG_CONDITION_NOT_SATISFIED ();
855               return;
856             }
857
858           DEBUG_BINARY (kd[GPG_KEY_FOR_SIGNING].data, pubkey_len);
859
860           result_len = pubkey_len;
861           r = rsa_sign (apdu.cmd_apdu_data, res_APDU, len,
862                         &kd[GPG_KEY_FOR_SIGNING], pubkey_len);
863         }
864       else if (attr == ALGO_NISTP256R1 || attr == ALGO_SECP256K1)
865         {
866           /* ECDSA with p256r1/p256k1 for signature */
867           if (len != ECDSA_HASH_LEN)
868             {
869               DEBUG_INFO (" wrong length");
870               GPG_CONDITION_NOT_SATISFIED ();
871               return;
872             }
873
874           cs = chopstx_setcancelstate (0);
875           result_len = ECDSA_SIGNATURE_LENGTH;
876           if (attr == ALGO_NISTP256R1)
877             r = ecdsa_sign_p256r1 (apdu.cmd_apdu_data, res_APDU,
878                                    kd[GPG_KEY_FOR_SIGNING].data);
879           else                  /* ALGO_SECP256K1 */
880             r = ecdsa_sign_p256k1 (apdu.cmd_apdu_data, res_APDU,
881                                    kd[GPG_KEY_FOR_SIGNING].data);
882           chopstx_setcancelstate (cs);
883         }
884       else if (attr == ALGO_ED25519)
885         {
886           uint32_t output[64/4];        /* Require 4-byte alignment. */
887
888           if (len > EDDSA_HASH_LEN_MAX)
889             {
890               DEBUG_INFO ("wrong hash length.");
891               GPG_CONDITION_NOT_SATISFIED ();
892               return;
893             }
894
895           cs = chopstx_setcancelstate (0);
896           result_len = EDDSA_SIGNATURE_LENGTH;
897           r = eddsa_sign_25519 (apdu.cmd_apdu_data, len, output,
898                                 kd[GPG_KEY_FOR_SIGNING].data,
899                                 kd[GPG_KEY_FOR_SIGNING].data+32,
900                                 kd[GPG_KEY_FOR_SIGNING].pubkey);
901           chopstx_setcancelstate (cs);
902           memcpy (res_APDU, output, EDDSA_SIGNATURE_LENGTH);
903         }
904       else
905         {
906           DEBUG_INFO ("unknown algo.");
907           GPG_FUNCTION_NOT_SUPPORTED ();
908           return;
909         }
910
911       if (r == 0)
912         {
913           res_APDU_size = result_len;
914           gpg_increment_digital_signature_counter ();
915         }
916       else   /* Failure */
917         ac_reset_pso_cds ();
918     }
919   else if (P1 (apdu) == 0x80 && P2 (apdu) == 0x86)
920     {
921       attr = gpg_get_algo_attr (GPG_KEY_FOR_DECRYPTION);
922       pubkey_len = gpg_get_algo_attr_key_size (GPG_KEY_FOR_DECRYPTION,
923                                                GPG_KEY_PUBLIC);
924
925       DEBUG_BINARY (kd[GPG_KEY_FOR_DECRYPTION].data, pubkey_len);
926
927       if (!ac_check_status (AC_OTHER_AUTHORIZED))
928         {
929           DEBUG_INFO ("security error.");
930           GPG_SECURITY_FAILURE ();
931           return;
932         }
933
934       if (attr == ALGO_RSA2K || attr == ALGO_RSA4K)
935         {
936           /* Skip padding 0x00 */
937           len--;
938           if (len != pubkey_len)
939             {
940               GPG_CONDITION_NOT_SATISFIED ();
941               return;
942             }
943           r = rsa_decrypt (apdu.cmd_apdu_data+1, res_APDU, len,
944                            &kd[GPG_KEY_FOR_DECRYPTION], &result_len);
945         }
946       else if (attr == ALGO_NISTP256R1 || attr == ALGO_SECP256K1)
947         {
948           int header = ECC_CIPHER_DO_HEADER_SIZE;
949
950           /* Format is in big endian MPI: 04 || x || y */
951           if (len != 65 + ECC_CIPHER_DO_HEADER_SIZE
952               || apdu.cmd_apdu_data[header] != 0x04)
953             {
954               GPG_CONDITION_NOT_SATISFIED ();
955               return;
956             }
957
958           cs = chopstx_setcancelstate (0);
959           result_len = 65;
960           if (attr == ALGO_NISTP256R1)
961             r = ecdh_decrypt_p256r1 (apdu.cmd_apdu_data + header, res_APDU,
962                                      kd[GPG_KEY_FOR_DECRYPTION].data);
963           else
964             r = ecdh_decrypt_p256k1 (apdu.cmd_apdu_data + header, res_APDU,
965                                      kd[GPG_KEY_FOR_DECRYPTION].data);
966           chopstx_setcancelstate (cs);
967         }
968       else if (attr == ALGO_CURVE25519)
969         {
970           int header = ECC_CIPHER_DO_HEADER_SIZE;
971
972           if (len != 32 + ECC_CIPHER_DO_HEADER_SIZE)
973             {
974               GPG_CONDITION_NOT_SATISFIED ();
975               return;
976             }
977
978           cs = chopstx_setcancelstate (0);
979           result_len = 32;
980           r = ecdh_decrypt_curve25519 (apdu.cmd_apdu_data + header, res_APDU,
981                                        kd[GPG_KEY_FOR_DECRYPTION].data);
982           chopstx_setcancelstate (cs);
983         }
984       else
985         {
986           DEBUG_INFO ("unknown algo.");
987           GPG_FUNCTION_NOT_SUPPORTED ();
988           return;
989         }
990
991       if (r == 0)
992         res_APDU_size = result_len;
993     }
994
995   if (r < 0)
996     {
997       DEBUG_INFO (" - ??");
998       DEBUG_BYTE (P1 (apdu));
999       DEBUG_INFO (" - ??");
1000       DEBUG_BYTE (P2 (apdu));
1001       GPG_ERROR ();
1002     }
1003
1004   DEBUG_INFO ("PSO done.\r\n");
1005 }
1006
1007
1008 #define MAX_RSA_DIGEST_INFO_LEN 102 /* 40% */
1009 static void
1010 cmd_internal_authenticate (void)
1011 {
1012   int attr = gpg_get_algo_attr (GPG_KEY_FOR_AUTHENTICATION);
1013   int pubkey_len = gpg_get_algo_attr_key_size (GPG_KEY_FOR_AUTHENTICATION,
1014                                                GPG_KEY_PUBLIC);
1015   int len = apdu.cmd_apdu_data_len;
1016   int r = -1;
1017   unsigned int result_len = 0;
1018   int cs;
1019
1020   DEBUG_INFO (" - INTERNAL AUTHENTICATE\r\n");
1021
1022   if (P1 (apdu) != 0x00 || P2 (apdu) != 0x00)
1023     {
1024       DEBUG_INFO (" - ??");
1025       DEBUG_BYTE (P1 (apdu));
1026       DEBUG_INFO (" - ??");
1027       DEBUG_BYTE (P2 (apdu));
1028       GPG_CONDITION_NOT_SATISFIED ();
1029       return;
1030     }
1031
1032   DEBUG_SHORT (len);
1033   if (!ac_check_status (AC_OTHER_AUTHORIZED))
1034     {
1035       DEBUG_INFO ("security error.");
1036       GPG_SECURITY_FAILURE ();
1037       return;
1038     }
1039
1040   if (attr == ALGO_RSA2K || attr == ALGO_RSA4K)
1041     {
1042       if (len > MAX_RSA_DIGEST_INFO_LEN)
1043         {
1044           DEBUG_INFO ("input is too long.");
1045           GPG_CONDITION_NOT_SATISFIED ();
1046           return;
1047         }
1048
1049       result_len = pubkey_len;
1050       r = rsa_sign (apdu.cmd_apdu_data, res_APDU, len,
1051                     &kd[GPG_KEY_FOR_AUTHENTICATION], pubkey_len);
1052     }
1053   else if (attr == ALGO_NISTP256R1)
1054     {
1055       if (len != ECDSA_HASH_LEN)
1056         {
1057           DEBUG_INFO ("wrong hash length.");
1058           GPG_CONDITION_NOT_SATISFIED ();
1059           return;
1060         }
1061
1062       cs = chopstx_setcancelstate (0);
1063       result_len = ECDSA_SIGNATURE_LENGTH;
1064       r = ecdsa_sign_p256r1 (apdu.cmd_apdu_data, res_APDU,
1065                              kd[GPG_KEY_FOR_AUTHENTICATION].data);
1066       chopstx_setcancelstate (cs);
1067     }
1068   else if (attr == ALGO_SECP256K1)
1069     {
1070       if (len != ECDSA_HASH_LEN)
1071         {
1072           DEBUG_INFO ("wrong hash length.");
1073           GPG_CONDITION_NOT_SATISFIED ();
1074           return;
1075         }
1076
1077       cs = chopstx_setcancelstate (0);
1078       result_len = ECDSA_SIGNATURE_LENGTH;
1079       r = ecdsa_sign_p256k1 (apdu.cmd_apdu_data, res_APDU,
1080                              kd[GPG_KEY_FOR_AUTHENTICATION].data);
1081       chopstx_setcancelstate (cs);
1082     }
1083   else if (attr == ALGO_ED25519)
1084     {
1085       uint32_t output[64/4];    /* Require 4-byte alignment. */
1086
1087       if (len > EDDSA_HASH_LEN_MAX)
1088         {
1089           DEBUG_INFO ("wrong hash length.");
1090           GPG_CONDITION_NOT_SATISFIED ();
1091           return;
1092         }
1093
1094       cs = chopstx_setcancelstate (0);
1095       result_len = EDDSA_SIGNATURE_LENGTH;
1096       r = eddsa_sign_25519 (apdu.cmd_apdu_data, len, output,
1097                             kd[GPG_KEY_FOR_AUTHENTICATION].data,
1098                             kd[GPG_KEY_FOR_AUTHENTICATION].data+32,
1099                             kd[GPG_KEY_FOR_AUTHENTICATION].pubkey);
1100       chopstx_setcancelstate (cs);
1101       memcpy (res_APDU, output, EDDSA_SIGNATURE_LENGTH);
1102     }
1103
1104   if (r == 0)
1105     res_APDU_size = result_len;
1106   else
1107     GPG_ERROR ();
1108
1109   DEBUG_INFO ("INTERNAL AUTHENTICATE done.\r\n");
1110 }
1111
1112
1113 #define MBD_OPRATION_WRITE  0
1114 #define MBD_OPRATION_UPDATE 1
1115
1116 static void
1117 modify_binary (uint8_t op, uint8_t p1, uint8_t p2, int len)
1118 {
1119   uint8_t file_id;
1120   uint16_t offset;
1121   int is_short_EF = (p1 & 0x80) != 0;
1122   int r;
1123
1124   if (!ac_check_status (AC_ADMIN_AUTHORIZED))
1125     {
1126       DEBUG_INFO ("security error.");
1127       GPG_SECURITY_FAILURE ();
1128       return;
1129     }
1130
1131   if (is_short_EF)
1132     file_id = (p1 & 0x1f);
1133   else
1134     file_id = file_selection - FILE_EF_SERIAL_NO + FILEID_SERIAL_NO;
1135
1136   if (!FILEID_CH_CERTIFICATE_IS_VALID && file_id == FILEID_CH_CERTIFICATE)
1137     {
1138       GPG_NO_FILE ();
1139       return;
1140     }
1141
1142   if (op == MBD_OPRATION_UPDATE && file_id != FILEID_CH_CERTIFICATE)
1143     {
1144       GPG_CONDITION_NOT_SATISFIED ();
1145       return;
1146     }
1147
1148   if (file_id > FILEID_CH_CERTIFICATE)
1149     {
1150       GPG_NO_FILE ();
1151       return;
1152     }
1153
1154   if (is_short_EF)
1155     {
1156       file_selection = file_id - FILEID_SERIAL_NO + FILE_EF_SERIAL_NO;
1157       offset = p2;
1158
1159       if (op == MBD_OPRATION_UPDATE)
1160         {
1161           r = flash_erase_binary (file_id);
1162           if (r < 0)
1163             {
1164               DEBUG_INFO ("memory error.\r\n");
1165               GPG_MEMORY_FAILURE ();
1166               return;
1167             }
1168         }
1169     }
1170   else
1171     offset = (p1 << 8) | p2;
1172
1173   DEBUG_SHORT (len);
1174   DEBUG_SHORT (offset);
1175
1176   if (file_id == FILEID_CH_CERTIFICATE && (len&1))
1177     /* It's OK the size of last write is odd.  */
1178     apdu.cmd_apdu_data[len++] = 0xff;
1179
1180   r = flash_write_binary (file_id, apdu.cmd_apdu_data, len, offset);
1181   if (r < 0)
1182     {
1183       DEBUG_INFO ("memory error.\r\n");
1184       GPG_MEMORY_FAILURE ();
1185       return;
1186     }
1187
1188   if (file_id >= FILEID_UPDATE_KEY_0 && file_id <= FILEID_UPDATE_KEY_3
1189       && len == 0 && offset == 0)
1190     {
1191       int i;
1192       const uint8_t *p;
1193
1194       for (i = 0; i < 4; i++)
1195         {
1196           p = gpg_get_firmware_update_key (i);
1197           if (p[0] != 0x00 || p[1] != 0x00) /* still valid */
1198             break;
1199         }
1200
1201       if (i == 4)                       /* all update keys are removed */
1202         {
1203           p = gpg_get_firmware_update_key (0);
1204           flash_erase_page ((uint32_t)p);
1205         }
1206     }
1207
1208   GPG_SUCCESS ();
1209 }
1210
1211
1212 #if defined(CERTDO_SUPPORT)
1213 static void
1214 cmd_update_binary (void)
1215 {
1216   int len = apdu.cmd_apdu_data_len;
1217
1218   DEBUG_INFO (" - UPDATE BINARY\r\n");
1219   modify_binary (MBD_OPRATION_UPDATE, P1 (apdu), P2 (apdu), len);
1220   DEBUG_INFO ("UPDATE BINARY done.\r\n");
1221 }
1222 #endif
1223
1224
1225 static void
1226 cmd_write_binary (void)
1227 {
1228   int len = apdu.cmd_apdu_data_len;
1229
1230   DEBUG_INFO (" - WRITE BINARY\r\n");
1231   modify_binary (MBD_OPRATION_WRITE, P1 (apdu), P2 (apdu), len);
1232   DEBUG_INFO ("WRITE BINARY done.\r\n");
1233 }
1234
1235
1236 static void
1237 cmd_external_authenticate (void)
1238 {
1239   const uint8_t *pubkey;
1240   const uint8_t *signature = apdu.cmd_apdu_data;
1241   int len = apdu.cmd_apdu_data_len;
1242   uint8_t keyno = P2 (apdu);
1243   int r;
1244
1245   DEBUG_INFO (" - EXTERNAL AUTHENTICATE\r\n");
1246
1247   if (keyno >= 4)
1248     {
1249       GPG_CONDITION_NOT_SATISFIED ();
1250       return;
1251     }
1252
1253   pubkey = gpg_get_firmware_update_key (keyno);
1254   if (len != 256
1255       || (pubkey[0] == 0xff && pubkey[1] == 0xff) /* not registered */
1256       || (pubkey[0] == 0x00 && pubkey[1] == 0x00) /* removed */)
1257     {
1258       GPG_CONDITION_NOT_SATISFIED ();
1259       return;
1260     }
1261
1262   r = rsa_verify (pubkey, FIRMWARE_UPDATE_KEY_CONTENT_LEN,
1263                   challenge, signature);
1264   random_bytes_free (challenge);
1265   challenge = NULL;
1266
1267   if (r < 0)
1268     {
1269       GPG_SECURITY_FAILURE ();
1270       return;
1271     }
1272
1273   eventflag_signal (openpgp_comm, EV_EXIT); /* signal to self.  */
1274   set_res_sw (0xff, 0xff);
1275   DEBUG_INFO ("EXTERNAL AUTHENTICATE done.\r\n");
1276 }
1277
1278 static void
1279 cmd_get_challenge (void)
1280 {
1281   int len = apdu.expected_res_size;
1282
1283   DEBUG_INFO (" - GET CHALLENGE\r\n");
1284
1285   if (len > CHALLENGE_LEN)
1286     {
1287       GPG_CONDITION_NOT_SATISFIED ();
1288       return;
1289     }
1290   else if (len == 0)
1291     /* Le is not specified.  Return full-sized challenge by GET_RESPONSE.  */
1292     len = CHALLENGE_LEN;
1293
1294   if (challenge)
1295     random_bytes_free (challenge);
1296
1297   challenge = random_bytes_get ();
1298   memcpy (res_APDU, challenge, len);
1299   res_APDU_size = len;
1300   GPG_SUCCESS ();
1301   DEBUG_INFO ("GET CHALLENGE done.\r\n");
1302 }
1303
1304
1305 struct command
1306 {
1307   uint8_t command;
1308   void (*cmd_handler) (void);
1309 };
1310
1311 const struct command cmds[] = {
1312   { INS_VERIFY, cmd_verify },
1313   { INS_CHANGE_REFERENCE_DATA, cmd_change_password },
1314   { INS_PSO, cmd_pso },
1315   { INS_RESET_RETRY_COUNTER, cmd_reset_user_password },
1316   { INS_PGP_GENERATE_ASYMMETRIC_KEY_PAIR, cmd_pgp_gakp },
1317   { INS_EXTERNAL_AUTHENTICATE,              /* Not in OpenPGP card protocol */
1318     cmd_external_authenticate },
1319   { INS_GET_CHALLENGE, cmd_get_challenge }, /* Not in OpenPGP card protocol */
1320   { INS_INTERNAL_AUTHENTICATE, cmd_internal_authenticate },
1321   { INS_SELECT_FILE, cmd_select_file },
1322   { INS_READ_BINARY, cmd_read_binary },
1323   { INS_GET_DATA, cmd_get_data },
1324   { INS_WRITE_BINARY, cmd_write_binary},    /* Not in OpenPGP card protocol */
1325 #if defined(CERTDO_SUPPORT)
1326   { INS_UPDATE_BINARY, cmd_update_binary }, /* Not in OpenPGP card protocol */
1327 #endif
1328   { INS_PUT_DATA, cmd_put_data },
1329   { INS_PUT_DATA_ODD, cmd_put_data },
1330 };
1331 #define NUM_CMDS ((int)(sizeof (cmds) / sizeof (struct command)))
1332
1333 static void
1334 process_command_apdu (void)
1335 {
1336   int i;
1337   uint8_t cmd = INS (apdu);
1338
1339   for (i = 0; i < NUM_CMDS; i++)
1340     if (cmds[i].command == cmd)
1341       break;
1342
1343   if (i < NUM_CMDS)
1344     {
1345       chopstx_setcancelstate (1);
1346       cmds[i].cmd_handler ();
1347       chopstx_setcancelstate (0);
1348     }
1349   else
1350     {
1351       DEBUG_INFO (" - ??");
1352       DEBUG_BYTE (cmd);
1353       GPG_NO_INS ();
1354     }
1355 }
1356
1357 static void * card_thread (chopstx_t thd, struct eventflag *ccid_comm);
1358
1359 void * __attribute__ ((naked))
1360 openpgp_card_thread (void *arg)
1361 {
1362   chopstx_t thd;
1363
1364   asm ("mov     %0, sp" : "=r" (thd));
1365   return card_thread (thd, (struct eventflag *)arg);
1366 }
1367
1368 chopstx_t openpgp_card_thd;
1369
1370 static void * __attribute__ ((noinline))
1371 card_thread (chopstx_t thd, struct eventflag *ccid_comm)
1372 {
1373   openpgp_card_thd = thd;
1374
1375   openpgp_comm = ccid_comm + 1;
1376
1377   gpg_init ();
1378
1379   while (1)
1380     {
1381 #if defined(PINPAD_SUPPORT)
1382       int len, pw_len, newpw_len;
1383 #endif
1384       eventmask_t m = eventflag_wait (openpgp_comm);
1385
1386       DEBUG_INFO ("GPG!: ");
1387
1388       if (m == EV_VERIFY_CMD_AVAILABLE)
1389         {
1390 #if defined(PINPAD_SUPPORT)
1391           if (INS (apdu) != INS_VERIFY)
1392             {
1393               GPG_CONDITION_NOT_SATISFIED ();
1394               goto done;
1395             }
1396
1397           pw_len = get_pinpad_input (PIN_INPUT_CURRENT);
1398           if (pw_len < 0)
1399             {
1400               GPG_ERROR ();
1401               goto done;
1402             }
1403           memcpy (apdu.cmd_apdu_data, pin_input_buffer, pw_len);
1404           apdu.cmd_apdu_data_len = pw_len;
1405 #else
1406           GPG_ERROR ();
1407           goto done;
1408 #endif
1409         }
1410       else if (m == EV_MODIFY_CMD_AVAILABLE)
1411         {
1412 #if defined(PINPAD_SUPPORT)
1413           uint8_t bConfirmPIN = apdu.cmd_apdu_data[0];
1414           uint8_t *p = apdu.cmd_apdu_data;
1415
1416           if (INS (apdu) != INS_CHANGE_REFERENCE_DATA
1417               && INS (apdu) != INS_RESET_RETRY_COUNTER
1418               && INS (apdu) != INS_PUT_DATA)
1419             {
1420               GPG_CONDITION_NOT_SATISFIED ();
1421               goto done;
1422             }
1423
1424           if ((bConfirmPIN & 2))        /* Require old PIN */
1425             {
1426               pw_len = get_pinpad_input (PIN_INPUT_CURRENT);
1427               if (pw_len < 0)
1428                 {
1429                   GPG_ERROR ();
1430                   goto done;
1431                 }
1432               memcpy (p, pin_input_buffer, pw_len);
1433               p += pw_len;
1434             }
1435           else
1436             pw_len = 0;
1437
1438           newpw_len = get_pinpad_input (PIN_INPUT_NEW);
1439           if (newpw_len < 0)
1440             {
1441               GPG_ERROR ();
1442               goto done;
1443             }
1444           memcpy (p, pin_input_buffer, newpw_len);
1445
1446           if ((bConfirmPIN & 1))        /* New PIN twice */
1447             {
1448               len = get_pinpad_input (PIN_INPUT_CONFIRM);
1449               if (len < 0)
1450                 {
1451                   GPG_ERROR ();
1452                   goto done;
1453                 }
1454
1455               if (len != newpw_len || memcmp (p, pin_input_buffer, len) != 0)
1456                 {
1457                   GPG_SECURITY_FAILURE ();
1458                   goto done;
1459                 }
1460             }
1461
1462           apdu.cmd_apdu_data_len = pw_len + newpw_len;
1463 #else
1464           GPG_ERROR ();
1465           goto done;
1466 #endif
1467         }
1468       else if (m == EV_EXIT)
1469         break;
1470
1471       led_blink (LED_START_COMMAND);
1472       process_command_apdu ();
1473       led_blink (LED_FINISH_COMMAND);
1474     done:
1475       eventflag_signal (ccid_comm, EV_EXEC_FINISHED);
1476     }
1477
1478   gpg_fini ();
1479   return NULL;
1480 }