always enable keygen
[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
821   DEBUG_INFO (" - PSO: ");
822   DEBUG_WORD ((uint32_t)&r);
823   DEBUG_BINARY (apdu.cmd_apdu_data, apdu.cmd_apdu_data_len);
824   DEBUG_SHORT (len);
825
826   if (P1 (apdu) == 0x9e && P2 (apdu) == 0x9a)
827     {
828       attr = gpg_get_algo_attr (GPG_KEY_FOR_SIGNING);
829       pubkey_len = gpg_get_algo_attr_key_size (GPG_KEY_FOR_SIGNING,
830                                                GPG_KEY_PUBLIC);
831
832       if (!ac_check_status (AC_PSO_CDS_AUTHORIZED))
833         {
834           DEBUG_INFO ("security error.");
835           GPG_SECURITY_FAILURE ();
836           return;
837         }
838
839       if (attr == ALGO_RSA2K || attr == ALGO_RSA4K)
840         {
841           /* Check size of digestInfo */
842           if (len != 34         /* MD5 */
843               && len != 35              /* SHA1 / RIPEMD-160 */
844               && len != 47              /* SHA224 */
845               && len != 51              /* SHA256 */
846               && len != 67              /* SHA384 */
847               && len != 83)             /* SHA512 */
848             {
849               DEBUG_INFO (" wrong length");
850               GPG_CONDITION_NOT_SATISFIED ();
851               return;
852             }
853
854           DEBUG_BINARY (kd[GPG_KEY_FOR_SIGNING].data, pubkey_len);
855
856           result_len = pubkey_len;
857           r = rsa_sign (apdu.cmd_apdu_data, res_APDU, len,
858                         &kd[GPG_KEY_FOR_SIGNING], pubkey_len);
859         }
860       else if (attr == ALGO_NISTP256R1 || attr == ALGO_SECP256K1)
861         {
862           /* ECDSA with p256r1/p256k1 for signature */
863           if (len != ECDSA_HASH_LEN)
864             {
865               DEBUG_INFO (" wrong length");
866               GPG_CONDITION_NOT_SATISFIED ();
867               return;
868             }
869
870           result_len = ECDSA_SIGNATURE_LENGTH;
871           if (attr == ALGO_NISTP256R1)
872             r = ecdsa_sign_p256r1 (apdu.cmd_apdu_data, res_APDU,
873                                    kd[GPG_KEY_FOR_SIGNING].data);
874           else                  /* ALGO_SECP256K1 */
875             r = ecdsa_sign_p256k1 (apdu.cmd_apdu_data, res_APDU,
876                                    kd[GPG_KEY_FOR_SIGNING].data);
877         }
878       else if (attr == ALGO_ED25519)
879         {
880           uint32_t output[64/4];        /* Require 4-byte alignment. */
881
882           if (len > EDDSA_HASH_LEN_MAX)
883             {
884               DEBUG_INFO ("wrong hash length.");
885               GPG_CONDITION_NOT_SATISFIED ();
886               return;
887             }
888
889           result_len = EDDSA_SIGNATURE_LENGTH;
890           r = eddsa_sign_25519 (apdu.cmd_apdu_data, len, output,
891                                 kd[GPG_KEY_FOR_SIGNING].data,
892                                 kd[GPG_KEY_FOR_SIGNING].data+32,
893                                 kd[GPG_KEY_FOR_SIGNING].pubkey);
894           memcpy (res_APDU, output, EDDSA_SIGNATURE_LENGTH);
895         }
896       else
897         {
898           DEBUG_INFO ("unknown algo.");
899           GPG_FUNCTION_NOT_SUPPORTED ();
900           return;
901         }
902
903       if (r == 0)
904         {
905           res_APDU_size = result_len;
906           gpg_increment_digital_signature_counter ();
907         }
908       else   /* Failure */
909         ac_reset_pso_cds ();
910     }
911   else if (P1 (apdu) == 0x80 && P2 (apdu) == 0x86)
912     {
913       attr = gpg_get_algo_attr (GPG_KEY_FOR_DECRYPTION);
914       pubkey_len = gpg_get_algo_attr_key_size (GPG_KEY_FOR_DECRYPTION,
915                                                GPG_KEY_PUBLIC);
916
917       DEBUG_BINARY (kd[GPG_KEY_FOR_DECRYPTION].data, pubkey_len);
918
919       if (!ac_check_status (AC_OTHER_AUTHORIZED))
920         {
921           DEBUG_INFO ("security error.");
922           GPG_SECURITY_FAILURE ();
923           return;
924         }
925
926       if (attr == ALGO_RSA2K || attr == ALGO_RSA4K)
927         {
928           /* Skip padding 0x00 */
929           len--;
930           if (len != pubkey_len)
931             {
932               GPG_CONDITION_NOT_SATISFIED ();
933               return;
934             }
935           r = rsa_decrypt (apdu.cmd_apdu_data+1, res_APDU, len,
936                            &kd[GPG_KEY_FOR_DECRYPTION], &result_len);
937         }
938       else if (attr == ALGO_NISTP256R1 || attr == ALGO_SECP256K1)
939         {
940           int header = ECC_CIPHER_DO_HEADER_SIZE;
941
942           /* Format is in big endian MPI: 04 || x || y */
943           if (len != 65 + ECC_CIPHER_DO_HEADER_SIZE
944               || apdu.cmd_apdu_data[header] != 0x04)
945             {
946               GPG_CONDITION_NOT_SATISFIED ();
947               return;
948             }
949
950           result_len = 65;
951           if (attr == ALGO_NISTP256R1)
952             r = ecdh_decrypt_p256r1 (apdu.cmd_apdu_data + header, res_APDU,
953                                      kd[GPG_KEY_FOR_DECRYPTION].data);
954           else
955             r = ecdh_decrypt_p256k1 (apdu.cmd_apdu_data + header, res_APDU,
956                                      kd[GPG_KEY_FOR_DECRYPTION].data);
957         }
958       else if (attr == ALGO_CURVE25519)
959         {
960           int header = ECC_CIPHER_DO_HEADER_SIZE;
961
962           if (len != 32 + ECC_CIPHER_DO_HEADER_SIZE)
963             {
964               GPG_CONDITION_NOT_SATISFIED ();
965               return;
966             }
967
968           result_len = 32;
969           r = ecdh_decrypt_curve25519 (apdu.cmd_apdu_data + header, res_APDU,
970                                        kd[GPG_KEY_FOR_DECRYPTION].data);
971         }
972       else
973         {
974           DEBUG_INFO ("unknown algo.");
975           GPG_FUNCTION_NOT_SUPPORTED ();
976           return;
977         }
978
979       if (r == 0)
980         res_APDU_size = result_len;
981     }
982
983   if (r < 0)
984     {
985       DEBUG_INFO (" - ??");
986       DEBUG_BYTE (P1 (apdu));
987       DEBUG_INFO (" - ??");
988       DEBUG_BYTE (P2 (apdu));
989       GPG_ERROR ();
990     }
991
992   DEBUG_INFO ("PSO done.\r\n");
993 }
994
995
996 #define MAX_RSA_DIGEST_INFO_LEN 102 /* 40% */
997 static void
998 cmd_internal_authenticate (void)
999 {
1000   int attr = gpg_get_algo_attr (GPG_KEY_FOR_AUTHENTICATION);
1001   int pubkey_len = gpg_get_algo_attr_key_size (GPG_KEY_FOR_AUTHENTICATION,
1002                                                GPG_KEY_PUBLIC);
1003   int len = apdu.cmd_apdu_data_len;
1004   int r = -1;
1005   unsigned int result_len = 0;
1006
1007   DEBUG_INFO (" - INTERNAL AUTHENTICATE\r\n");
1008
1009   if (P1 (apdu) != 0x00 || P2 (apdu) != 0x00)
1010     {
1011       DEBUG_INFO (" - ??");
1012       DEBUG_BYTE (P1 (apdu));
1013       DEBUG_INFO (" - ??");
1014       DEBUG_BYTE (P2 (apdu));
1015       GPG_CONDITION_NOT_SATISFIED ();
1016       return;
1017     }
1018
1019   DEBUG_SHORT (len);
1020   if (!ac_check_status (AC_OTHER_AUTHORIZED))
1021     {
1022       DEBUG_INFO ("security error.");
1023       GPG_SECURITY_FAILURE ();
1024       return;
1025     }
1026
1027   if (attr == ALGO_RSA2K || attr == ALGO_RSA4K)
1028     {
1029       if (len > MAX_RSA_DIGEST_INFO_LEN)
1030         {
1031           DEBUG_INFO ("input is too long.");
1032           GPG_CONDITION_NOT_SATISFIED ();
1033           return;
1034         }
1035
1036       result_len = pubkey_len;
1037       r = rsa_sign (apdu.cmd_apdu_data, res_APDU, len,
1038                     &kd[GPG_KEY_FOR_AUTHENTICATION], pubkey_len);
1039     }     
1040   else if (attr == ALGO_NISTP256R1)
1041     {
1042       if (len != ECDSA_HASH_LEN)
1043         {
1044           DEBUG_INFO ("wrong hash length.");
1045           GPG_CONDITION_NOT_SATISFIED ();
1046           return;
1047         }
1048
1049       result_len = ECDSA_SIGNATURE_LENGTH;
1050       r = ecdsa_sign_p256r1 (apdu.cmd_apdu_data, res_APDU,
1051                              kd[GPG_KEY_FOR_AUTHENTICATION].data);
1052     }
1053   else if (attr == ALGO_SECP256K1)
1054     {
1055       if (len != ECDSA_HASH_LEN)
1056         {
1057           DEBUG_INFO ("wrong hash length.");
1058           GPG_CONDITION_NOT_SATISFIED ();
1059           return;
1060         }
1061
1062       result_len = ECDSA_SIGNATURE_LENGTH;
1063       r = ecdsa_sign_p256k1 (apdu.cmd_apdu_data, res_APDU,
1064                              kd[GPG_KEY_FOR_AUTHENTICATION].data);
1065     }
1066   else if (attr == ALGO_ED25519)
1067     {
1068       uint32_t output[64/4];    /* Require 4-byte alignment. */
1069
1070       if (len > EDDSA_HASH_LEN_MAX)
1071         {
1072           DEBUG_INFO ("wrong hash length.");
1073           GPG_CONDITION_NOT_SATISFIED ();
1074           return;
1075         }
1076
1077       result_len = EDDSA_SIGNATURE_LENGTH;
1078       r = eddsa_sign_25519 (apdu.cmd_apdu_data, len, output,
1079                             kd[GPG_KEY_FOR_AUTHENTICATION].data,
1080                             kd[GPG_KEY_FOR_AUTHENTICATION].data+32,
1081                             kd[GPG_KEY_FOR_AUTHENTICATION].pubkey);
1082       memcpy (res_APDU, output, EDDSA_SIGNATURE_LENGTH);
1083     }
1084
1085   if (r == 0)
1086     res_APDU_size = result_len;
1087   else
1088     GPG_ERROR ();
1089
1090   DEBUG_INFO ("INTERNAL AUTHENTICATE done.\r\n");
1091 }
1092
1093
1094 #define MBD_OPRATION_WRITE  0
1095 #define MBD_OPRATION_UPDATE 1
1096
1097 static void
1098 modify_binary (uint8_t op, uint8_t p1, uint8_t p2, int len)
1099 {
1100   uint8_t file_id;
1101   uint16_t offset;
1102   int is_short_EF = (p1 & 0x80) != 0;
1103   int r;
1104
1105   if (!ac_check_status (AC_ADMIN_AUTHORIZED))
1106     {
1107       DEBUG_INFO ("security error.");
1108       GPG_SECURITY_FAILURE ();
1109       return;
1110     }
1111
1112   if (is_short_EF)
1113     file_id = (p1 & 0x1f);
1114   else
1115     file_id = file_selection - FILE_EF_SERIAL_NO + FILEID_SERIAL_NO;
1116
1117   if (!FILEID_CH_CERTIFICATE_IS_VALID && file_id == FILEID_CH_CERTIFICATE)
1118     {
1119       GPG_NO_FILE ();
1120       return;
1121     }
1122
1123   if (op == MBD_OPRATION_UPDATE && file_id != FILEID_CH_CERTIFICATE)
1124     {
1125       GPG_CONDITION_NOT_SATISFIED ();
1126       return;
1127     }
1128
1129   if (file_id > FILEID_CH_CERTIFICATE)
1130     {
1131       GPG_NO_FILE ();
1132       return;
1133     }
1134
1135   if (is_short_EF)
1136     {
1137       file_selection = file_id - FILEID_SERIAL_NO + FILE_EF_SERIAL_NO;
1138       offset = p2;
1139
1140       if (op == MBD_OPRATION_UPDATE)
1141         {
1142           r = flash_erase_binary (file_id);
1143           if (r < 0)
1144             {
1145               DEBUG_INFO ("memory error.\r\n");
1146               GPG_MEMORY_FAILURE ();
1147               return;
1148             }
1149         }
1150     }
1151   else
1152     offset = (p1 << 8) | p2;
1153
1154   DEBUG_SHORT (len);
1155   DEBUG_SHORT (offset);
1156
1157   if (file_id == FILEID_CH_CERTIFICATE && (len&1))
1158     /* It's OK the size of last write is odd.  */
1159     apdu.cmd_apdu_data[len++] = 0xff;
1160
1161   r = flash_write_binary (file_id, apdu.cmd_apdu_data, len, offset);
1162   if (r < 0)
1163     {
1164       DEBUG_INFO ("memory error.\r\n");
1165       GPG_MEMORY_FAILURE ();
1166       return;
1167     }
1168
1169   if (file_id >= FILEID_UPDATE_KEY_0 && file_id <= FILEID_UPDATE_KEY_3
1170       && len == 0 && offset == 0)
1171     {
1172       int i;
1173       const uint8_t *p;
1174
1175       for (i = 0; i < 4; i++)
1176         {
1177           p = gpg_get_firmware_update_key (i);
1178           if (p[0] != 0x00 || p[1] != 0x00) /* still valid */
1179             break;
1180         }
1181
1182       if (i == 4)                       /* all update keys are removed */
1183         {
1184           p = gpg_get_firmware_update_key (0);
1185           flash_erase_page ((uint32_t)p);
1186         }
1187     }
1188
1189   GPG_SUCCESS ();
1190 }
1191
1192
1193 #if defined(CERTDO_SUPPORT)
1194 static void
1195 cmd_update_binary (void)
1196 {
1197   int len = apdu.cmd_apdu_data_len;
1198
1199   DEBUG_INFO (" - UPDATE BINARY\r\n");
1200   modify_binary (MBD_OPRATION_UPDATE, P1 (apdu), P2 (apdu), len);
1201   DEBUG_INFO ("UPDATE BINARY done.\r\n");
1202 }
1203 #endif
1204
1205
1206 static void
1207 cmd_write_binary (void)
1208 {
1209   int len = apdu.cmd_apdu_data_len;
1210
1211   DEBUG_INFO (" - WRITE BINARY\r\n");
1212   modify_binary (MBD_OPRATION_WRITE, P1 (apdu), P2 (apdu), len);
1213   DEBUG_INFO ("WRITE BINARY done.\r\n");
1214 }
1215
1216
1217 static void
1218 cmd_external_authenticate (void)
1219 {
1220   const uint8_t *pubkey;
1221   const uint8_t *signature = apdu.cmd_apdu_data;
1222   int len = apdu.cmd_apdu_data_len;
1223   uint8_t keyno = P2 (apdu);
1224   int r;
1225
1226   DEBUG_INFO (" - EXTERNAL AUTHENTICATE\r\n");
1227
1228   if (keyno >= 4)
1229     {
1230       GPG_CONDITION_NOT_SATISFIED ();
1231       return;
1232     }
1233
1234   pubkey = gpg_get_firmware_update_key (keyno);
1235   if (len != 256
1236       || (pubkey[0] == 0xff && pubkey[1] == 0xff) /* not registered */
1237       || (pubkey[0] == 0x00 && pubkey[1] == 0x00) /* removed */)
1238     {
1239       GPG_CONDITION_NOT_SATISFIED ();
1240       return;
1241     }
1242
1243   r = rsa_verify (pubkey, FIRMWARE_UPDATE_KEY_CONTENT_LEN,
1244                   challenge, signature);
1245   random_bytes_free (challenge);
1246   challenge = NULL;
1247
1248   if (r < 0)
1249     {
1250       GPG_SECURITY_FAILURE ();
1251       return;
1252     }
1253
1254   eventflag_signal (openpgp_comm, EV_EXIT); /* signal to self.  */
1255   set_res_sw (0xff, 0xff);
1256   DEBUG_INFO ("EXTERNAL AUTHENTICATE done.\r\n");
1257 }
1258
1259 static void
1260 cmd_get_challenge (void)
1261 {
1262   int len = apdu.expected_res_size;
1263
1264   DEBUG_INFO (" - GET CHALLENGE\r\n");
1265
1266   if (len > CHALLENGE_LEN)
1267     {
1268       GPG_CONDITION_NOT_SATISFIED ();
1269       return;
1270     }
1271   else if (len == 0)
1272     /* Le is not specified.  Return full-sized challenge by GET_RESPONSE.  */
1273     len = CHALLENGE_LEN;
1274
1275   if (challenge)
1276     random_bytes_free (challenge);
1277
1278   challenge = random_bytes_get ();
1279   memcpy (res_APDU, challenge, len);
1280   res_APDU_size = len;
1281   GPG_SUCCESS ();
1282   DEBUG_INFO ("GET CHALLENGE done.\r\n");
1283 }
1284
1285
1286 struct command
1287 {
1288   uint8_t command;
1289   void (*cmd_handler) (void);
1290 };
1291
1292 const struct command cmds[] = {
1293   { INS_VERIFY, cmd_verify },
1294   { INS_CHANGE_REFERENCE_DATA, cmd_change_password },
1295   { INS_PSO, cmd_pso },
1296   { INS_RESET_RETRY_COUNTER, cmd_reset_user_password },
1297   { INS_PGP_GENERATE_ASYMMETRIC_KEY_PAIR, cmd_pgp_gakp },
1298   { INS_EXTERNAL_AUTHENTICATE,              /* Not in OpenPGP card protocol */
1299     cmd_external_authenticate },
1300   { INS_GET_CHALLENGE, cmd_get_challenge }, /* Not in OpenPGP card protocol */
1301   { INS_INTERNAL_AUTHENTICATE, cmd_internal_authenticate },
1302   { INS_SELECT_FILE, cmd_select_file },
1303   { INS_READ_BINARY, cmd_read_binary },
1304   { INS_GET_DATA, cmd_get_data },
1305   { INS_WRITE_BINARY, cmd_write_binary},    /* Not in OpenPGP card protocol */
1306 #if defined(CERTDO_SUPPORT)
1307   { INS_UPDATE_BINARY, cmd_update_binary }, /* Not in OpenPGP card protocol */
1308 #endif
1309   { INS_PUT_DATA, cmd_put_data },
1310   { INS_PUT_DATA_ODD, cmd_put_data },
1311 };
1312 #define NUM_CMDS ((int)(sizeof (cmds) / sizeof (struct command)))
1313
1314 static void
1315 process_command_apdu (void)
1316 {
1317   int i;
1318   uint8_t cmd = INS (apdu);
1319
1320   for (i = 0; i < NUM_CMDS; i++)
1321     if (cmds[i].command == cmd)
1322       break;
1323
1324   if (i < NUM_CMDS)
1325     cmds[i].cmd_handler ();
1326   else
1327     {
1328       DEBUG_INFO (" - ??");
1329       DEBUG_BYTE (cmd);
1330       GPG_NO_INS ();
1331     }
1332 }
1333
1334 static void * card_thread (chopstx_t thd, struct eventflag *ccid_comm);
1335
1336 void * __attribute__ ((naked))
1337 openpgp_card_thread (void *arg)
1338 {
1339   chopstx_t thd;
1340
1341   asm ("mov     %0, sp" : "=r" (thd));
1342   return card_thread (thd, (struct eventflag *)arg);
1343 }
1344
1345 chopstx_t openpgp_card_thd;
1346
1347 static void * __attribute__ ((noinline))
1348 card_thread (chopstx_t thd, struct eventflag *ccid_comm)
1349 {
1350   openpgp_card_thd = thd;
1351
1352   openpgp_comm = ccid_comm + 1;
1353
1354   gpg_init ();
1355
1356   while (1)
1357     {
1358       eventmask_t m = eventflag_wait (openpgp_comm);
1359 #if defined(PINPAD_SUPPORT)
1360       int len, pw_len, newpw_len;
1361 #endif
1362
1363       DEBUG_INFO ("GPG!: ");
1364
1365       if (m == EV_VERIFY_CMD_AVAILABLE)
1366         {
1367 #if defined(PINPAD_SUPPORT)
1368           if (INS (apdu) != INS_VERIFY)
1369             {
1370               GPG_CONDITION_NOT_SATISFIED ();
1371               goto done;
1372             }
1373
1374           pw_len = get_pinpad_input (PIN_INPUT_CURRENT);
1375           if (pw_len < 0)
1376             {
1377               GPG_ERROR ();
1378               goto done;
1379             }
1380           memcpy (apdu.cmd_apdu_data, pin_input_buffer, pw_len);
1381           apdu.cmd_apdu_data_len = pw_len;
1382 #else
1383           GPG_ERROR ();
1384           goto done;
1385 #endif
1386         }
1387       else if (m == EV_MODIFY_CMD_AVAILABLE)
1388         {
1389 #if defined(PINPAD_SUPPORT)
1390           uint8_t bConfirmPIN = apdu.cmd_apdu_data[5];
1391           uint8_t *p = apdu.cmd_apdu_data;
1392
1393           if (INS (apdu) != INS_CHANGE_REFERENCE_DATA
1394               && INS (apdu) != INS_RESET_RETRY_COUNTER
1395               && INS (apdu) != INS_PUT_DATA)
1396             {
1397               GPG_CONDITION_NOT_SATISFIED ();
1398               goto done;
1399             }
1400
1401           if ((bConfirmPIN & 2))        /* Require old PIN */
1402             {
1403               pw_len = get_pinpad_input (PIN_INPUT_CURRENT);
1404               if (pw_len < 0)
1405                 {
1406                   GPG_ERROR ();
1407                   goto done;
1408                 }
1409               memcpy (p, pin_input_buffer, pw_len);
1410               p += pw_len;
1411             }
1412           else
1413             pw_len = 0;
1414
1415           newpw_len = get_pinpad_input (PIN_INPUT_NEW);
1416           if (newpw_len < 0)
1417             {
1418               GPG_ERROR ();
1419               goto done;
1420             }
1421           memcpy (p, pin_input_buffer, newpw_len);
1422
1423           if ((bConfirmPIN & 1))        /* New PIN twice */
1424             {
1425               len = get_pinpad_input (PIN_INPUT_CONFIRM);
1426               if (len < 0)
1427                 {
1428                   GPG_ERROR ();
1429                   goto done;
1430                 }
1431
1432               if (len != newpw_len || memcmp (p, pin_input_buffer, len) != 0)
1433                 {
1434                   GPG_SECURITY_FAILURE ();
1435                   goto done;
1436                 }
1437             }
1438
1439           apdu.cmd_apdu_data_len = pw_len + newpw_len;
1440 #else
1441           GPG_ERROR ();
1442           goto done;
1443 #endif
1444         }
1445       else if (m == EV_EXIT)
1446         break;
1447
1448       led_blink (LED_START_COMMAND);
1449       process_command_apdu ();
1450       led_blink (LED_FINISH_COMMAND);
1451     done:
1452       eventflag_signal (ccid_comm, EV_EXEC_FINISHED);
1453     }
1454
1455   gpg_fini ();
1456   return NULL;
1457 }