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