* command.c (cmd_getattr): New command GETATTR.
[gnupg.git] / scd / app-openpgp.c
1 /* app-openpgp.c - The OpenPGP card application.
2  *      Copyright (C) 2003 Free Software Foundation, Inc.
3  *
4  * This file is part of GnuPG.
5  *
6  * GnuPG is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License as published by
8  * the Free Software Foundation; either version 2 of the License, or
9  * (at your option) any later version.
10  *
11  * GnuPG is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, write to the Free Software
18  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
19  */
20
21 #include <config.h>
22 #include <errno.h>
23 #include <stdio.h>
24 #include <stdlib.h>
25 #include <string.h>
26 #include <assert.h>
27
28 #include "scdaemon.h"
29 #include "app-common.h"
30 #include "iso7816.h"
31
32
33
34 static struct {
35   int tag;
36   int constructed;
37   int get_from;  /* Constructed DO with this DO or 0 for direct access. */
38   int binary;
39   char *desc;
40 } data_objects[] = {
41   { 0x005E, 0,    0, 1, "Login Data" },
42   { 0x5F50, 0,    0, 0, "URL" },
43   { 0x0065, 1,    0, 1, "Cardholder Related Data"},
44   { 0x005B, 0, 0x65, 0, "Name" },
45   { 0x5F2D, 0, 0x65, 0, "Language preferences" },
46   { 0x5F35, 0, 0x65, 0, "Sex" },
47   { 0x006E, 1,    0, 1, "Application Related Data" },
48   { 0x004F, 0, 0x6E, 1, "AID" },
49   { 0x0073, 1,    0, 1, "Discretionary Data Objects" },
50   { 0x0047, 0, 0x6E, 1, "Card Capabilities" },
51   { 0x00C0, 0, 0x6E, 1, "Extended Card Capabilities" },
52   { 0x00C1, 0, 0x6E, 1, "Algorithm Attributes Signature" },
53   { 0x00C2, 0, 0x6E, 1, "Algorithm Attributes Decryption" },
54   { 0x00C3, 0, 0x6E, 1, "Algorithm Attributes Authentication" },
55   { 0x00C4, 0, 0x6E, 1, "CHV Status Bytes" },
56   { 0x00C5, 0, 0x6E, 1, "Fingerprints" },
57   { 0x00C6, 0, 0x6E, 1, "CA Fingerprints" },
58   { 0x007A, 1,    0, 1, "Security Support Template" },
59   { 0x0093, 0, 0x7A, 1, "Digital Signature Counter" },
60   { 0 }
61 };
62
63
64 static unsigned long convert_sig_counter_value (const unsigned char *value,
65                                                 size_t valuelen);
66 static unsigned long get_sig_counter (APP app);
67
68
69 /* Locate a TLV encoded data object in BUFFER of LENGTH and
70    return a pointer to value as well as its length in NBYTES.  Return
71    NULL if it was not found.  Note, that the function does not check
72    whether the value fits into the provided buffer. 
73
74    FIXME: Move this to an extra file, it is mostly duplicated from card.c.
75 */
76 static const unsigned char *
77 find_tlv (const unsigned char *buffer, size_t length,
78           int tag, size_t *nbytes, int nestlevel)
79 {
80   const unsigned char *s = buffer;
81   size_t n = length;
82   size_t len;
83   int this_tag;
84   int composite;
85     
86   for (;;)
87     {
88       buffer = s;
89       if (n < 2)
90         return NULL; /* buffer definitely too short for tag and length. */
91       if (!*s || *s == 0xff)
92         { /* Skip optional filler between TLV objects. */
93           s++;
94           n--;
95           continue;
96         }
97       composite = !!(*s & 0x20);
98       if ((*s & 0x1f) == 0x1f)
99         { /* more tag bytes to follow */
100           s++;
101           n--;
102           if (n < 2)
103             return NULL; /* buffer definitely too short for tag and length. */
104           if ((*s & 0x1f) == 0x1f)
105             return NULL; /* We support only up to 2 bytes. */
106           this_tag = (s[-1] << 8) | (s[0] & 0x7f);
107         }
108       else
109         this_tag = s[0];
110       len = s[1];
111       s += 2; n -= 2;
112       if (len < 0x80)
113         ;
114       else if (len == 0x81)
115         { /* One byte length follows. */
116           if (!n)
117             return NULL; /* we expected 1 more bytes with the length. */
118           len = s[0];
119           s++; n--;
120         }
121       else if (len == 0x82)
122         { /* Two byte length follows. */
123           if (n < 2)
124             return NULL; /* we expected 2 more bytes with the length. */
125           len = (s[0] << 8) | s[1];
126           s += 2; n -= 2;
127         }
128       else
129         return NULL; /* APDU limit is 65535, thus it does not make
130                         sense to assume longer length fields. */
131
132       if (composite && nestlevel < 100)
133         { /* Dive into this composite DO after checking for too deep
134              nesting. */
135           const unsigned char *tmp_s;
136           size_t tmp_len;
137           
138           tmp_s = find_tlv (s, len, tag, &tmp_len, nestlevel+1);
139           if (tmp_s)
140             {
141               *nbytes = tmp_len;
142               return tmp_s;
143             }
144         }
145
146       if (this_tag == tag)
147         {
148           *nbytes = len;
149           return s;
150         }
151       if (len > n)
152         return NULL; /* buffer too short to skip to the next tag. */
153       s += len; n -= len;
154     }
155 }
156
157
158 /* Get the DO identified by TAG from the card in SLOT and return a
159    buffer with its content in RESULT and NBYTES.  The return value is
160    NULL if not found or a pointer which must be used to release the
161    buffer holding value. */
162 static void *
163 get_one_do (int slot, int tag, unsigned char **result, size_t *nbytes)
164 {
165   int rc, i;
166   unsigned char *buffer;
167   size_t buflen;
168   unsigned char *value;
169   size_t valuelen;
170
171   *result = NULL;
172   *nbytes = 0;
173   for (i=0; data_objects[i].tag && data_objects[i].tag != tag; i++)
174     ;
175
176   value = NULL;
177   rc = -1;
178   if (data_objects[i].tag && data_objects[i].get_from)
179     {
180       rc = iso7816_get_data (slot, data_objects[i].get_from,
181                              &buffer, &buflen);
182       if (!rc)
183         {
184           const unsigned char *s;
185
186           s = find_tlv (buffer, buflen, tag, &valuelen, 0);
187           if (!s)
188             value = NULL; /* not found */
189           else if (valuelen > buflen - (s - buffer))
190             {
191               log_error ("warning: constructed DO too short\n");
192               value = NULL;
193               xfree (buffer); buffer = NULL;
194             }
195           else
196             value = buffer + (s - buffer);
197         }
198     }
199
200   if (!value) /* Not in a constructed DO, try simple. */
201     {
202       rc = iso7816_get_data (slot, tag, &buffer, &buflen);
203       if (!rc)
204         {
205           value = buffer;
206           valuelen = buflen;
207         }
208     }
209
210   if (!rc)
211     {
212       *nbytes = valuelen;
213       *result = value;
214       return buffer;
215     }
216   return NULL;
217 }
218
219
220 static void
221 dump_all_do (int slot)
222 {
223   int rc, i, j;
224   unsigned char *buffer;
225   size_t buflen;
226   
227   for (i=0; data_objects[i].tag; i++)
228     {
229       if (data_objects[i].get_from)
230         continue;
231
232       rc = iso7816_get_data (slot, data_objects[i].tag, &buffer, &buflen);
233       if (gpg_err_code (rc) == GPG_ERR_NO_OBJ)
234         ;
235       else if (rc) 
236         log_info ("DO `%s' not available: %s\n",
237                   data_objects[i].desc, gpg_strerror (rc));
238       else
239         {
240           if (data_objects[i].binary)
241             {
242               log_info ("DO `%s': ", data_objects[i].desc);
243               log_printhex ("", buffer, buflen);
244             }
245           else
246             log_info ("DO `%s': `%.*s'\n",
247                       data_objects[i].desc,
248                       (int)buflen, buffer); /* FIXME: sanitize */
249
250           if (data_objects[i].constructed)
251             {
252               for (j=0; data_objects[j].tag; j++)
253                 {
254                   const unsigned char *value;
255                   size_t valuelen;
256                   
257                   if (j==i || data_objects[i].tag != data_objects[j].get_from)
258                     continue;
259                   value = find_tlv (buffer, buflen,
260                                     data_objects[j].tag, &valuelen, 0);
261                   if (!value)
262                     ; /* not found */
263                   else if (valuelen > buflen - (value - buffer))
264                     log_error ("warning: constructed DO too short\n");
265                   else
266                     {
267                       if (data_objects[j].binary)
268                         {
269                           log_info ("DO `%s': ", data_objects[j].desc);
270                           log_printhex ("", value, valuelen);
271                         }
272                       else
273                         log_info ("DO `%s': `%.*s'\n",
274                                   data_objects[j].desc,
275                                   (int)valuelen, value); /* FIXME: sanitize */
276                     }
277                 }
278             }
279         }
280       xfree (buffer); buffer = NULL;
281     }
282 }
283
284
285 /* Count the number of bits, assuming the A represents an unsigned big
286    integer of length LEN bytes. */
287 static unsigned int
288 count_bits (const unsigned char *a, size_t len)
289 {
290   unsigned int n = len * 8;
291   int i;
292
293   for (; len && !*a; len--, a++, n -=8)
294     ;
295   if (len)
296     {
297       for (i=7; i && !(*a & (1<<i)); i--)
298         n--;
299     }
300   return n;
301 }
302
303 /* Note, that FPR must be at least 20 bytes. */
304 static int 
305 store_fpr (int slot, int keynumber, u32 timestamp,
306            const unsigned char *m, size_t mlen,
307            const unsigned char *e, size_t elen, 
308            unsigned char *fpr, unsigned int card_version)
309 {
310   unsigned int n, nbits;
311   unsigned char *buffer, *p;
312   int rc;
313   
314   for (; mlen && !*m; mlen--, m++) /* strip leading zeroes */
315     ;
316   for (; elen && !*e; elen--, e++) /* strip leading zeroes */
317     ;
318
319   n = 6 + 2 + mlen + 2 + elen;
320   p = buffer = xtrymalloc (3 + n);
321   if (!buffer)
322     return out_of_core ();
323   
324   *p++ = 0x99;     /* ctb */
325   *p++ = n >> 8;   /* 2 byte length header */
326   *p++ = n;
327   *p++ = 4;        /* key packet version */
328   *p++ = timestamp >> 24;
329   *p++ = timestamp >> 16;
330   *p++ = timestamp >>  8;
331   *p++ = timestamp;
332   *p++ = 1; /* RSA */
333   nbits = count_bits (m, mlen);
334   *p++ = nbits >> 8;
335   *p++ = nbits;
336   memcpy (p, m, mlen); p += mlen;
337   nbits = count_bits (e, elen);
338   *p++ = nbits >> 8;
339   *p++ = nbits;
340   memcpy (p, e, elen); p += elen;
341     
342   log_printhex ("fprbuf:", buffer, n+3);
343   gcry_md_hash_buffer (GCRY_MD_SHA1, fpr, buffer, n+3);
344
345   xfree (buffer);
346
347   rc = iso7816_put_data (slot, (card_version > 0x0007? 0xC7 : 0xC6)
348                                + keynumber, fpr, 20);
349   if (rc)
350     log_error ("failed to store the fingerprint: %s\n",gpg_strerror (rc));
351
352   return rc;
353 }
354
355        
356 static void
357 send_fpr_if_not_null (CTRL ctrl, const char *keyword,
358                       int number, const unsigned char *fpr)
359 {                      
360   int i;
361   char buf[41];
362   char numbuf[25];
363
364   for (i=0; i < 20 && !fpr[i]; i++)
365     ;
366   if (i==20)
367     return; /* All zero. */
368   for (i=0; i< 20; i++)
369     sprintf (buf+2*i, "%02X", fpr[i]);
370   if (number == -1)
371     *numbuf = 0; /* Don't print the key number */
372   else
373     sprintf (numbuf, "%d", number);
374   send_status_info (ctrl, keyword,
375                     numbuf, (size_t)strlen(numbuf),
376                     buf, (size_t)strlen (buf), NULL, 0);
377 }
378
379 static void
380 send_key_data (CTRL ctrl, const char *name, 
381                const unsigned char *a, size_t alen)
382 {
383   char *p, *buf = xmalloc (alen*2+1);
384   
385   for (p=buf; alen; a++, alen--, p += 2)
386     sprintf (p, "%02X", *a);
387
388   send_status_info (ctrl, "KEY-DATA",
389                     name, (size_t)strlen(name), 
390                     buf, (size_t)strlen (buf),
391                     NULL, 0);
392   xfree (buf);
393 }
394
395 /* Implement the GETATTR command.  This is similar to the LEARN
396    command but returns just one value via the status interface. */
397 static int 
398 do_getattr (APP app, CTRL ctrl, const char *name)
399 {
400   static struct {
401     const char *name;
402     int tag;
403     int special;
404   } table[] = {
405     { "DISP-NAME",    0x005B },
406     { "LOGIN-DATA",   0x005E },
407     { "DISP-LANG",    0x5F2D },
408     { "DISP-SEX",     0x5F35 },
409     { "PUBKEY-URL",   0x5F50 },
410     { "KEY-FPR",      0x00C5, 3 },
411     { "CA-FPR",       0x00C6, 3 },
412     { "CHV-STATUS",   0x00C4, 1 },
413     { "SIG-COUNTER",  0x0093, 2 },
414     { NULL, 0 }
415   };
416   int idx, i;
417   void *relptr;
418   unsigned char *value;
419   size_t valuelen;
420
421   for (idx=0; table[idx].name && strcmp (table[idx].name, name); idx++)
422     ;
423   if (!table[idx].name)
424     return gpg_error (GPG_ERR_INV_NAME); 
425   
426   relptr = get_one_do (app->slot, table[idx].tag, &value, &valuelen);
427   if (relptr)
428     {
429       if (table[idx].special == 1)
430         {
431           char numbuf[7*23];
432           
433           for (i=0,*numbuf=0; i < valuelen && i < 7; i++)
434             sprintf (numbuf+strlen (numbuf), " %d", value[i]); 
435           send_status_info (ctrl, table[idx].name,
436                             numbuf, strlen (numbuf), NULL, 0);
437         }
438       else if (table[idx].special == 2)
439         {
440           char numbuf[50];
441
442           sprintf (numbuf, "%lu", convert_sig_counter_value (value, valuelen));
443           send_status_info (ctrl, table[idx].name,
444                             numbuf, strlen (numbuf), NULL, 0);
445         }
446       else if (table[idx].special == 3)
447         {
448           if (valuelen >= 60)
449             for (i=0; i < 3; i++)
450               send_fpr_if_not_null (ctrl, "KEY-FPR", i+1, value+i*20);
451         }
452       else
453         send_status_info (ctrl, table[idx].name, value, valuelen, NULL, 0);
454
455       xfree (relptr);
456     }
457   return 0;
458 }
459
460
461 static int
462 do_learn_status (APP app, CTRL ctrl)
463 {
464   do_getattr (app, ctrl, "DISP-NAME");
465   do_getattr (app, ctrl, "DISP-LANG");
466   do_getattr (app, ctrl, "DISP-SEX");
467   do_getattr (app, ctrl, "PUBKEY-URL");
468   do_getattr (app, ctrl, "LOGIN-DATA");
469   do_getattr (app, ctrl, "KEY-FPR");
470   do_getattr (app, ctrl, "CA-FPR");
471   do_getattr (app, ctrl, "CHV-STATUS");
472   do_getattr (app, ctrl, "SIG-COUNTER");
473
474   return 0;
475 }
476
477
478 /* Verify CHV2 if required.  Depending on the configuration of the
479    card CHV1 will also be verified. */
480 static int
481 verify_chv2 (APP app,
482              int (*pincb)(void*, const char *, char **),
483              void *pincb_arg)
484 {
485   int rc = 0;
486
487   if (!app->did_chv2) 
488     {
489       char *pinvalue;
490
491       rc = pincb (pincb_arg, "PIN", &pinvalue); 
492       if (rc)
493         {
494           log_info ("PIN callback returned error: %s\n", gpg_strerror (rc));
495           return rc;
496         }
497
498       rc = iso7816_verify (app->slot, 0x82, pinvalue, strlen (pinvalue));
499       if (rc)
500         {
501           log_error ("verify CHV2 failed: %s\n", gpg_strerror (rc));
502           xfree (pinvalue);
503           return rc;
504         }
505       app->did_chv2 = 1;
506
507       if (!app->did_chv1 && !app->force_chv1)
508         {
509           rc = iso7816_verify (app->slot, 0x81, pinvalue, strlen (pinvalue));
510           if (gpg_err_code (rc) == GPG_ERR_BAD_PIN)
511             rc = gpg_error (GPG_ERR_PIN_NOT_SYNCED);
512           if (rc)
513             {
514               log_error ("verify CHV1 failed: %s\n", gpg_strerror (rc));
515               xfree (pinvalue);
516               return rc;
517             }
518           app->did_chv1 = 1;
519         }
520       xfree (pinvalue);
521     }
522   return rc;
523 }
524
525 /* Verify CHV3 if required. */
526 static int
527 verify_chv3 (APP app,
528              int (*pincb)(void*, const char *, char **),
529              void *pincb_arg)
530 {
531   int rc = 0;
532
533   if (!app->did_chv3) 
534     {
535       char *pinvalue;
536
537       rc = pincb (pincb_arg, "Admin PIN", &pinvalue); 
538       if (rc)
539         {
540           log_info ("PIN callback returned error: %s\n", gpg_strerror (rc));
541           return rc;
542         }
543
544       rc = iso7816_verify (app->slot, 0x83, pinvalue, strlen (pinvalue));
545       xfree (pinvalue);
546       if (rc)
547         {
548           log_error ("verify CHV3 failed: %s\n", gpg_strerror (rc));
549           return rc;
550         }
551       app->did_chv3 = 1;
552     }
553   return rc;
554 }
555
556
557 /* Handle the SETATTR operation. All arguments are already basically
558    checked. */
559 static int 
560 do_setattr (APP app, const char *name,
561             int (*pincb)(void*, const char *, char **),
562             void *pincb_arg,
563             const unsigned char *value, size_t valuelen)
564 {
565   gpg_error_t rc;
566   int idx;
567   static struct {
568     const char *name;
569     int tag;
570   } table[] = {
571     { "DISP-NAME",    0x005B },
572     { "LOGIN-DATA",   0x005E },
573     { "DISP-LANG",    0x5F2D },
574     { "DISP-SEX",     0x5F35 },
575     { "PUBKEY-URL",   0x5F50 },
576     { "CHV-STATUS-1", 0x00C4 },
577     { "CA-FPR-1",     0x00CA },
578     { "CA-FPR-2",     0x00CB },
579     { "CA-FPR-3",     0x00CC },
580     { NULL, 0 }
581   };
582
583
584   for (idx=0; table[idx].name && strcmp (table[idx].name, name); idx++)
585     ;
586   if (!table[idx].name)
587     return gpg_error (GPG_ERR_INV_NAME); 
588
589   rc = verify_chv3 (app, pincb, pincb_arg);
590   if (rc)
591     return rc;
592
593   rc = iso7816_put_data (app->slot, table[idx].tag, value, valuelen);
594   if (rc)
595     log_error ("failed to set `%s': %s\n", table[idx].name, gpg_strerror (rc));
596
597   return rc;
598 }
599
600
601 /* Handle the PASSWD command. */
602 static int 
603 do_change_pin (APP app, CTRL ctrl,  const char *chvnostr, int reset_mode,
604                int (*pincb)(void*, const char *, char **),
605                void *pincb_arg)
606 {
607   int rc = 0;
608   int chvno = atoi (chvnostr);
609   char *pinvalue;
610
611   if (reset_mode && chvno == 3)
612     {
613       rc = gpg_error (GPG_ERR_INV_ID);
614       goto leave;
615     }
616   else if (reset_mode || chvno == 3)
617     {
618       /* we always require that the PIN is entered. */
619       app->did_chv3 = 0;
620       rc = verify_chv3 (app, pincb, pincb_arg);
621       if (rc)
622         goto leave;
623     }
624   else if (chvno == 1 || chvno == 2)
625     {
626       /* CHV1 and CVH2 should always have the same value, thus we
627          enforce it here.  */
628       int save_force = app->force_chv1;
629
630       app->force_chv1 = 0;
631       app->did_chv1 = 0;
632       app->did_chv2 = 0;
633       rc = verify_chv2 (app, pincb, pincb_arg);
634       app->force_chv1 = save_force;
635       if (rc)
636         goto leave;
637     }
638   else
639     {
640       rc = gpg_error (GPG_ERR_INV_ID);
641       goto leave;
642     }
643
644   if (chvno == 3)
645     app->did_chv3 = 0;
646   else
647     app->did_chv1 = app->did_chv2 = 0;
648
649   rc = pincb (pincb_arg, chvno == 3? "New Admin PIN" : "New PIN", &pinvalue); 
650   if (rc)
651     {
652       log_error ("error getting new PIN: %s\n", gpg_strerror (rc));
653       goto leave;
654     }
655
656   if (reset_mode)
657     {
658       rc = iso7816_reset_retry_counter (app->slot, 0x81,
659                                         pinvalue, strlen (pinvalue));
660       if (!rc)
661         rc = iso7816_reset_retry_counter (app->slot, 0x82,
662                                           pinvalue, strlen (pinvalue));
663     }
664   else
665     {
666       if (chvno == 1 || chvno == 2)
667         {
668           rc = iso7816_change_reference_data (app->slot, 0x81, NULL, 0,
669                                               pinvalue, strlen (pinvalue));
670           if (!rc)
671             rc = iso7816_change_reference_data (app->slot, 0x82, NULL, 0,
672                                                 pinvalue, strlen (pinvalue));
673         }
674       else
675         rc = iso7816_change_reference_data (app->slot, 0x80 + chvno, NULL, 0,
676                                             pinvalue, strlen (pinvalue));
677     }
678   xfree (pinvalue);
679
680
681  leave:
682   return rc;
683 }
684
685
686
687 /* Handle the GENKEY command. */
688 static int 
689 do_genkey (APP app, CTRL ctrl,  const char *keynostr, unsigned int flags,
690           int (*pincb)(void*, const char *, char **),
691           void *pincb_arg)
692 {
693   int rc;
694   int i;
695   char numbuf[30];
696   unsigned char fprbuf[20];
697   const unsigned char *fpr;
698   const unsigned char *keydata, *m, *e;
699   unsigned char *buffer;
700   size_t buflen, keydatalen, n, mlen, elen;
701   time_t created_at;
702   int keyno = atoi (keynostr);
703   int force = (flags & 1);
704   time_t start_at;
705
706   if (keyno < 1 || keyno > 3)
707     return gpg_error (GPG_ERR_INV_ID);
708   keyno--;
709
710   rc = iso7816_get_data (app->slot, 0x006E, &buffer, &buflen);
711   if (rc)
712     {
713       log_error ("error reading application data\n");
714       return gpg_error (GPG_ERR_GENERAL);
715     }
716   fpr = find_tlv (buffer, buflen, 0x00C5, &n, 0);
717   if (!fpr || n != 60)
718     {
719       rc = gpg_error (GPG_ERR_GENERAL);
720       log_error ("error reading fingerprint DO\n");
721       goto leave;
722     }
723   fpr += 20*keyno;
724   for (i=0; i < 20 && !fpr[i]; i++)
725     ;
726   if (i!=20 && !force)
727     {
728       rc = gpg_error (GPG_ERR_EEXIST);
729       log_error ("key already exists\n");
730       goto leave;
731     }
732   else if (i!=20)
733     log_info ("existing key will be replaced\n");
734   else
735     log_info ("generating new key\n");
736
737
738   rc = verify_chv3 (app, pincb, pincb_arg);
739   if (rc)
740     goto leave;
741
742   xfree (buffer); buffer = NULL;
743 #if 1
744   log_info ("please wait while key is being generated ...\n");
745   start_at = time (NULL);
746   rc = iso7816_generate_keypair 
747 #else
748 #warning key generation temporary replaced by reading an existing key.
749   rc = iso7816_read_public_key
750 #endif
751                               (app->slot, 
752                                  keyno == 0? "\xB6" :
753                                  keyno == 1? "\xB8" : "\xA4",
754                                  2,
755                                  &buffer, &buflen);
756   if (rc)
757     {
758       rc = gpg_error (GPG_ERR_CARD);
759       log_error ("generating key failed\n");
760       goto leave;
761     }
762   log_info ("key generation completed (%d seconds)\n",
763             (int)(time (NULL) - start_at));
764   keydata = find_tlv (buffer, buflen, 0x7F49, &keydatalen, 0);
765   if (!keydata)
766     {
767       rc = gpg_error (GPG_ERR_CARD);
768       log_error ("response does not contain the public key data\n");
769       goto leave;
770     }
771  
772   m = find_tlv (keydata, keydatalen, 0x0081, &mlen, 0);
773   if (!m)
774     {
775       rc = gpg_error (GPG_ERR_CARD);
776       log_error ("response does not contain the RSA modulus\n");
777       goto leave;
778     }
779 /*    log_printhex ("RSA n:", m, mlen); */
780   send_key_data (ctrl, "n", m, mlen);
781
782   e = find_tlv (keydata, keydatalen, 0x0082, &elen, 0);
783   if (!e)
784     {
785       rc = gpg_error (GPG_ERR_CARD);
786       log_error ("response does not contain the RSA public exponent\n");
787       goto leave;
788     }
789 /*    log_printhex ("RSA e:", e, elen); */
790   send_key_data (ctrl, "e", e, elen);
791
792   created_at = gnupg_get_time ();
793   sprintf (numbuf, "%lu", (unsigned long)created_at);
794   send_status_info (ctrl, "KEY-CREATED-AT",
795                     numbuf, (size_t)strlen(numbuf), NULL, 0);
796
797   rc = store_fpr (app->slot, keyno, (u32)created_at,
798                   m, mlen, e, elen, fprbuf, app->card_version);
799   if (rc)
800     goto leave;
801   send_fpr_if_not_null (ctrl, "KEY-FPR", -1, fprbuf);
802
803
804  leave:
805   xfree (buffer);
806   return rc;
807 }
808
809
810 static unsigned long
811 convert_sig_counter_value (const unsigned char *value, size_t valuelen)
812 {
813   unsigned long ul;
814
815   if (valuelen == 3 )
816     ul = (value[0] << 16) | (value[1] << 8) | value[2];
817   else
818     {
819       log_error ("invalid structure of OpenPGP card (DO 0x93)\n");
820       ul = 0;
821     }
822   return ul;
823 }
824
825 static unsigned long
826 get_sig_counter (APP app)
827 {
828   void *relptr;
829   unsigned char *value;
830   size_t valuelen;
831   unsigned long ul;
832
833   relptr = get_one_do (app->slot, 0x0093, &value, &valuelen);
834   if (!relptr)
835     return 0;
836   ul = convert_sig_counter_value (value, valuelen);
837   xfree (relptr);
838   return ul;
839 }
840
841 static int
842 compare_fingerprint (APP app, int keyno, unsigned char *sha1fpr)
843 {
844   const unsigned char *fpr;
845   unsigned char *buffer;
846   size_t buflen, n;
847   int rc, i;
848   
849   assert (keyno >= 1 && keyno <= 3);
850
851   rc = iso7816_get_data (app->slot, 0x006E, &buffer, &buflen);
852   if (rc)
853     {
854       log_error ("error reading application data\n");
855       return gpg_error (GPG_ERR_GENERAL);
856     }
857   fpr = find_tlv (buffer, buflen, 0x00C5, &n, 0);
858   if (!fpr || n != 60)
859     {
860       xfree (buffer);
861       log_error ("error reading fingerprint DO\n");
862       return gpg_error (GPG_ERR_GENERAL);
863     }
864   fpr += (keyno-1)*20;
865   for (i=0; i < 20; i++)
866     if (sha1fpr[i] != fpr[i])
867       {
868         xfree (buffer);
869         return gpg_error (GPG_ERR_WRONG_SECKEY);
870       }
871   xfree (buffer);
872   return 0;
873 }
874
875
876
877 /* Compute a digital signature on INDATA which is expected to be the
878    raw message digest. For this application the KEYIDSTR consists of
879    the serialnumber and the fingerprint delimited by a slash.
880
881    Note that this fucntion may return the error code
882    GPG_ERR_WRONG_CARD to indicate that the card currently present does
883    not match the one required for the requested action (e.g. the
884    serial number does not match). */
885 static int 
886 do_sign (APP app, const char *keyidstr, int hashalgo,
887          int (*pincb)(void*, const char *, char **),
888          void *pincb_arg,
889          const void *indata, size_t indatalen,
890          unsigned char **outdata, size_t *outdatalen )
891 {
892   static unsigned char sha1_prefix[15] = /* Object ID is 1.3.14.3.2.26 */
893   { 0x30, 0x21, 0x30, 0x09, 0x06, 0x05, 0x2b, 0x0e, 0x03,
894     0x02, 0x1a, 0x05, 0x00, 0x04, 0x14 };
895   static unsigned char rmd160_prefix[15] = /* Object ID is 1.3.36.3.2.1 */
896   { 0x30, 0x21, 0x30, 0x09, 0x06, 0x05, 0x2b, 0x24, 0x03,
897     0x02, 0x01, 0x05, 0x00, 0x04, 0x14 };
898   int rc;
899   unsigned char data[35];
900   unsigned char tmp_sn[20]; /* actually 16 but we use it also for the fpr. */
901   const char *s;
902   int n;
903   const char *fpr = NULL;
904   unsigned long sigcount;
905
906   if (!keyidstr || !*keyidstr)
907     return gpg_error (GPG_ERR_INV_VALUE);
908   if (indatalen != 20)
909     return gpg_error (GPG_ERR_INV_VALUE);
910
911   /* Check whether an OpenPGP card of any version has been requested. */
912   if (strlen (keyidstr) < 32 || strncmp (keyidstr, "D27600012401", 12))
913     return gpg_error (GPG_ERR_INV_ID);
914   
915   for (s=keyidstr, n=0; hexdigitp (s); s++, n++)
916     ;
917   if (n != 32)
918     return gpg_error (GPG_ERR_INV_ID);
919   else if (!*s)
920     ; /* no fingerprint given: we allow this for now. */
921   else if (*s == '/')
922     fpr = s + 1; 
923   else
924     return gpg_error (GPG_ERR_INV_ID);
925
926   for (s=keyidstr, n=0; n < 16; s += 2, n++)
927     tmp_sn[n] = xtoi_2 (s);
928
929   if (app->serialnolen != 16)
930     return gpg_error (GPG_ERR_INV_CARD);
931   if (memcmp (app->serialno, tmp_sn, 16))
932     return gpg_error (GPG_ERR_WRONG_CARD);
933
934   /* If a fingerprint has been specified check it against the one on
935      the card.  This is allows for a meaningful error message in case
936      the key on the card has been replaced but the shadow information
937      known to gpg was not updated.  If there is no fingerprint, gpg
938      will detect a bogus signature anyway due to the
939      verify-after-signing feature. */
940   if (fpr)
941     {
942       for (s=fpr, n=0; hexdigitp (s); s++, n++)
943         ;
944       if (n != 40)
945         return gpg_error (GPG_ERR_INV_ID);
946       else if (!*s)
947         ; /* okay */
948       else
949         return gpg_error (GPG_ERR_INV_ID);
950
951       for (s=fpr, n=0; n < 20; s += 2, n++)
952         tmp_sn[n] = xtoi_2 (s);
953       rc = compare_fingerprint (app, 1, tmp_sn);
954       if (rc)
955         return rc;
956     }
957
958   if (hashalgo == GCRY_MD_SHA1)
959     memcpy (data, sha1_prefix, 15);
960   else if (hashalgo == GCRY_MD_RMD160)
961     memcpy (data, rmd160_prefix, 15);
962   else 
963     return gpg_error (GPG_ERR_UNSUPPORTED_ALGORITHM);
964   memcpy (data+15, indata, indatalen);
965
966   sigcount = get_sig_counter (app);
967   log_info ("signatures created so far: %lu\n", sigcount);
968
969   if (!app->did_chv1 || app->force_chv1 ) 
970     {
971       char *pinvalue;
972
973       {
974         char *prompt;
975         if (asprintf (&prompt, "PIN [sigs done: %lu]", sigcount) < 0)
976           return gpg_error_from_errno (errno);
977         rc = pincb (pincb_arg, prompt, &pinvalue); 
978         free (prompt);
979       }
980       if (rc)
981         {
982           log_info ("PIN callback returned error: %s\n", gpg_strerror (rc));
983           return rc;
984         }
985
986       rc = iso7816_verify (app->slot, 0x81, pinvalue, strlen (pinvalue));
987       if (rc)
988         {
989           log_error ("verify CHV1 failed\n");
990           xfree (pinvalue);
991           return rc;
992         }
993       app->did_chv1 = 1;
994       if (!app->did_chv2)
995         {
996           /* We should also verify CHV2. */
997           rc = iso7816_verify (app->slot, 0x82, pinvalue, strlen (pinvalue));
998           if (gpg_err_code (rc) == GPG_ERR_BAD_PIN)
999             rc = gpg_error (GPG_ERR_PIN_NOT_SYNCED);
1000           if (rc)
1001             {
1002               log_error ("verify CHV2 failed\n");
1003               xfree (pinvalue);
1004               return rc;
1005             }
1006           app->did_chv2 = 1;
1007         }
1008       xfree (pinvalue);
1009     }
1010
1011   rc = iso7816_compute_ds (app->slot, data, 35, outdata, outdatalen);
1012   return rc;
1013 }
1014
1015 /* Compute a digital signature using the INTERNAL AUTHENTICATE command
1016    on INDATA which is expected to be the raw message digest. For this
1017    application the KEYIDSTR consists of the serialnumber and the
1018    fingerprint delimited by a slash.
1019
1020    Note that this fucntion may return the error code
1021    GPG_ERR_WRONG_CARD to indicate that the card currently present does
1022    not match the one required for the requested action (e.g. the
1023    serial number does not match). */
1024 static int 
1025 do_auth (APP app, const char *keyidstr,
1026          int (*pincb)(void*, const char *, char **),
1027          void *pincb_arg,
1028          const void *indata, size_t indatalen,
1029          unsigned char **outdata, size_t *outdatalen )
1030 {
1031   int rc;
1032   unsigned char tmp_sn[20]; /* actually 16 but we use it also for the fpr. */
1033   const char *s;
1034   int n;
1035   const char *fpr = NULL;
1036
1037   if (!keyidstr || !*keyidstr)
1038     return gpg_error (GPG_ERR_INV_VALUE);
1039   if (indatalen > 50) /* For a 1024 bit key. */
1040     return gpg_error (GPG_ERR_INV_VALUE);
1041
1042   /* Check whether an OpenPGP card of any version has been requested. */
1043   if (strlen (keyidstr) < 32 || strncmp (keyidstr, "D27600012401", 12))
1044     return gpg_error (GPG_ERR_INV_ID);
1045   
1046   for (s=keyidstr, n=0; hexdigitp (s); s++, n++)
1047     ;
1048   if (n != 32)
1049     return gpg_error (GPG_ERR_INV_ID);
1050   else if (!*s)
1051     ; /* no fingerprint given: we allow this for now. */
1052   else if (*s == '/')
1053     fpr = s + 1; 
1054   else
1055     return gpg_error (GPG_ERR_INV_ID);
1056
1057   for (s=keyidstr, n=0; n < 16; s += 2, n++)
1058     tmp_sn[n] = xtoi_2 (s);
1059
1060   if (app->serialnolen != 16)
1061     return gpg_error (GPG_ERR_INV_CARD);
1062   if (memcmp (app->serialno, tmp_sn, 16))
1063     return gpg_error (GPG_ERR_WRONG_CARD);
1064
1065   /* If a fingerprint has been specified check it against the one on
1066      the card.  This is allows for a meaningful error message in case
1067      the key on the card has been replaced but the shadow information
1068      known to gpg was not updated.  If there is no fingerprint, gpg
1069      will detect a bogus signature anyway due to the
1070      verify-after-signing feature. */
1071   if (fpr)
1072     {
1073       for (s=fpr, n=0; hexdigitp (s); s++, n++)
1074         ;
1075       if (n != 40)
1076         return gpg_error (GPG_ERR_INV_ID);
1077       else if (!*s)
1078         ; /* okay */
1079       else
1080         return gpg_error (GPG_ERR_INV_ID);
1081
1082       for (s=fpr, n=0; n < 20; s += 2, n++)
1083         tmp_sn[n] = xtoi_2 (s);
1084       rc = compare_fingerprint (app, 3, tmp_sn);
1085       if (rc)
1086         return rc;
1087     }
1088
1089   rc = verify_chv2 (app, pincb, pincb_arg);
1090   if (!rc)
1091     rc = iso7816_internal_authenticate (app->slot, indata, indatalen,
1092                                         outdata, outdatalen);
1093   return rc;
1094 }
1095
1096
1097 static int 
1098 do_decipher (APP app, const char *keyidstr,
1099              int (pincb)(void*, const char *, char **),
1100              void *pincb_arg,
1101              const void *indata, size_t indatalen,
1102              unsigned char **outdata, size_t *outdatalen )
1103 {
1104   int rc;
1105   unsigned char tmp_sn[20]; /* actually 16 but we use it also for the fpr. */
1106   const char *s;
1107   int n;
1108   const char *fpr = NULL;
1109
1110   if (!keyidstr || !*keyidstr || !indatalen)
1111     return gpg_error (GPG_ERR_INV_VALUE);
1112
1113   /* Check whether an OpenPGP card of any version has been requested. */
1114   if (strlen (keyidstr) < 32 || strncmp (keyidstr, "D27600012401", 12))
1115     return gpg_error (GPG_ERR_INV_ID);
1116   
1117   for (s=keyidstr, n=0; hexdigitp (s); s++, n++)
1118     ;
1119   if (n != 32)
1120     return gpg_error (GPG_ERR_INV_ID);
1121   else if (!*s)
1122     ; /* no fingerprint given: we allow this for now. */
1123   else if (*s == '/')
1124     fpr = s + 1; 
1125   else
1126     return gpg_error (GPG_ERR_INV_ID);
1127
1128   for (s=keyidstr, n=0; n < 16; s += 2, n++)
1129     tmp_sn[n] = xtoi_2 (s);
1130
1131   if (app->serialnolen != 16)
1132     return gpg_error (GPG_ERR_INV_CARD);
1133   if (memcmp (app->serialno, tmp_sn, 16))
1134     return gpg_error (GPG_ERR_WRONG_CARD);
1135
1136   /* If a fingerprint has been specified check it against the one on
1137      the card.  This is allows for a meaningful error message in case
1138      the key on the card has been replaced but the shadow information
1139      known to gpg was not updated.  If there is no fingerprint, the
1140      decryption will won't produce the right plaintext anyway. */
1141   if (fpr)
1142     {
1143       for (s=fpr, n=0; hexdigitp (s); s++, n++)
1144         ;
1145       if (n != 40)
1146         return gpg_error (GPG_ERR_INV_ID);
1147       else if (!*s)
1148         ; /* okay */
1149       else
1150         return gpg_error (GPG_ERR_INV_ID);
1151
1152       for (s=fpr, n=0; n < 20; s += 2, n++)
1153         tmp_sn[n] = xtoi_2 (s);
1154       rc = compare_fingerprint (app, 2, tmp_sn);
1155       if (rc)
1156         return rc;
1157     }
1158
1159   rc = verify_chv2 (app, pincb, pincb_arg);
1160   if (!rc)
1161     rc = iso7816_decipher (app->slot, indata, indatalen, outdata, outdatalen);
1162   return rc;
1163 }
1164
1165
1166
1167
1168 /* Select the OpenPGP application on the card in SLOT.  This function
1169    must be used before any other OpenPGP application functions. */
1170 int
1171 app_select_openpgp (APP app, unsigned char **sn, size_t *snlen)
1172 {
1173   static char const aid[] = { 0xD2, 0x76, 0x00, 0x01, 0x24, 0x01 };
1174   int slot = app->slot;
1175   int rc;
1176   unsigned char *buffer;
1177   size_t buflen;
1178   void *relptr;
1179   
1180   rc = iso7816_select_application (slot, aid, sizeof aid);
1181   if (!rc)
1182     {
1183       app->did_chv1 = 0;
1184       app->did_chv2 = 0;
1185       app->did_chv3 = 0;
1186
1187       rc = iso7816_get_data (slot, 0x004F, &buffer, &buflen);
1188       if (rc)
1189         goto leave;
1190       if (opt.verbose)
1191         {
1192           log_info ("got AID: ");
1193           log_printhex ("", buffer, buflen);
1194         }
1195
1196       if (sn)
1197         {
1198           *sn = buffer;
1199           *snlen = buflen;
1200           app->card_version = buffer[6] << 8;
1201           app->card_version |= buffer[7];
1202         }
1203       else
1204         xfree (buffer);
1205
1206       relptr = get_one_do (app->slot, 0x00C4, &buffer, &buflen);
1207       if (!relptr)
1208         {
1209           log_error ("can't access CHV Status Bytes - invalid OpenPGP card?\n");
1210           goto leave;
1211         }
1212       app->force_chv1 = (buflen && *buffer == 0);
1213       xfree (relptr);
1214         
1215       if (opt.verbose > 1)
1216         dump_all_do (slot);
1217
1218       app->fnc.learn_status = do_learn_status;
1219       app->fnc.getattr = do_getattr;
1220       app->fnc.setattr = do_setattr;
1221       app->fnc.genkey = do_genkey;
1222       app->fnc.sign = do_sign;
1223       app->fnc.auth = do_auth;
1224       app->fnc.decipher = do_decipher;
1225       app->fnc.change_pin = do_change_pin;
1226    }
1227
1228 leave:
1229   return rc;
1230 }
1231
1232
1233
1234 /* This function is a hack to retrieve essential information about the
1235    card to be displayed by simple tools.  It mostly resembles what the
1236    LEARN command returns. All parameters return allocated strings or
1237    buffers or NULL if the data object is not available.  All returned
1238    values are sanitized. */
1239 int
1240 app_openpgp_cardinfo (APP app,
1241                       char **serialno,
1242                       char **disp_name,
1243                       char **pubkey_url,
1244                       unsigned char **fpr1,
1245                       unsigned char **fpr2,
1246                       unsigned char **fpr3)
1247 {
1248   int rc;
1249   void *relptr;
1250   unsigned char *value;
1251   size_t valuelen;
1252
1253   if (serialno)
1254     {
1255       time_t dummy;
1256
1257       *serialno = NULL;
1258       rc = app_get_serial_and_stamp (app, serialno, &dummy);
1259       if (rc)
1260         {
1261           log_error ("error getting serial number: %s\n", gpg_strerror (rc));
1262           return rc;
1263         }
1264     }
1265       
1266   if (disp_name)
1267     {
1268       *disp_name = NULL;
1269       relptr = get_one_do (app->slot, 0x005B, &value, &valuelen);
1270       if (relptr)
1271         {
1272           *disp_name = make_printable_string (value, valuelen, 0);
1273           xfree (relptr);
1274         }
1275     }
1276
1277   if (pubkey_url)
1278     {
1279       *pubkey_url = NULL;
1280       relptr = get_one_do (app->slot, 0x5F50, &value, &valuelen);
1281       if (relptr)
1282         {
1283           *pubkey_url = make_printable_string (value, valuelen, 0);
1284           xfree (relptr);
1285         }
1286     }
1287
1288   if (fpr1)
1289     *fpr1 = NULL;
1290   if (fpr2)
1291     *fpr2 = NULL;
1292   if (fpr3)
1293     *fpr3 = NULL;
1294   relptr = get_one_do (app->slot, 0x00C5, &value, &valuelen);
1295   if (relptr && valuelen >= 60)
1296     {
1297       if (fpr1)
1298         {
1299           *fpr1 = xmalloc (20);
1300           memcpy (*fpr1, value +  0, 20);
1301         }
1302       if (fpr2)
1303         {
1304           *fpr2 = xmalloc (20);
1305           memcpy (*fpr2, value + 20, 20);
1306         }
1307       if (fpr3)
1308         {
1309           *fpr3 = xmalloc (20);
1310           memcpy (*fpr3, value + 40, 20);
1311         }
1312     }
1313   xfree (relptr);
1314
1315   return 0;
1316 }
1317
1318
1319
1320 /* This function is currently only used by the sc-copykeys program to
1321    store a key on the smartcard.  APP ist the application handle,
1322    KEYNO is the number of the key and PINCB, PINCB_ARG are used to ask
1323    for the SO PIN.  TEMPLATE and TEMPLATE_LEN describe a buffer with
1324    the key template to store. CREATED_AT is the timestamp used to
1325    create the fingerprint. M, MLEN is the RSA modulus and E, ELEN the
1326    RSA public exponent. This function silently overwrites an existing
1327    key.*/
1328 int 
1329 app_openpgp_storekey (APP app, int keyno,
1330                       unsigned char *template, size_t template_len,
1331                       time_t created_at,
1332                       const unsigned char *m, size_t mlen,
1333                       const unsigned char *e, size_t elen,
1334                       int (*pincb)(void*, const char *, char **),
1335                       void *pincb_arg)
1336 {
1337   int rc;
1338   unsigned char fprbuf[20];
1339
1340   if (keyno < 1 || keyno > 3)
1341     return gpg_error (GPG_ERR_INV_ID);
1342   keyno--;
1343
1344   rc = verify_chv3 (app, pincb, pincb_arg);
1345   if (rc)
1346     goto leave;
1347
1348
1349   rc = iso7816_put_data (app->slot,
1350                          (app->card_version > 0x0007? 0xE0 : 0xE9) + keyno,
1351                          template, template_len);
1352   if (rc)
1353     {
1354       log_error ("failed to store the key: rc=%s\n", gpg_strerror (rc));
1355       rc = gpg_error (GPG_ERR_CARD);
1356       goto leave;
1357     }
1358  
1359 /*    log_printhex ("RSA n:", m, mlen);  */
1360 /*    log_printhex ("RSA e:", e, elen);  */
1361
1362   rc = store_fpr (app->slot, keyno, (u32)created_at,
1363                   m, mlen, e, elen, fprbuf, app->card_version);
1364
1365  leave:
1366   return rc;
1367 }
1368
1369
1370 /* Utility function for external tools: Read the public RSA key at
1371    KEYNO and return modulus and exponent in (M,MLEN) and (E,ELEN). */
1372 int 
1373 app_openpgp_readkey (APP app, int keyno, unsigned char **m, size_t *mlen,
1374                      unsigned char **e, size_t *elen)
1375 {
1376   int rc;
1377   const unsigned char *keydata, *a;
1378   unsigned char *buffer;
1379   size_t buflen, keydatalen, alen;
1380
1381   *m = NULL;
1382   *e = NULL;
1383
1384   if (keyno < 1 || keyno > 3)
1385     return gpg_error (GPG_ERR_INV_ID);
1386   keyno--;
1387
1388   rc = iso7816_read_public_key(app->slot, 
1389                                keyno == 0? "\xB6" :
1390                                keyno == 1? "\xB8" : "\xA4",
1391                                2,
1392                                &buffer, &buflen);
1393   if (rc)
1394     {
1395       rc = gpg_error (GPG_ERR_CARD);
1396       log_error ("reading key failed\n");
1397       goto leave;
1398     }
1399
1400   keydata = find_tlv (buffer, buflen, 0x7F49, &keydatalen, 0);
1401   if (!keydata)
1402     {
1403       log_error ("response does not contain the public key data\n");
1404       rc = gpg_error (GPG_ERR_CARD);
1405       goto leave;
1406     }
1407  
1408   a = find_tlv (keydata, keydatalen, 0x0081, &alen, 0);
1409   if (!a)
1410     {
1411       log_error ("response does not contain the RSA modulus\n");
1412       rc = gpg_error (GPG_ERR_CARD);
1413       goto leave;
1414     }
1415   *mlen = alen;
1416   *m = xmalloc (alen);
1417   memcpy (*m, a, alen);
1418   
1419   a = find_tlv (keydata, keydatalen, 0x0082, &alen, 0);
1420   if (!e)
1421     {
1422       log_error ("response does not contain the RSA public exponent\n");
1423       rc = gpg_error (GPG_ERR_CARD);
1424       goto leave;
1425     }
1426   *elen = alen;
1427   *e = xmalloc (alen);
1428   memcpy (*e, a, alen);
1429
1430  leave:
1431   xfree (buffer);
1432   if (rc)
1433     { 
1434       xfree (*m); *m = NULL;
1435       xfree (*e); *e = NULL;
1436     }
1437   return rc;
1438 }