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