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