Note: I have not fully tested the new key creation due to a pc/sc
[gnupg.git] / g10 / app-openpgp.c
1 /* app-openpgp.c - The OpenPGP card application.
2  *      Copyright (C) 2003, 2004 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 #include <time.h>
28
29 #if GNUPG_MAJOR_VERSION == 1
30 /* This is used with GnuPG version < 1.9.  The code has been source
31    copied from the current GnuPG >= 1.9  and is maintained over
32    there. */
33 #include "options.h"
34 #include "errors.h"
35 #include "memory.h"
36 #include "util.h"
37 #include "i18n.h"
38 #include "cardglue.h"
39 #else /* GNUPG_MAJOR_VERSION != 1 */
40 #include "scdaemon.h"
41 #endif /* GNUPG_MAJOR_VERSION != 1 */
42
43 #include "iso7816.h"
44 #include "app-common.h"
45 #include "tlv.h"
46
47
48 static struct {
49   int tag;
50   int constructed;
51   int get_from;  /* Constructed DO with this DO or 0 for direct access. */
52   int binary;
53   int dont_cache;
54   int flush_on_error;
55   char *desc;
56 } data_objects[] = {
57   { 0x005E, 0,    0, 1, 0, 0, "Login Data" },
58   { 0x5F50, 0,    0, 0, 0, 0, "URL" },
59   { 0x0065, 1,    0, 1, 0, 0, "Cardholder Related Data"},
60   { 0x005B, 0, 0x65, 0, 0, 0, "Name" },
61   { 0x5F2D, 0, 0x65, 0, 0, 0, "Language preferences" },
62   { 0x5F35, 0, 0x65, 0, 0, 0, "Sex" },
63   { 0x006E, 1,    0, 1, 0, 0, "Application Related Data" },
64   { 0x004F, 0, 0x6E, 1, 0, 0, "AID" },
65   { 0x0073, 1,    0, 1, 0, 0, "Discretionary Data Objects" },
66   { 0x0047, 0, 0x6E, 1, 1, 0, "Card Capabilities" },
67   { 0x00C0, 0, 0x6E, 1, 1, 0, "Extended Card Capabilities" },
68   { 0x00C1, 0, 0x6E, 1, 1, 0, "Algorithm Attributes Signature" },
69   { 0x00C2, 0, 0x6E, 1, 1, 0, "Algorithm Attributes Decryption" },
70   { 0x00C3, 0, 0x6E, 1, 1, 0, "Algorithm Attributes Authentication" },
71   { 0x00C4, 0, 0x6E, 1, 0, 1, "CHV Status Bytes" },
72   { 0x00C5, 0, 0x6E, 1, 0, 0, "Fingerprints" },
73   { 0x00C6, 0, 0x6E, 1, 0, 0, "CA Fingerprints" },
74   { 0x007A, 1,    0, 1, 0, 0, "Security Support Template" },
75   { 0x0093, 0, 0x7A, 1, 1, 0, "Digital Signature Counter" },
76   { 0 }
77 };
78
79
80 struct cache_s {
81   struct cache_s *next;
82   int tag;
83   size_t length;
84   unsigned char data[1];
85 };
86
87 struct app_local_s {
88   struct cache_s *cache;
89   struct 
90   {
91     unsigned int get_challenge:1;
92     unsigned int key_import:1;
93     unsigned int change_force_chv:1;
94     unsigned int private_dos:1;
95   } extcap;
96 };
97
98
99 static unsigned long convert_sig_counter_value (const unsigned char *value,
100                                                 size_t valuelen);
101 static unsigned long get_sig_counter (APP app);
102
103 /* Deconstructor. */
104 static void
105 do_deinit (app_t app)
106 {
107   if (app && app->app_local)
108     {
109       struct cache_s *c, *c2;
110
111       for (c = app->app_local->cache; c; c = c2)
112         {
113           c2 = c->next;
114           xfree (c);
115         }
116       xfree (app->app_local);
117       app->app_local = NULL;
118     }
119 }
120
121
122 /* Wrapper around iso7816_get_data which first tries to get the data
123    from the cache. */
124 static gpg_error_t
125 get_cached_data (app_t app, int tag, 
126                  unsigned char **result, size_t *resultlen)
127 {
128   gpg_error_t err;
129   int i;
130   unsigned char *p;
131   size_t len;
132   struct cache_s *c;
133
134   *result = NULL;
135   *resultlen = 0;
136
137   for (c=app->app_local->cache; c; c = c->next)
138     if (c->tag == tag)
139       {
140         if(c->length)
141           {
142             p = xtrymalloc (c->length);
143             if (!p)
144               return gpg_error (gpg_err_code_from_errno (errno));
145             memcpy (p, c->data, c->length);
146             *result = p;
147           }
148
149         *resultlen = c->length;
150
151         return 0;
152       }
153  
154   
155   err = iso7816_get_data (app->slot, tag, &p, &len);
156   if (err)
157     return err;
158   *result = p;
159   *resultlen = len;
160
161   /* Check whether we should cache this object. */
162   for (i=0; data_objects[i].tag; i++)
163     if (data_objects[i].tag == tag)
164       {
165         if (data_objects[i].dont_cache)
166           return 0;
167         break;
168       }
169
170   /* No, cache it. */
171
172   for (c=app->app_local->cache; c; c = c->next)
173     assert (c->tag != tag);
174   
175   c = xtrymalloc (sizeof *c + len);
176   if (c)
177     {
178       memcpy (c->data, p, len);
179       c->length = len;
180       c->tag = tag;
181       c->next = app->app_local->cache;
182       app->app_local->cache = c;
183     }
184
185   return 0;
186 }
187
188 /* Remove DO at TAG from the cache. */
189 static void
190 flush_cache_item (app_t app, int tag)
191 {
192   struct cache_s *c, *cprev;
193   int i;
194
195   if (!app->app_local)
196     return;
197
198   for (c=app->app_local->cache, cprev=NULL; c ; cprev=c, c = c->next)
199     if (c->tag == tag)
200       {
201         if (cprev)
202           cprev->next = c->next;
203         else
204           app->app_local->cache = c->next;
205         xfree (c);
206
207         for (c=app->app_local->cache; c ; c = c->next)
208           assert (c->tag != tag); /* Oops: duplicated entry. */
209         return;
210       }
211
212   /* Try again if we have an outer tag. */
213   for (i=0; data_objects[i].tag; i++)
214     if (data_objects[i].tag == tag && data_objects[i].get_from
215         && data_objects[i].get_from != tag)
216       flush_cache_item (app, data_objects[i].get_from);
217 }
218
219 /* Flush all entries from the cache which might be out of sync after
220    an error. */
221 static void
222 flush_cache_after_error (app_t app)
223 {
224   int i;
225
226   for (i=0; data_objects[i].tag; i++)
227     if (data_objects[i].flush_on_error)
228       flush_cache_item (app, data_objects[i].tag);
229 }
230
231
232 /* Flush the entire cache. */
233 static void
234 flush_cache (app_t app)
235 {
236   if (app && app->app_local)
237     {
238       struct cache_s *c, *c2;
239
240       for (c = app->app_local->cache; c; c = c2)
241         {
242           c2 = c->next;
243           xfree (c);
244         }
245       app->app_local->cache = NULL;
246     }
247 }
248
249
250 /* Get the DO identified by TAG from the card in SLOT and return a
251    buffer with its content in RESULT and NBYTES.  The return value is
252    NULL if not found or a pointer which must be used to release the
253    buffer holding value. */
254 static void *
255 get_one_do (app_t app, int tag, unsigned char **result, size_t *nbytes)
256 {
257   int rc, i;
258   unsigned char *buffer;
259   size_t buflen;
260   unsigned char *value;
261   size_t valuelen;
262
263   *result = NULL;
264   *nbytes = 0;
265   for (i=0; data_objects[i].tag && data_objects[i].tag != tag; i++)
266     ;
267
268   value = NULL;
269   rc = -1;
270   if (data_objects[i].tag && data_objects[i].get_from)
271     {
272       rc = get_cached_data (app, data_objects[i].get_from,
273                             &buffer, &buflen);
274       if (!rc)
275         {
276           const unsigned char *s;
277
278           s = find_tlv (buffer, buflen, tag, &valuelen);
279           if (!s)
280             value = NULL; /* not found */
281           else if (valuelen > buflen - (s - buffer))
282             {
283               log_error ("warning: constructed DO too short\n");
284               value = NULL;
285               xfree (buffer); buffer = NULL;
286             }
287           else
288             value = buffer + (s - buffer);
289         }
290     }
291
292   if (!value) /* Not in a constructed DO, try simple. */
293     {
294       rc = get_cached_data (app, tag, &buffer, &buflen);
295       if (!rc)
296         {
297           value = buffer;
298           valuelen = buflen;
299         }
300     }
301
302   if (!rc)
303     {
304       *nbytes = valuelen;
305       *result = value;
306       return buffer;
307     }
308   return NULL;
309 }
310
311
312 static void
313 dump_all_do (int slot)
314 {
315   int rc, i, j;
316   unsigned char *buffer;
317   size_t buflen;
318   
319   for (i=0; data_objects[i].tag; i++)
320     {
321       if (data_objects[i].get_from)
322         continue;
323
324       rc = iso7816_get_data (slot, data_objects[i].tag, &buffer, &buflen);
325       if (gpg_err_code (rc) == GPG_ERR_NO_OBJ)
326         ;
327       else if (rc) 
328         log_info ("DO `%s' not available: %s\n",
329                   data_objects[i].desc, gpg_strerror (rc));
330       else
331         {
332           if (data_objects[i].binary)
333             {
334               log_info ("DO `%s': ", data_objects[i].desc);
335               log_printhex ("", buffer, buflen);
336             }
337           else
338             log_info ("DO `%s': `%.*s'\n",
339                       data_objects[i].desc,
340                       (int)buflen, buffer); /* FIXME: sanitize */
341
342           if (data_objects[i].constructed)
343             {
344               for (j=0; data_objects[j].tag; j++)
345                 {
346                   const unsigned char *value;
347                   size_t valuelen;
348                   
349                   if (j==i || data_objects[i].tag != data_objects[j].get_from)
350                     continue;
351                   value = find_tlv (buffer, buflen,
352                                     data_objects[j].tag, &valuelen);
353                   if (!value)
354                     ; /* not found */
355                   else if (valuelen > buflen - (value - buffer))
356                     log_error ("warning: constructed DO too short\n");
357                   else
358                     {
359                       if (data_objects[j].binary)
360                         {
361                           log_info ("DO `%s': ", data_objects[j].desc);
362                           log_printhex ("", value, valuelen);
363                         }
364                       else
365                         log_info ("DO `%s': `%.*s'\n",
366                                   data_objects[j].desc,
367                                   (int)valuelen, value); /* FIXME: sanitize */
368                     }
369                 }
370             }
371         }
372       xfree (buffer); buffer = NULL;
373     }
374 }
375
376
377 /* Count the number of bits, assuming the A represents an unsigned big
378    integer of length LEN bytes. */
379 static unsigned int
380 count_bits (const unsigned char *a, size_t len)
381 {
382   unsigned int n = len * 8;
383   int i;
384
385   for (; len && !*a; len--, a++, n -=8)
386     ;
387   if (len)
388     {
389       for (i=7; i && !(*a & (1<<i)); i--)
390         n--;
391     }
392   return n;
393 }
394
395 /* Note, that FPR must be at least 20 bytes. */
396 static int 
397 store_fpr (int slot, int keynumber, u32 timestamp,
398            const unsigned char *m, size_t mlen,
399            const unsigned char *e, size_t elen, 
400            unsigned char *fpr, unsigned int card_version)
401 {
402   unsigned int n, nbits;
403   unsigned char *buffer, *p;
404   int rc;
405   
406   for (; mlen && !*m; mlen--, m++) /* strip leading zeroes */
407     ;
408   for (; elen && !*e; elen--, e++) /* strip leading zeroes */
409     ;
410
411   n = 6 + 2 + mlen + 2 + elen;
412   p = buffer = xtrymalloc (3 + n);
413   if (!buffer)
414     return gpg_error (gpg_err_code_from_errno (errno));
415   
416   *p++ = 0x99;     /* ctb */
417   *p++ = n >> 8;   /* 2 byte length header */
418   *p++ = n;
419   *p++ = 4;        /* key packet version */
420   *p++ = timestamp >> 24;
421   *p++ = timestamp >> 16;
422   *p++ = timestamp >>  8;
423   *p++ = timestamp;
424   *p++ = 1; /* RSA */
425   nbits = count_bits (m, mlen);
426   *p++ = nbits >> 8;
427   *p++ = nbits;
428   memcpy (p, m, mlen); p += mlen;
429   nbits = count_bits (e, elen);
430   *p++ = nbits >> 8;
431   *p++ = nbits;
432   memcpy (p, e, elen); p += elen;
433     
434   gcry_md_hash_buffer (GCRY_MD_SHA1, fpr, buffer, n+3);
435
436   xfree (buffer);
437
438   rc = iso7816_put_data (slot, (card_version > 0x0007? 0xC7 : 0xC6)
439                                + keynumber, fpr, 20);
440   if (rc)
441     log_error ("failed to store the fingerprint: %s\n",gpg_strerror (rc));
442
443   return rc;
444 }
445
446        
447 static void
448 send_fpr_if_not_null (CTRL ctrl, const char *keyword,
449                       int number, const unsigned char *fpr)
450 {                      
451   int i;
452   char buf[41];
453   char numbuf[25];
454
455   for (i=0; i < 20 && !fpr[i]; i++)
456     ;
457   if (i==20)
458     return; /* All zero. */
459   for (i=0; i< 20; i++)
460     sprintf (buf+2*i, "%02X", fpr[i]);
461   if (number == -1)
462     *numbuf = 0; /* Don't print the key number */
463   else
464     sprintf (numbuf, "%d", number);
465   send_status_info (ctrl, keyword,
466                     numbuf, (size_t)strlen(numbuf),
467                     buf, (size_t)strlen (buf), NULL, 0);
468 }
469
470 static void
471 send_key_data (CTRL ctrl, const char *name, 
472                const unsigned char *a, size_t alen)
473 {
474   char *p, *buf = xmalloc (alen*2+1);
475   
476   for (p=buf; alen; a++, alen--, p += 2)
477     sprintf (p, "%02X", *a);
478
479   send_status_info (ctrl, "KEY-DATA",
480                     name, (size_t)strlen(name), 
481                     buf, (size_t)strlen (buf),
482                     NULL, 0);
483   xfree (buf);
484 }
485
486 /* Implement the GETATTR command.  This is similar to the LEARN
487    command but returns just one value via the status interface. */
488 static int 
489 do_getattr (APP app, CTRL ctrl, const char *name)
490 {
491   static struct {
492     const char *name;
493     int tag;
494     int special;
495   } table[] = {
496     { "DISP-NAME",    0x005B },
497     { "LOGIN-DATA",   0x005E },
498     { "DISP-LANG",    0x5F2D },
499     { "DISP-SEX",     0x5F35 },
500     { "PUBKEY-URL",   0x5F50 },
501     { "KEY-FPR",      0x00C5, 3 },
502     { "CA-FPR",       0x00C6, 3 },
503     { "CHV-STATUS",   0x00C4, 1 },
504     { "SIG-COUNTER",  0x0093, 2 },
505     { "SERIALNO",     0x004F, -1 },
506     { "AID",          0x004F },
507     { "EXTCAP",       0x0000, -2 },
508     { NULL, 0 }
509   };
510   int idx, i;
511   void *relptr;
512   unsigned char *value;
513   size_t valuelen;
514
515   for (idx=0; table[idx].name && strcmp (table[idx].name, name); idx++)
516     ;
517   if (!table[idx].name)
518     return gpg_error (GPG_ERR_INV_NAME); 
519   
520   if (table[idx].special == -1)
521     {
522       /* The serial number is very special.  We could have used the
523          AID DO to retrieve it, but we have it already in the app
524          context and the stamp argument is required anyway which we
525          can't by other means. The AID DO is available anyway but not
526          hex formatted. */
527       char *serial;
528       time_t stamp;
529       char tmp[50];
530
531       if (!app_get_serial_and_stamp (app, &serial, &stamp))
532         {
533           sprintf (tmp, "%lu", (unsigned long)stamp);
534           send_status_info (ctrl, "SERIALNO",
535                             serial, strlen (serial),
536                             tmp, strlen (tmp),
537                             NULL, 0);
538           xfree (serial);
539         }
540       return 0;
541     }
542   if (table[idx].special == -2)
543     {
544       char tmp[50];
545
546       sprintf (tmp, "gc=%d ki=%d fc=%d pd=%d", 
547                app->app_local->extcap.get_challenge,
548                app->app_local->extcap.key_import,
549                app->app_local->extcap.change_force_chv,
550                app->app_local->extcap.private_dos);
551       send_status_info (ctrl, table[idx].name, tmp, strlen (tmp), NULL, 0);
552       return 0;
553     }
554
555   relptr = get_one_do (app, table[idx].tag, &value, &valuelen);
556   if (relptr)
557     {
558       if (table[idx].special == 1)
559         {
560           char numbuf[7*23];
561           
562           for (i=0,*numbuf=0; i < valuelen && i < 7; i++)
563             sprintf (numbuf+strlen (numbuf), " %d", value[i]); 
564           send_status_info (ctrl, table[idx].name,
565                             numbuf, strlen (numbuf), NULL, 0);
566         }
567       else if (table[idx].special == 2)
568         {
569           char numbuf[50];
570
571           sprintf (numbuf, "%lu", convert_sig_counter_value (value, valuelen));
572           send_status_info (ctrl, table[idx].name,
573                             numbuf, strlen (numbuf), NULL, 0);
574         }
575       else if (table[idx].special == 3)
576         {
577           if (valuelen >= 60)
578             for (i=0; i < 3; i++)
579               send_fpr_if_not_null (ctrl, table[idx].name, i+1, value+i*20);
580         }
581       else
582         send_status_info (ctrl, table[idx].name, value, valuelen, NULL, 0);
583
584       xfree (relptr);
585     }
586   return 0;
587 }
588
589
590 static int
591 do_learn_status (APP app, CTRL ctrl)
592 {
593   do_getattr (app, ctrl, "EXTCAP");
594   do_getattr (app, ctrl, "DISP-NAME");
595   do_getattr (app, ctrl, "DISP-LANG");
596   do_getattr (app, ctrl, "DISP-SEX");
597   do_getattr (app, ctrl, "PUBKEY-URL");
598   do_getattr (app, ctrl, "LOGIN-DATA");
599   do_getattr (app, ctrl, "KEY-FPR");
600   do_getattr (app, ctrl, "CA-FPR");
601   do_getattr (app, ctrl, "CHV-STATUS");
602   do_getattr (app, ctrl, "SIG-COUNTER");
603
604   return 0;
605 }
606
607
608 /* Verify CHV2 if required.  Depending on the configuration of the
609    card CHV1 will also be verified. */
610 static int
611 verify_chv2 (app_t app,
612              int (*pincb)(void*, const char *, char **),
613              void *pincb_arg)
614 {
615   int rc = 0;
616
617   if (!app->did_chv2) 
618     {
619       char *pinvalue;
620
621       rc = pincb (pincb_arg, "PIN", &pinvalue); 
622       if (rc)
623         {
624           log_info ("PIN callback returned error: %s\n", gpg_strerror (rc));
625           return rc;
626         }
627
628       if (strlen (pinvalue) < 6)
629         {
630           log_error ("prassphrase (CHV2) is too short; minimum length is 6\n");
631           xfree (pinvalue);
632           return gpg_error (GPG_ERR_BAD_PIN);
633         }
634
635       rc = iso7816_verify (app->slot, 0x82, pinvalue, strlen (pinvalue));
636       if (rc)
637         {
638           log_error ("verify CHV2 failed: %s\n", gpg_strerror (rc));
639           xfree (pinvalue);
640           flush_cache_after_error (app);
641           return rc;
642         }
643       app->did_chv2 = 1;
644
645       if (!app->did_chv1 && !app->force_chv1)
646         {
647           rc = iso7816_verify (app->slot, 0x81, pinvalue, strlen (pinvalue));
648           if (gpg_err_code (rc) == GPG_ERR_BAD_PIN)
649             rc = gpg_error (GPG_ERR_PIN_NOT_SYNCED);
650           if (rc)
651             {
652               log_error ("verify CHV1 failed: %s\n", gpg_strerror (rc));
653               xfree (pinvalue);
654               flush_cache_after_error (app);
655               return rc;
656             }
657           app->did_chv1 = 1;
658         }
659       xfree (pinvalue);
660     }
661   return rc;
662 }
663
664 /* Verify CHV3 if required. */
665 static int
666 verify_chv3 (APP app,
667              int (*pincb)(void*, const char *, char **),
668              void *pincb_arg)
669 {
670   int rc = 0;
671
672   if (!opt.allow_admin)
673     {
674       log_info ("access to admin commands is not configured\n");
675       return gpg_error (GPG_ERR_EACCES);
676     }
677       
678   if (!app->did_chv3) 
679     {
680       char *pinvalue;
681
682       rc = pincb (pincb_arg, "Admin PIN", &pinvalue); 
683       if (rc)
684         {
685           log_info ("PIN callback returned error: %s\n", gpg_strerror (rc));
686           return rc;
687         }
688
689       if (strlen (pinvalue) < 6)
690         {
691           log_error ("prassphrase (CHV3) is too short; minimum length is 6\n");
692           xfree (pinvalue);
693           return gpg_error (GPG_ERR_BAD_PIN);
694         }
695
696       rc = iso7816_verify (app->slot, 0x83, pinvalue, strlen (pinvalue));
697       xfree (pinvalue);
698       if (rc)
699         {
700           log_error ("verify CHV3 failed: %s\n", gpg_strerror (rc));
701           flush_cache_after_error (app);
702           return rc;
703         }
704       app->did_chv3 = 1;
705     }
706   return rc;
707 }
708
709
710 /* Handle the SETATTR operation. All arguments are already basically
711    checked. */
712 static int 
713 do_setattr (APP app, const char *name,
714             int (*pincb)(void*, const char *, char **),
715             void *pincb_arg,
716             const unsigned char *value, size_t valuelen)
717 {
718   gpg_error_t rc;
719   int idx;
720   static struct {
721     const char *name;
722     int tag;
723     int special;
724   } table[] = {
725     { "DISP-NAME",    0x005B },
726     { "LOGIN-DATA",   0x005E },
727     { "DISP-LANG",    0x5F2D },
728     { "DISP-SEX",     0x5F35 },
729     { "PUBKEY-URL",   0x5F50 },
730     { "CHV-STATUS-1", 0x00C4, 1 },
731     { "CA-FPR-1",     0x00CA },
732     { "CA-FPR-2",     0x00CB },
733     { "CA-FPR-3",     0x00CC },
734     { NULL, 0 }
735   };
736
737
738   for (idx=0; table[idx].name && strcmp (table[idx].name, name); idx++)
739     ;
740   if (!table[idx].name)
741     return gpg_error (GPG_ERR_INV_NAME); 
742
743   rc = verify_chv3 (app, pincb, pincb_arg);
744   if (rc)
745     return rc;
746
747   /* Flush the cache before writing it, so that the next get operation
748      will reread the data from the card and thus get synced in case of
749      errors (e.g. data truncated by the card). */
750   flush_cache_item (app, table[idx].tag);
751   rc = iso7816_put_data (app->slot, table[idx].tag, value, valuelen);
752   if (rc)
753     log_error ("failed to set `%s': %s\n", table[idx].name, gpg_strerror (rc));
754
755   if (table[idx].special == 1)
756     app->force_chv1 = (valuelen && *value == 0);
757
758   return rc;
759 }
760
761
762 /* Handle the PASSWD command. */
763 static int 
764 do_change_pin (APP app, CTRL ctrl,  const char *chvnostr, int reset_mode,
765                int (*pincb)(void*, const char *, char **),
766                void *pincb_arg)
767 {
768   int rc = 0;
769   int chvno = atoi (chvnostr);
770   char *pinvalue;
771
772   if (reset_mode && chvno == 3)
773     {
774       rc = gpg_error (GPG_ERR_INV_ID);
775       goto leave;
776     }
777   else if (reset_mode || chvno == 3)
778     {
779       /* we always require that the PIN is entered. */
780       app->did_chv3 = 0;
781       rc = verify_chv3 (app, pincb, pincb_arg);
782       if (rc)
783         goto leave;
784     }
785   else if (chvno == 1 || chvno == 2)
786     {
787       /* CHV1 and CVH2 should always have the same value, thus we
788          enforce it here.  */
789       int save_force = app->force_chv1;
790
791       app->force_chv1 = 0;
792       app->did_chv1 = 0;
793       app->did_chv2 = 0;
794       rc = verify_chv2 (app, pincb, pincb_arg);
795       app->force_chv1 = save_force;
796       if (rc)
797         goto leave;
798     }
799   else
800     {
801       rc = gpg_error (GPG_ERR_INV_ID);
802       goto leave;
803     }
804
805   if (chvno == 3)
806     app->did_chv3 = 0;
807   else
808     app->did_chv1 = app->did_chv2 = 0;
809
810   rc = pincb (pincb_arg, chvno == 3? "New Admin PIN" : "New PIN", &pinvalue); 
811   if (rc)
812     {
813       log_error ("error getting new PIN: %s\n", gpg_strerror (rc));
814       goto leave;
815     }
816
817   if (reset_mode)
818     {
819       rc = iso7816_reset_retry_counter (app->slot, 0x81,
820                                         pinvalue, strlen (pinvalue));
821       if (!rc)
822         rc = iso7816_reset_retry_counter (app->slot, 0x82,
823                                           pinvalue, strlen (pinvalue));
824     }
825   else
826     {
827       if (chvno == 1 || chvno == 2)
828         {
829           rc = iso7816_change_reference_data (app->slot, 0x81, NULL, 0,
830                                               pinvalue, strlen (pinvalue));
831           if (!rc)
832             rc = iso7816_change_reference_data (app->slot, 0x82, NULL, 0,
833                                                 pinvalue, strlen (pinvalue));
834         }
835       else
836         rc = iso7816_change_reference_data (app->slot, 0x80 + chvno, NULL, 0,
837                                             pinvalue, strlen (pinvalue));
838     }
839   xfree (pinvalue);
840   if (rc)
841     flush_cache_after_error (app);
842
843  leave:
844   return rc;
845 }
846
847
848
849 /* Handle the GENKEY command. */
850 static int 
851 do_genkey (APP app, CTRL ctrl,  const char *keynostr, unsigned int flags,
852           int (*pincb)(void*, const char *, char **),
853           void *pincb_arg)
854 {
855   int rc;
856   int i;
857   char numbuf[30];
858   unsigned char fprbuf[20];
859   const unsigned char *fpr;
860   const unsigned char *keydata, *m, *e;
861   unsigned char *buffer;
862   size_t buflen, keydatalen, n, mlen, elen;
863   time_t created_at;
864   int keyno = atoi (keynostr);
865   int force = (flags & 1);
866   time_t start_at;
867
868   if (keyno < 1 || keyno > 3)
869     return gpg_error (GPG_ERR_INV_ID);
870   keyno--;
871
872   /* We flush the cache to increase the traffic before a key
873      generation.  This _might_ help a card to gather more entropy. */
874   flush_cache (app);
875
876   rc = iso7816_get_data (app->slot, 0x006E, &buffer, &buflen);
877   if (rc)
878     {
879       log_error ("error reading application data\n");
880       return gpg_error (GPG_ERR_GENERAL);
881     }
882   fpr = find_tlv (buffer, buflen, 0x00C5, &n);
883   if (!fpr || n != 60)
884     {
885       rc = gpg_error (GPG_ERR_GENERAL);
886       log_error ("error reading fingerprint DO\n");
887       goto leave;
888     }
889   fpr += 20*keyno;
890   for (i=0; i < 20 && !fpr[i]; i++)
891     ;
892   if (i!=20 && !force)
893     {
894       rc = gpg_error (GPG_ERR_EEXIST);
895       log_error ("key already exists\n");
896       goto leave;
897     }
898   else if (i!=20)
899     log_info ("existing key will be replaced\n");
900   else
901     log_info ("generating new key\n");
902
903
904   rc = verify_chv3 (app, pincb, pincb_arg);
905   if (rc)
906     goto leave;
907
908   xfree (buffer); buffer = NULL;
909
910 #if 1
911   log_info ("please wait while key is being generated ...\n");
912   start_at = time (NULL);
913   rc = iso7816_generate_keypair 
914 #else
915 #warning key generation temporary replaced by reading an existing key.
916   rc = iso7816_read_public_key
917 #endif
918                               (app->slot, 
919                                  keyno == 0? "\xB6" :
920                                  keyno == 1? "\xB8" : "\xA4",
921                                  2,
922                                  &buffer, &buflen);
923   if (rc)
924     {
925       rc = gpg_error (GPG_ERR_CARD);
926       log_error ("generating key failed\n");
927       goto leave;
928     }
929   log_info ("key generation completed (%d seconds)\n",
930             (int)(time (NULL) - start_at));
931   keydata = find_tlv (buffer, buflen, 0x7F49, &keydatalen);
932   if (!keydata)
933     {
934       rc = gpg_error (GPG_ERR_CARD);
935       log_error ("response does not contain the public key data\n");
936       goto leave;
937     }
938  
939   m = find_tlv (keydata, keydatalen, 0x0081, &mlen);
940   if (!m)
941     {
942       rc = gpg_error (GPG_ERR_CARD);
943       log_error ("response does not contain the RSA modulus\n");
944       goto leave;
945     }
946 /*    log_printhex ("RSA n:", m, mlen); */
947   send_key_data (ctrl, "n", m, mlen);
948
949   e = find_tlv (keydata, keydatalen, 0x0082, &elen);
950   if (!e)
951     {
952       rc = gpg_error (GPG_ERR_CARD);
953       log_error ("response does not contain the RSA public exponent\n");
954       goto leave;
955     }
956 /*    log_printhex ("RSA e:", e, elen); */
957   send_key_data (ctrl, "e", e, elen);
958
959   created_at = gnupg_get_time ();
960   sprintf (numbuf, "%lu", (unsigned long)created_at);
961   send_status_info (ctrl, "KEY-CREATED-AT",
962                     numbuf, (size_t)strlen(numbuf), NULL, 0);
963
964   rc = store_fpr (app->slot, keyno, (u32)created_at,
965                   m, mlen, e, elen, fprbuf, app->card_version);
966   if (rc)
967     goto leave;
968   send_fpr_if_not_null (ctrl, "KEY-FPR", -1, fprbuf);
969
970
971  leave:
972   xfree (buffer);
973   return rc;
974 }
975
976
977 static unsigned long
978 convert_sig_counter_value (const unsigned char *value, size_t valuelen)
979 {
980   unsigned long ul;
981
982   if (valuelen == 3 )
983     ul = (value[0] << 16) | (value[1] << 8) | value[2];
984   else
985     {
986       log_error ("invalid structure of OpenPGP card (DO 0x93)\n");
987       ul = 0;
988     }
989   return ul;
990 }
991
992 static unsigned long
993 get_sig_counter (APP app)
994 {
995   void *relptr;
996   unsigned char *value;
997   size_t valuelen;
998   unsigned long ul;
999
1000   relptr = get_one_do (app, 0x0093, &value, &valuelen);
1001   if (!relptr)
1002     return 0;
1003   ul = convert_sig_counter_value (value, valuelen);
1004   xfree (relptr);
1005   return ul;
1006 }
1007
1008 static int
1009 compare_fingerprint (APP app, int keyno, unsigned char *sha1fpr)
1010 {
1011   const unsigned char *fpr;
1012   unsigned char *buffer;
1013   size_t buflen, n;
1014   int rc, i;
1015   
1016   assert (keyno >= 1 && keyno <= 3);
1017
1018   rc = get_cached_data (app, 0x006E, &buffer, &buflen);
1019   if (rc)
1020     {
1021       log_error ("error reading application data\n");
1022       return gpg_error (GPG_ERR_GENERAL);
1023     }
1024   fpr = find_tlv (buffer, buflen, 0x00C5, &n);
1025   if (!fpr || n != 60)
1026     {
1027       xfree (buffer);
1028       log_error ("error reading fingerprint DO\n");
1029       return gpg_error (GPG_ERR_GENERAL);
1030     }
1031   fpr += (keyno-1)*20;
1032   for (i=0; i < 20; i++)
1033     if (sha1fpr[i] != fpr[i])
1034       {
1035         xfree (buffer);
1036         return gpg_error (GPG_ERR_WRONG_SECKEY);
1037       }
1038   xfree (buffer);
1039   return 0;
1040 }
1041
1042
1043   /* If a fingerprint has been specified check it against the one on
1044      the card.  This is allows for a meaningful error message in case
1045      the key on the card has been replaced but the shadow information
1046      known to gpg was not updated.  If there is no fingerprint we
1047      assume that this is okay. */
1048 static int
1049 check_against_given_fingerprint (APP app, const char *fpr, int keyno)
1050 {
1051   unsigned char tmp[20];
1052   const char *s;
1053   int n;
1054
1055   for (s=fpr, n=0; hexdigitp (s); s++, n++)
1056     ;
1057   if (n != 40)
1058     return gpg_error (GPG_ERR_INV_ID);
1059   else if (!*s)
1060     ; /* okay */
1061   else
1062     return gpg_error (GPG_ERR_INV_ID);
1063
1064   for (s=fpr, n=0; n < 20; s += 2, n++)
1065         tmp[n] = xtoi_2 (s);
1066   return compare_fingerprint (app, keyno, tmp);
1067 }
1068
1069
1070
1071 /* Compute a digital signature on INDATA which is expected to be the
1072    raw message digest. For this application the KEYIDSTR consists of
1073    the serialnumber and the fingerprint delimited by a slash.
1074
1075    Note that this fucntion may return the error code
1076    GPG_ERR_WRONG_CARD to indicate that the card currently present does
1077    not match the one required for the requested action (e.g. the
1078    serial number does not match). */
1079 static int 
1080 do_sign (APP app, const char *keyidstr, int hashalgo,
1081          int (*pincb)(void*, const char *, char **),
1082          void *pincb_arg,
1083          const void *indata, size_t indatalen,
1084          unsigned char **outdata, size_t *outdatalen )
1085 {
1086   static unsigned char sha1_prefix[15] = /* Object ID is 1.3.14.3.2.26 */
1087   { 0x30, 0x21, 0x30, 0x09, 0x06, 0x05, 0x2b, 0x0e, 0x03,
1088     0x02, 0x1a, 0x05, 0x00, 0x04, 0x14 };
1089   static unsigned char rmd160_prefix[15] = /* Object ID is 1.3.36.3.2.1 */
1090   { 0x30, 0x21, 0x30, 0x09, 0x06, 0x05, 0x2b, 0x24, 0x03,
1091     0x02, 0x01, 0x05, 0x00, 0x04, 0x14 };
1092   int rc;
1093   unsigned char data[35];
1094   unsigned char tmp_sn[20]; /* actually 16 but we use it also for the fpr. */
1095   const char *s;
1096   int n;
1097   const char *fpr = NULL;
1098   unsigned long sigcount;
1099
1100   if (!keyidstr || !*keyidstr)
1101     return gpg_error (GPG_ERR_INV_VALUE);
1102   if (indatalen != 20)
1103     return gpg_error (GPG_ERR_INV_VALUE);
1104
1105   /* Check whether an OpenPGP card of any version has been requested. */
1106   if (strlen (keyidstr) < 32 || strncmp (keyidstr, "D27600012401", 12))
1107     return gpg_error (GPG_ERR_INV_ID);
1108   
1109   for (s=keyidstr, n=0; hexdigitp (s); s++, n++)
1110     ;
1111   if (n != 32)
1112     return gpg_error (GPG_ERR_INV_ID);
1113   else if (!*s)
1114     ; /* no fingerprint given: we allow this for now. */
1115   else if (*s == '/')
1116     fpr = s + 1; 
1117   else
1118     return gpg_error (GPG_ERR_INV_ID);
1119
1120   for (s=keyidstr, n=0; n < 16; s += 2, n++)
1121     tmp_sn[n] = xtoi_2 (s);
1122
1123   if (app->serialnolen != 16)
1124     return gpg_error (GPG_ERR_INV_CARD);
1125   if (memcmp (app->serialno, tmp_sn, 16))
1126     return gpg_error (GPG_ERR_WRONG_CARD);
1127
1128   /* If a fingerprint has been specified check it against the one on
1129      the card.  This is allows for a meaningful error message in case
1130      the key on the card has been replaced but the shadow information
1131      known to gpg was not updated.  If there is no fingerprint, gpg
1132      will detect a bogus signature anyway due to the
1133      verify-after-signing feature. */
1134   rc = fpr? check_against_given_fingerprint (app, fpr, 1) : 0;
1135   if (rc)
1136     return rc;
1137
1138   if (hashalgo == GCRY_MD_SHA1)
1139     memcpy (data, sha1_prefix, 15);
1140   else if (hashalgo == GCRY_MD_RMD160)
1141     memcpy (data, rmd160_prefix, 15);
1142   else 
1143     return gpg_error (GPG_ERR_UNSUPPORTED_ALGORITHM);
1144   memcpy (data+15, indata, indatalen);
1145
1146   sigcount = get_sig_counter (app);
1147   log_info ("signatures created so far: %lu\n", sigcount);
1148
1149   if (!app->did_chv1 || app->force_chv1 ) 
1150     {
1151       char *pinvalue;
1152
1153       {
1154         char *prompt;
1155         if (asprintf (&prompt, "PIN [sigs done: %lu]", sigcount) < 0)
1156           return gpg_error_from_errno (errno);
1157         rc = pincb (pincb_arg, prompt, &pinvalue); 
1158         free (prompt);
1159       }
1160       if (rc)
1161         {
1162           log_info ("PIN callback returned error: %s\n", gpg_strerror (rc));
1163           return rc;
1164         }
1165
1166       if (strlen (pinvalue) < 6)
1167         {
1168           log_error ("prassphrase (CHV1) is too short; minimum length is 6\n");
1169           xfree (pinvalue);
1170           return gpg_error (GPG_ERR_BAD_PIN);
1171         }
1172
1173       rc = iso7816_verify (app->slot, 0x81, pinvalue, strlen (pinvalue));
1174       if (rc)
1175         {
1176           log_error ("verify CHV1 failed\n");
1177           xfree (pinvalue);
1178           flush_cache_after_error (app);
1179           return rc;
1180         }
1181       app->did_chv1 = 1;
1182       if (!app->did_chv2)
1183         {
1184           /* We should also verify CHV2. */
1185           rc = iso7816_verify (app->slot, 0x82, pinvalue, strlen (pinvalue));
1186           if (gpg_err_code (rc) == GPG_ERR_BAD_PIN)
1187             rc = gpg_error (GPG_ERR_PIN_NOT_SYNCED);
1188           if (rc)
1189             {
1190               log_error ("verify CHV2 failed\n");
1191               xfree (pinvalue);
1192               flush_cache_after_error (app);
1193               return rc;
1194             }
1195           app->did_chv2 = 1;
1196         }
1197       xfree (pinvalue);
1198     }
1199
1200   rc = iso7816_compute_ds (app->slot, data, 35, outdata, outdatalen);
1201   return rc;
1202 }
1203
1204 /* Compute a digital signature using the INTERNAL AUTHENTICATE command
1205    on INDATA which is expected to be the raw message digest. For this
1206    application the KEYIDSTR consists of the serialnumber and the
1207    fingerprint delimited by a slash.
1208
1209    Note that this fucntion may return the error code
1210    GPG_ERR_WRONG_CARD to indicate that the card currently present does
1211    not match the one required for the requested action (e.g. the
1212    serial number does not match). */
1213 static int 
1214 do_auth (APP app, const char *keyidstr,
1215          int (*pincb)(void*, const char *, char **),
1216          void *pincb_arg,
1217          const void *indata, size_t indatalen,
1218          unsigned char **outdata, size_t *outdatalen )
1219 {
1220   int rc;
1221   unsigned char tmp_sn[20]; /* actually 16 but we use it also for the fpr. */
1222   const char *s;
1223   int n;
1224   const char *fpr = NULL;
1225
1226   if (!keyidstr || !*keyidstr)
1227     return gpg_error (GPG_ERR_INV_VALUE);
1228   if (indatalen > 50) /* For a 1024 bit key. */
1229     return gpg_error (GPG_ERR_INV_VALUE);
1230
1231   /* Check whether an OpenPGP card of any version has been requested. */
1232   if (strlen (keyidstr) < 32 || strncmp (keyidstr, "D27600012401", 12))
1233     return gpg_error (GPG_ERR_INV_ID);
1234   
1235   for (s=keyidstr, n=0; hexdigitp (s); s++, n++)
1236     ;
1237   if (n != 32)
1238     return gpg_error (GPG_ERR_INV_ID);
1239   else if (!*s)
1240     ; /* no fingerprint given: we allow this for now. */
1241   else if (*s == '/')
1242     fpr = s + 1; 
1243   else
1244     return gpg_error (GPG_ERR_INV_ID);
1245
1246   for (s=keyidstr, n=0; n < 16; s += 2, n++)
1247     tmp_sn[n] = xtoi_2 (s);
1248
1249   if (app->serialnolen != 16)
1250     return gpg_error (GPG_ERR_INV_CARD);
1251   if (memcmp (app->serialno, tmp_sn, 16))
1252     return gpg_error (GPG_ERR_WRONG_CARD);
1253
1254   /* If a fingerprint has been specified check it against the one on
1255      the card.  This is allows for a meaningful error message in case
1256      the key on the card has been replaced but the shadow information
1257      known to gpg was not updated.  If there is no fingerprint, gpg
1258      will detect a bogus signature anyway due to the
1259      verify-after-signing feature. */
1260   rc = fpr? check_against_given_fingerprint (app, fpr, 3) : 0;
1261   if (rc)
1262     return rc;
1263
1264   rc = verify_chv2 (app, pincb, pincb_arg);
1265   if (!rc)
1266     rc = iso7816_internal_authenticate (app->slot, indata, indatalen,
1267                                         outdata, outdatalen);
1268   return rc;
1269 }
1270
1271
1272 static int 
1273 do_decipher (APP app, const char *keyidstr,
1274              int (pincb)(void*, const char *, char **),
1275              void *pincb_arg,
1276              const void *indata, size_t indatalen,
1277              unsigned char **outdata, size_t *outdatalen )
1278 {
1279   int rc;
1280   unsigned char tmp_sn[20]; /* actually 16 but we use it also for the fpr. */
1281   const char *s;
1282   int n;
1283   const char *fpr = NULL;
1284
1285   if (!keyidstr || !*keyidstr || !indatalen)
1286     return gpg_error (GPG_ERR_INV_VALUE);
1287
1288   /* Check whether an OpenPGP card of any version has been requested. */
1289   if (strlen (keyidstr) < 32 || strncmp (keyidstr, "D27600012401", 12))
1290     return gpg_error (GPG_ERR_INV_ID);
1291   
1292   for (s=keyidstr, n=0; hexdigitp (s); s++, n++)
1293     ;
1294   if (n != 32)
1295     return gpg_error (GPG_ERR_INV_ID);
1296   else if (!*s)
1297     ; /* no fingerprint given: we allow this for now. */
1298   else if (*s == '/')
1299     fpr = s + 1; 
1300   else
1301     return gpg_error (GPG_ERR_INV_ID);
1302
1303   for (s=keyidstr, n=0; n < 16; s += 2, n++)
1304     tmp_sn[n] = xtoi_2 (s);
1305
1306   if (app->serialnolen != 16)
1307     return gpg_error (GPG_ERR_INV_CARD);
1308   if (memcmp (app->serialno, tmp_sn, 16))
1309     return gpg_error (GPG_ERR_WRONG_CARD);
1310
1311   /* If a fingerprint has been specified check it against the one on
1312      the card.  This is allows for a meaningful error message in case
1313      the key on the card has been replaced but the shadow information
1314      known to gpg was not updated.  If there is no fingerprint, the
1315      decryption will won't produce the right plaintext anyway. */
1316   rc = fpr? check_against_given_fingerprint (app, fpr, 2) : 0;
1317   if (rc)
1318     return rc;
1319
1320   rc = verify_chv2 (app, pincb, pincb_arg);
1321   if (!rc)
1322     rc = iso7816_decipher (app->slot, indata, indatalen, 0,
1323                            outdata, outdatalen);
1324   return rc;
1325 }
1326
1327
1328 /* Perform a simple verify operation for CHV1 and CHV2, so that
1329    further operations won't ask for CHV2 and it is possible to do a
1330    cheap check on the PIN: If there is something wrong with the PIN
1331    entry system, only the regular CHV will get blocked and not the
1332    dangerous CHV3.  KEYIDSTR is the usual card's serial number; an
1333    optional fingerprint part will be ignored. */
1334 static int 
1335 do_check_pin (APP app, const char *keyidstr,
1336               int (pincb)(void*, const char *, char **),
1337               void *pincb_arg)
1338 {
1339   unsigned char tmp_sn[20]; 
1340   const char *s;
1341   int n;
1342
1343   if (!keyidstr || !*keyidstr)
1344     return gpg_error (GPG_ERR_INV_VALUE);
1345
1346   /* Check whether an OpenPGP card of any version has been requested. */
1347   if (strlen (keyidstr) < 32 || strncmp (keyidstr, "D27600012401", 12))
1348     return gpg_error (GPG_ERR_INV_ID);
1349   
1350   for (s=keyidstr, n=0; hexdigitp (s); s++, n++)
1351     ;
1352   if (n != 32)
1353     return gpg_error (GPG_ERR_INV_ID);
1354   else if (!*s)
1355     ; /* No fingerprint given: we allow this for now. */
1356   else if (*s == '/')
1357     ; /* We ignore a fingerprint. */
1358   else
1359     return gpg_error (GPG_ERR_INV_ID);
1360
1361   for (s=keyidstr, n=0; n < 16; s += 2, n++)
1362     tmp_sn[n] = xtoi_2 (s);
1363
1364   if (app->serialnolen != 16)
1365     return gpg_error (GPG_ERR_INV_CARD);
1366   if (memcmp (app->serialno, tmp_sn, 16))
1367     return gpg_error (GPG_ERR_WRONG_CARD);
1368   /* Yes, there is a race conditions: The user might pull the card
1369      right here and we won't notice that.  However this is not a
1370      problem and the check above is merely for a graceful failure
1371      between operations. */
1372
1373   return verify_chv2 (app, pincb, pincb_arg);
1374 }
1375
1376
1377
1378
1379 /* Select the OpenPGP application on the card in SLOT.  This function
1380    must be used before any other OpenPGP application functions. */
1381 int
1382 app_select_openpgp (APP app)
1383 {
1384   static char const aid[] = { 0xD2, 0x76, 0x00, 0x01, 0x24, 0x01 };
1385   int slot = app->slot;
1386   int rc;
1387   unsigned char *buffer;
1388   size_t buflen;
1389   void *relptr;
1390   
1391   rc = iso7816_select_application (slot, aid, sizeof aid);
1392   if (!rc)
1393     {
1394       unsigned int manufacturer;
1395
1396       app->apptype = "OPENPGP";
1397
1398       app->did_chv1 = 0;
1399       app->did_chv2 = 0;
1400       app->did_chv3 = 0;
1401       app->app_local = NULL;
1402
1403       /* The OpenPGP card returns the serial number as part of the
1404          AID; because we prefer to use OpenPGP serial numbers, we
1405          replace a possibly already set one from a EF.GDO with this
1406          one.  Note, that for current OpenPGP cards, no EF.GDO exists
1407          and thus it won't matter at all. */
1408       rc = iso7816_get_data (slot, 0x004F, &buffer, &buflen);
1409       if (rc)
1410         goto leave;
1411       if (opt.verbose)
1412         {
1413           log_info ("got AID: ");
1414           log_printhex ("", buffer, buflen);
1415         }
1416
1417       app->card_version = buffer[6] << 8;
1418       app->card_version |= buffer[7];
1419       manufacturer = (buffer[8]<<8 | buffer[9]);
1420
1421       xfree (app->serialno);
1422       app->serialno = buffer;
1423       app->serialnolen = buflen;
1424       buffer = NULL;
1425       app->app_local = xtrycalloc (1, sizeof *app->app_local);
1426       if (!app->app_local)
1427         {
1428           rc = gpg_error (gpg_err_code_from_errno (errno));
1429           goto leave;
1430         }
1431
1432       relptr = get_one_do (app, 0x00C4, &buffer, &buflen);
1433       if (!relptr)
1434         {
1435           log_error ("can't access CHV Status Bytes - invalid OpenPGP card?\n");
1436           goto leave;
1437         }
1438       app->force_chv1 = (buflen && *buffer == 0);
1439       xfree (relptr);
1440
1441       relptr = get_one_do (app, 0x00C0, &buffer, &buflen);
1442       if (!relptr)
1443         {
1444           log_error ("can't access Extended Capability Flags - "
1445                      "invalid OpenPGP card?\n");
1446           goto leave;
1447         }
1448       if (buflen)
1449         {
1450           app->app_local->extcap.get_challenge    = !!(*buffer & 0x40);
1451           app->app_local->extcap.key_import       = !!(*buffer & 0x20);
1452           app->app_local->extcap.change_force_chv = !!(*buffer & 0x10);
1453           app->app_local->extcap.private_dos      = !!(*buffer & 0x08);
1454         }
1455       xfree (relptr);
1456       
1457       /* Some of the first cards accidently don't set the
1458          CHANGE_FORCE_CHV bit but allow it anyway. */
1459       if (app->card_version <= 0x0100 && manufacturer == 1)
1460         app->app_local->extcap.change_force_chv = 1;
1461
1462
1463       if (opt.verbose > 1)
1464         dump_all_do (slot);
1465
1466       app->fnc.deinit = do_deinit;
1467       app->fnc.learn_status = do_learn_status;
1468       app->fnc.readcert = NULL;
1469       app->fnc.getattr = do_getattr;
1470       app->fnc.setattr = do_setattr;
1471       app->fnc.genkey = do_genkey;
1472       app->fnc.sign = do_sign;
1473       app->fnc.auth = do_auth;
1474       app->fnc.decipher = do_decipher;
1475       app->fnc.change_pin = do_change_pin;
1476       app->fnc.check_pin = do_check_pin;
1477    }
1478
1479 leave:
1480   if (rc)
1481     do_deinit (app);
1482   return rc;
1483 }
1484
1485
1486
1487 /* This function is a hack to retrieve essential information about the
1488    card to be displayed by simple tools.  It mostly resembles what the
1489    LEARN command returns. All parameters return allocated strings or
1490    buffers or NULL if the data object is not available.  All returned
1491    values are sanitized. */
1492 int
1493 app_openpgp_cardinfo (APP app,
1494                       char **serialno,
1495                       char **disp_name,
1496                       char **pubkey_url,
1497                       unsigned char **fpr1,
1498                       unsigned char **fpr2,
1499                       unsigned char **fpr3)
1500 {
1501   int rc;
1502   void *relptr;
1503   unsigned char *value;
1504   size_t valuelen;
1505
1506   if (serialno)
1507     {
1508       time_t dummy;
1509
1510       *serialno = NULL;
1511       rc = app_get_serial_and_stamp (app, serialno, &dummy);
1512       if (rc)
1513         {
1514           log_error ("error getting serial number: %s\n", gpg_strerror (rc));
1515           return rc;
1516         }
1517     }
1518       
1519   if (disp_name)
1520     {
1521       *disp_name = NULL;
1522       relptr = get_one_do (app, 0x005B, &value, &valuelen);
1523       if (relptr)
1524         {
1525           *disp_name = make_printable_string (value, valuelen, 0);
1526           xfree (relptr);
1527         }
1528     }
1529
1530   if (pubkey_url)
1531     {
1532       *pubkey_url = NULL;
1533       relptr = get_one_do (app, 0x5F50, &value, &valuelen);
1534       if (relptr)
1535         {
1536           *pubkey_url = make_printable_string (value, valuelen, 0);
1537           xfree (relptr);
1538         }
1539     }
1540
1541   if (fpr1)
1542     *fpr1 = NULL;
1543   if (fpr2)
1544     *fpr2 = NULL;
1545   if (fpr3)
1546     *fpr3 = NULL;
1547   relptr = get_one_do (app, 0x00C5, &value, &valuelen);
1548   if (relptr && valuelen >= 60)
1549     {
1550       if (fpr1)
1551         {
1552           *fpr1 = xmalloc (20);
1553           memcpy (*fpr1, value +  0, 20);
1554         }
1555       if (fpr2)
1556         {
1557           *fpr2 = xmalloc (20);
1558           memcpy (*fpr2, value + 20, 20);
1559         }
1560       if (fpr3)
1561         {
1562           *fpr3 = xmalloc (20);
1563           memcpy (*fpr3, value + 40, 20);
1564         }
1565     }
1566   xfree (relptr);
1567
1568   return 0;
1569 }
1570
1571
1572
1573 /* This function is currently only used by the sc-copykeys program to
1574    store a key on the smartcard.  APP ist the application handle,
1575    KEYNO is the number of the key and PINCB, PINCB_ARG are used to ask
1576    for the SO PIN.  TEMPLATE and TEMPLATE_LEN describe a buffer with
1577    the key template to store. CREATED_AT is the timestamp used to
1578    create the fingerprint. M, MLEN is the RSA modulus and E, ELEN the
1579    RSA public exponent. This function silently overwrites an existing
1580    key.*/
1581 int 
1582 app_openpgp_storekey (APP app, int keyno,
1583                       unsigned char *template, size_t template_len,
1584                       time_t created_at,
1585                       const unsigned char *m, size_t mlen,
1586                       const unsigned char *e, size_t elen,
1587                       int (*pincb)(void*, const char *, char **),
1588                       void *pincb_arg)
1589 {
1590   int rc;
1591   unsigned char fprbuf[20];
1592
1593   if (keyno < 1 || keyno > 3)
1594     return gpg_error (GPG_ERR_INV_ID);
1595   keyno--;
1596
1597   rc = verify_chv3 (app, pincb, pincb_arg);
1598   if (rc)
1599     goto leave;
1600
1601   flush_cache (app);
1602
1603   rc = iso7816_put_data (app->slot,
1604                          (app->card_version > 0x0007? 0xE0 : 0xE9) + keyno,
1605                          template, template_len);
1606   if (rc)
1607     {
1608       log_error ("failed to store the key: rc=%s\n", gpg_strerror (rc));
1609       rc = gpg_error (GPG_ERR_CARD);
1610       goto leave;
1611     }
1612  
1613 /*    log_printhex ("RSA n:", m, mlen);  */
1614 /*    log_printhex ("RSA e:", e, elen);  */
1615
1616   rc = store_fpr (app->slot, keyno, (u32)created_at,
1617                   m, mlen, e, elen, fprbuf, app->card_version);
1618
1619  leave:
1620   return rc;
1621 }
1622
1623
1624 /* Utility function for external tools: Read the public RSA key at
1625    KEYNO and return modulus and exponent in (M,MLEN) and (E,ELEN). */
1626 int 
1627 app_openpgp_readkey (APP app, int keyno, unsigned char **m, size_t *mlen,
1628                      unsigned char **e, size_t *elen)
1629 {
1630   int rc;
1631   const unsigned char *keydata, *a;
1632   unsigned char *buffer;
1633   size_t buflen, keydatalen, alen;
1634
1635   *m = NULL;
1636   *e = NULL;
1637
1638   if (keyno < 1 || keyno > 3)
1639     return gpg_error (GPG_ERR_INV_ID);
1640   keyno--;
1641
1642   rc = iso7816_read_public_key(app->slot, 
1643                                keyno == 0? "\xB6" :
1644                                keyno == 1? "\xB8" : "\xA4",
1645                                2,
1646                                &buffer, &buflen);
1647   if (rc)
1648     {
1649       rc = gpg_error (GPG_ERR_CARD);
1650       log_error ("reading key failed\n");
1651       goto leave;
1652     }
1653
1654   keydata = find_tlv (buffer, buflen, 0x7F49, &keydatalen);
1655   if (!keydata)
1656     {
1657       log_error ("response does not contain the public key data\n");
1658       rc = gpg_error (GPG_ERR_CARD);
1659       goto leave;
1660     }
1661  
1662   a = find_tlv (keydata, keydatalen, 0x0081, &alen);
1663   if (!a)
1664     {
1665       log_error ("response does not contain the RSA modulus\n");
1666       rc = gpg_error (GPG_ERR_CARD);
1667       goto leave;
1668     }
1669   *mlen = alen;
1670   *m = xmalloc (alen);
1671   memcpy (*m, a, alen);
1672   
1673   a = find_tlv (keydata, keydatalen, 0x0082, &alen);
1674   if (!a)
1675     {
1676       log_error ("response does not contain the RSA public exponent\n");
1677       rc = gpg_error (GPG_ERR_CARD);
1678       goto leave;
1679     }
1680   *elen = alen;
1681   *e = xmalloc (alen);
1682   memcpy (*e, a, alen);
1683
1684  leave:
1685   xfree (buffer);
1686   if (rc)
1687     { 
1688       xfree (*m); *m = NULL;
1689       xfree (*e); *e = NULL;
1690     }
1691   return rc;
1692 }