8d146ba6a2b786735d835326eaa0b08f1ad3d517
[gnupg.git] / scd / app-openpgp.c
1 /* app-openpgp.c - The OpenPGP card application.
2  *      Copyright (C) 2003, 2004, 2005 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  * $Id$
21  */
22
23 #include <config.h>
24 #include <errno.h>
25 #include <stdio.h>
26 #include <stdlib.h>
27 #include <string.h>
28 #include <assert.h>
29 #include <time.h>
30
31 #if GNUPG_MAJOR_VERSION == 1
32 /* This is used with GnuPG version < 1.9.  The code has been source
33    copied from the current GnuPG >= 1.9  and is maintained over
34    there. */
35 #include "options.h"
36 #include "errors.h"
37 #include "memory.h"
38 #include "util.h"
39 #include "cardglue.h"
40 #else /* GNUPG_MAJOR_VERSION != 1 */
41 #include "scdaemon.h"
42 #endif /* GNUPG_MAJOR_VERSION != 1 */
43
44 #include "i18n.h"
45 #include "iso7816.h"
46 #include "app-common.h"
47 #include "tlv.h"
48
49
50 static struct {
51   int tag;
52   int constructed;
53   int get_from;  /* Constructed DO with this DO or 0 for direct access. */
54   int binary;
55   int dont_cache;
56   int flush_on_error;
57   int get_immediate_in_v11; /* Enable a hack to bypass the cache of
58                                this data object if it is used in 1.1
59                                and later versions of the card.  This
60                                does not work with composite DO and is
61                                currently only useful for the CHV
62                                status bytes. */
63   char *desc;
64 } data_objects[] = {
65   { 0x005E, 0,    0, 1, 0, 0, 0, "Login Data" },
66   { 0x5F50, 0,    0, 0, 0, 0, 0, "URL" },
67   { 0x0065, 1,    0, 1, 0, 0, 0, "Cardholder Related Data"},
68   { 0x005B, 0, 0x65, 0, 0, 0, 0, "Name" },
69   { 0x5F2D, 0, 0x65, 0, 0, 0, 0, "Language preferences" },
70   { 0x5F35, 0, 0x65, 0, 0, 0, 0, "Sex" },
71   { 0x006E, 1,    0, 1, 0, 0, 0, "Application Related Data" },
72   { 0x004F, 0, 0x6E, 1, 0, 0, 0, "AID" },
73   { 0x0073, 1,    0, 1, 0, 0, 0, "Discretionary Data Objects" },
74   { 0x0047, 0, 0x6E, 1, 1, 0, 0, "Card Capabilities" },
75   { 0x00C0, 0, 0x6E, 1, 1, 0, 0, "Extended Card Capabilities" },
76   { 0x00C1, 0, 0x6E, 1, 1, 0, 0, "Algorithm Attributes Signature" },
77   { 0x00C2, 0, 0x6E, 1, 1, 0, 0, "Algorithm Attributes Decryption" },
78   { 0x00C3, 0, 0x6E, 1, 1, 0, 0, "Algorithm Attributes Authentication" },
79   { 0x00C4, 0, 0x6E, 1, 0, 1, 1, "CHV Status Bytes" },
80   { 0x00C5, 0, 0x6E, 1, 0, 0, 0, "Fingerprints" },
81   { 0x00C6, 0, 0x6E, 1, 0, 0, 0, "CA Fingerprints" },
82   { 0x00CD, 0, 0x6E, 1, 0, 0, 0, "Generation time" },
83   { 0x007A, 1,    0, 1, 0, 0, 0, "Security Support Template" },
84   { 0x0093, 0, 0x7A, 1, 1, 0, 0, "Digital Signature Counter" },
85   { 0x0101, 0,    0, 0, 0, 0, 0, "Private DO 1"},
86   { 0x0102, 0,    0, 0, 0, 0, 0, "Private DO 2"},
87   { 0x0103, 0,    0, 0, 0, 0, 0, "Private DO 3"},
88   { 0x0104, 0,    0, 0, 0, 0, 0, "Private DO 4"},
89   { 0 }
90 };
91
92
93 /* One cache item for DOs.  */
94 struct cache_s {
95   struct cache_s *next;
96   int tag;
97   size_t length;
98   unsigned char data[1];
99 };
100
101
102 /* Object with application (i.e. OpenPGP card) specific data.  */
103 struct app_local_s {
104   /* A linked list with cached DOs.  */
105   struct cache_s *cache;
106   
107   /* Keep track of the public keys.  */
108   struct
109   {
110     int read_done;   /* True if we have at least tried to read them.  */
111     gcry_sexp_t key; /* Might be NULL if key is not available.  */
112   } pk[3];
113
114   /* Keep track of card capabilities.  */
115   struct 
116   {
117     unsigned int get_challenge:1;
118     unsigned int key_import:1;
119     unsigned int change_force_chv:1;
120     unsigned int private_dos:1;
121   } extcap;
122
123   /* Flags used to control the application.  */
124   struct
125   {
126     unsigned int no_sync:1;   /* Do not sync CHV1 and CHV2 */
127     unsigned int def_chv2:1;  /* Use 123456 for CHV2.  */
128   } flags;
129 };
130
131
132
133 /***** Local prototypes  *****/
134 static unsigned long convert_sig_counter_value (const unsigned char *value,
135                                                 size_t valuelen);
136 static unsigned long get_sig_counter (app_t app);
137
138
139
140
141 \f
142 /* Deconstructor. */
143 static void
144 do_deinit (app_t app)
145 {
146   if (app && app->app_local)
147     {
148       struct cache_s *c, *c2;
149       int i;
150
151       for (c = app->app_local->cache; c; c = c2)
152         {
153           c2 = c->next;
154           xfree (c);
155         }
156
157       for (i=0; i < DIM (app->app_local->pk); i++)
158         {
159           gcry_sexp_release (app->app_local->pk[i].key);
160           app->app_local->pk[i].read_done = 0;
161         }
162       xfree (app->app_local);
163       app->app_local = NULL;
164     }
165 }
166
167
168 /* Wrapper around iso7816_get_data which first tries to get the data
169    from the cache.  With GET_IMMEDIATE passed as true, the cache is
170    bypassed. */
171 static gpg_error_t
172 get_cached_data (app_t app, int tag, 
173                  unsigned char **result, size_t *resultlen,
174                  int get_immediate)
175 {
176   gpg_error_t err;
177   int i;
178   unsigned char *p;
179   size_t len;
180   struct cache_s *c;
181
182   *result = NULL;
183   *resultlen = 0;
184
185   if (!get_immediate)
186     {
187       for (c=app->app_local->cache; c; c = c->next)
188         if (c->tag == tag)
189           {
190             if(c->length)
191               {
192                 p = xtrymalloc (c->length);
193                 if (!p)
194                   return gpg_error (gpg_err_code_from_errno (errno));
195                 memcpy (p, c->data, c->length);
196                 *result = p;
197               }
198             
199             *resultlen = c->length;
200             
201             return 0;
202           }
203     }
204   
205   err = iso7816_get_data (app->slot, tag, &p, &len);
206   if (err)
207     return err;
208   *result = p;
209   *resultlen = len;
210
211   /* Check whether we should cache this object. */
212   if (get_immediate)
213     return 0;
214
215   for (i=0; data_objects[i].tag; i++)
216     if (data_objects[i].tag == tag)
217       {
218         if (data_objects[i].dont_cache)
219           return 0;
220         break;
221       }
222
223   /* Okay, cache it. */
224   for (c=app->app_local->cache; c; c = c->next)
225     assert (c->tag != tag);
226   
227   c = xtrymalloc (sizeof *c + len);
228   if (c)
229     {
230       memcpy (c->data, p, len);
231       c->length = len;
232       c->tag = tag;
233       c->next = app->app_local->cache;
234       app->app_local->cache = c;
235     }
236
237   return 0;
238 }
239
240 /* Remove DO at TAG from the cache. */
241 static void
242 flush_cache_item (app_t app, int tag)
243 {
244   struct cache_s *c, *cprev;
245   int i;
246
247   if (!app->app_local)
248     return;
249
250   for (c=app->app_local->cache, cprev=NULL; c ; cprev=c, c = c->next)
251     if (c->tag == tag)
252       {
253         if (cprev)
254           cprev->next = c->next;
255         else
256           app->app_local->cache = c->next;
257         xfree (c);
258
259         for (c=app->app_local->cache; c ; c = c->next)
260           {
261             assert (c->tag != tag); /* Oops: duplicated entry. */
262           }
263         return;
264       }
265
266   /* Try again if we have an outer tag. */
267   for (i=0; data_objects[i].tag; i++)
268     if (data_objects[i].tag == tag && data_objects[i].get_from
269         && data_objects[i].get_from != tag)
270       flush_cache_item (app, data_objects[i].get_from);
271 }
272
273 /* Flush all entries from the cache which might be out of sync after
274    an error. */
275 static void
276 flush_cache_after_error (app_t app)
277 {
278   int i;
279
280   for (i=0; data_objects[i].tag; i++)
281     if (data_objects[i].flush_on_error)
282       flush_cache_item (app, data_objects[i].tag);
283 }
284
285
286 /* Flush the entire cache. */
287 static void
288 flush_cache (app_t app)
289 {
290   if (app && app->app_local)
291     {
292       struct cache_s *c, *c2;
293
294       for (c = app->app_local->cache; c; c = c2)
295         {
296           c2 = c->next;
297           xfree (c);
298         }
299       app->app_local->cache = NULL;
300     }
301 }
302
303
304 /* Get the DO identified by TAG from the card in SLOT and return a
305    buffer with its content in RESULT and NBYTES.  The return value is
306    NULL if not found or a pointer which must be used to release the
307    buffer holding value. */
308 static void *
309 get_one_do (app_t app, int tag, unsigned char **result, size_t *nbytes)
310 {
311   int rc, i;
312   unsigned char *buffer;
313   size_t buflen;
314   unsigned char *value;
315   size_t valuelen;
316
317   *result = NULL;
318   *nbytes = 0;
319   for (i=0; data_objects[i].tag && data_objects[i].tag != tag; i++)
320     ;
321
322   if (app->card_version > 0x0100 && data_objects[i].get_immediate_in_v11)
323     {
324       if( iso7816_get_data (app->slot, tag, &buffer, &buflen))
325         return NULL;
326       *result = buffer;
327       *nbytes = buflen;
328       return buffer;
329     }
330
331   value = NULL;
332   rc = -1;
333   if (data_objects[i].tag && data_objects[i].get_from)
334     {
335       rc = get_cached_data (app, data_objects[i].get_from,
336                             &buffer, &buflen,
337                             data_objects[i].get_immediate_in_v11);
338       if (!rc)
339         {
340           const unsigned char *s;
341
342           s = find_tlv (buffer, buflen, tag, &valuelen);
343           if (!s)
344             value = NULL; /* not found */
345           else if (valuelen > buflen - (s - buffer))
346             {
347               log_error ("warning: constructed DO too short\n");
348               value = NULL;
349               xfree (buffer); buffer = NULL;
350             }
351           else
352             value = buffer + (s - buffer);
353         }
354     }
355
356   if (!value) /* Not in a constructed DO, try simple. */
357     {
358       rc = get_cached_data (app, tag, &buffer, &buflen,
359                             data_objects[i].get_immediate_in_v11);
360       if (!rc)
361         {
362           value = buffer;
363           valuelen = buflen;
364         }
365     }
366
367   if (!rc)
368     {
369       *nbytes = valuelen;
370       *result = value;
371       return buffer;
372     }
373   return NULL;
374 }
375
376
377 static void
378 dump_all_do (int slot)
379 {
380   int rc, i, j;
381   unsigned char *buffer;
382   size_t buflen;
383   
384   for (i=0; data_objects[i].tag; i++)
385     {
386       if (data_objects[i].get_from)
387         continue;
388
389       rc = iso7816_get_data (slot, data_objects[i].tag, &buffer, &buflen);
390       if (gpg_err_code (rc) == GPG_ERR_NO_OBJ)
391         ;
392       else if (rc) 
393         log_info ("DO `%s' not available: %s\n",
394                   data_objects[i].desc, gpg_strerror (rc));
395       else
396         {
397           if (data_objects[i].binary)
398             {
399               log_info ("DO `%s': ", data_objects[i].desc);
400               log_printhex ("", buffer, buflen);
401             }
402           else
403             log_info ("DO `%s': `%.*s'\n",
404                       data_objects[i].desc,
405                       (int)buflen, buffer); /* FIXME: sanitize */
406
407           if (data_objects[i].constructed)
408             {
409               for (j=0; data_objects[j].tag; j++)
410                 {
411                   const unsigned char *value;
412                   size_t valuelen;
413                   
414                   if (j==i || data_objects[i].tag != data_objects[j].get_from)
415                     continue;
416                   value = find_tlv (buffer, buflen,
417                                     data_objects[j].tag, &valuelen);
418                   if (!value)
419                     ; /* not found */
420                   else if (valuelen > buflen - (value - buffer))
421                     log_error ("warning: constructed DO too short\n");
422                   else
423                     {
424                       if (data_objects[j].binary)
425                         {
426                           log_info ("DO `%s': ", data_objects[j].desc);
427                           log_printhex ("", value, valuelen);
428                         }
429                       else
430                         log_info ("DO `%s': `%.*s'\n",
431                                   data_objects[j].desc,
432                                   (int)valuelen, value); /* FIXME: sanitize */
433                     }
434                 }
435             }
436         }
437       xfree (buffer); buffer = NULL;
438     }
439 }
440
441
442 /* Count the number of bits, assuming the A represents an unsigned big
443    integer of length LEN bytes. */
444 static unsigned int
445 count_bits (const unsigned char *a, size_t len)
446 {
447   unsigned int n = len * 8;
448   int i;
449
450   for (; len && !*a; len--, a++, n -=8)
451     ;
452   if (len)
453     {
454       for (i=7; i && !(*a & (1<<i)); i--)
455         n--;
456     }
457   return n;
458 }
459
460 /* GnuPG makes special use of the login-data DO, this fucntion parses
461    the login data to store the flags for later use.  It may be called
462    at any time and should be called after changing the login-data DO.
463
464    Everything up to a LF is considered a mailbox or account name.  If
465    the first LF is followed by DC4 (0x14) control sequence are
466    expected up to the next LF.  Control sequences are separated by FS
467    (0x28) and consist of key=value pairs.  There is one key defined:
468
469     F=<flags>
470
471     Were FLAGS is a plain hexadecimal number representing flag values.
472     The lsb is here the rightmost bit.  Defined flags bits are:
473
474       Bit 0 = CHV1 and CHV2 are not syncronized
475       Bit 1 = CHV2 has been been set to the default PIN of "123456"
476               (this implies that bit 0 is also set).
477
478 */
479 static void
480 parse_login_data (app_t app)
481 {
482   unsigned char *buffer, *p;
483   size_t buflen, len;
484   void *relptr;
485
486   /* Set defaults.  */
487   app->app_local->flags.no_sync = 0;
488   app->app_local->flags.def_chv2 = 0;
489
490   /* Read the DO.  */
491   relptr = get_one_do (app, 0x005E, &buffer, &buflen);
492   if (!relptr)
493     return; /* Ooops. */
494   for (; buflen; buflen--, buffer++)
495     if (*buffer == '\n')
496       break;
497   if (buflen < 2 || buffer[1] != '\x14')
498     return; /* No control sequences.  */
499   buflen--;
500   buffer++;
501   do
502     {
503       buflen--;
504       buffer++;
505       if (buflen > 1 && *buffer == 'F' && buffer[1] == '=')
506         {
507           /* Flags control sequence found.  */
508           int lastdig = 0;
509
510           /* For now we are only interested in the last digit, so skip
511              any leading digits but bail out on invalid characters. */
512           for (p=buffer+2, len = buflen-2; len && hexdigitp (p); p++, len--)
513             lastdig = xtoi_1 (p);
514           if (len && !(*p == '\n' || *p == '\x18'))
515             goto next;  /* Invalid characters in field.  */
516           app->app_local->flags.no_sync = !!(lastdig & 1);
517           app->app_local->flags.def_chv2 = (lastdig & 3) == 3;
518         }
519     next:
520       for (; buflen && *buffer != '\x18'; buflen--, buffer++)
521         if (*buffer == '\n')
522           buflen = 1; 
523     }
524   while (buflen);
525
526   xfree (relptr);
527 }
528
529 /* Note, that FPR must be at least 20 bytes. */
530 static int 
531 store_fpr (int slot, int keynumber, u32 timestamp,
532            const unsigned char *m, size_t mlen,
533            const unsigned char *e, size_t elen, 
534            unsigned char *fpr, unsigned int card_version)
535 {
536   unsigned int n, nbits;
537   unsigned char *buffer, *p;
538   int rc;
539   
540   for (; mlen && !*m; mlen--, m++) /* strip leading zeroes */
541     ;
542   for (; elen && !*e; elen--, e++) /* strip leading zeroes */
543     ;
544
545   n = 6 + 2 + mlen + 2 + elen;
546   p = buffer = xtrymalloc (3 + n);
547   if (!buffer)
548     return gpg_error (gpg_err_code_from_errno (errno));
549   
550   *p++ = 0x99;     /* ctb */
551   *p++ = n >> 8;   /* 2 byte length header */
552   *p++ = n;
553   *p++ = 4;        /* key packet version */
554   *p++ = timestamp >> 24;
555   *p++ = timestamp >> 16;
556   *p++ = timestamp >>  8;
557   *p++ = timestamp;
558   *p++ = 1; /* RSA */
559   nbits = count_bits (m, mlen);
560   *p++ = nbits >> 8;
561   *p++ = nbits;
562   memcpy (p, m, mlen); p += mlen;
563   nbits = count_bits (e, elen);
564   *p++ = nbits >> 8;
565   *p++ = nbits;
566   memcpy (p, e, elen); p += elen;
567     
568   gcry_md_hash_buffer (GCRY_MD_SHA1, fpr, buffer, n+3);
569
570   xfree (buffer);
571
572   rc = iso7816_put_data (slot, (card_version > 0x0007? 0xC7 : 0xC6)
573                                + keynumber, fpr, 20);
574   if (rc)
575     log_error (_("failed to store the fingerprint: %s\n"),gpg_strerror (rc));
576
577   if (!rc && card_version > 0x0100)
578     {
579       unsigned char buf[4];
580
581       buf[0] = timestamp >> 24;
582       buf[1] = timestamp >> 16;
583       buf[2] = timestamp >>  8;
584       buf[3] = timestamp;
585
586       rc = iso7816_put_data (slot, 0xCE + keynumber, buf, 4);
587       if (rc)
588         log_error (_("failed to store the creation date: %s\n"),
589                    gpg_strerror (rc));
590     }
591
592   return rc;
593 }
594
595        
596 static void
597 send_fpr_if_not_null (ctrl_t ctrl, const char *keyword,
598                       int number, const unsigned char *fpr)
599 {                      
600   int i;
601   char buf[41];
602   char numbuf[25];
603
604   for (i=0; i < 20 && !fpr[i]; i++)
605     ;
606   if (i==20)
607     return; /* All zero. */
608   for (i=0; i< 20; i++)
609     sprintf (buf+2*i, "%02X", fpr[i]);
610   if (number == -1)
611     *numbuf = 0; /* Don't print the key number */
612   else
613     sprintf (numbuf, "%d", number);
614   send_status_info (ctrl, keyword,
615                     numbuf, (size_t)strlen(numbuf),
616                     buf, (size_t)strlen (buf), NULL, 0);
617 }
618
619 static void
620 send_fprtime_if_not_null (ctrl_t ctrl, const char *keyword,
621                           int number, const unsigned char *stamp)
622 {                      
623   char numbuf1[50], numbuf2[50];
624   unsigned long value;
625
626   value = (stamp[0] << 24) | (stamp[1]<<16) | (stamp[2]<<8) | stamp[3];
627   if (!value)
628     return;
629   sprintf (numbuf1, "%d", number);
630   sprintf (numbuf2, "%lu", value);
631   send_status_info (ctrl, keyword,
632                     numbuf1, (size_t)strlen(numbuf1),
633                     numbuf2, (size_t)strlen(numbuf2), NULL, 0);
634 }
635
636 static void
637 send_key_data (ctrl_t ctrl, const char *name, 
638                const unsigned char *a, size_t alen)
639 {
640   char *p, *buf = xmalloc (alen*2+1);
641   
642   for (p=buf; alen; a++, alen--, p += 2)
643     sprintf (p, "%02X", *a);
644
645   send_status_info (ctrl, "KEY-DATA",
646                     name, (size_t)strlen(name), 
647                     buf, (size_t)strlen (buf),
648                     NULL, 0);
649   xfree (buf);
650 }
651
652 /* Implement the GETATTR command.  This is similar to the LEARN
653    command but returns just one value via the status interface. */
654 static int 
655 do_getattr (app_t app, ctrl_t ctrl, const char *name)
656 {
657   static struct {
658     const char *name;
659     int tag;
660     int special;
661   } table[] = {
662     { "DISP-NAME",    0x005B },
663     { "LOGIN-DATA",   0x005E },
664     { "DISP-LANG",    0x5F2D },
665     { "DISP-SEX",     0x5F35 },
666     { "PUBKEY-URL",   0x5F50 },
667     { "KEY-FPR",      0x00C5, 3 },
668     { "KEY-TIME",     0x00CD, 4 },
669     { "CA-FPR",       0x00C6, 3 },
670     { "CHV-STATUS",   0x00C4, 1 }, 
671     { "SIG-COUNTER",  0x0093, 2 },
672     { "SERIALNO",     0x004F, -1 },
673     { "AID",          0x004F },
674     { "EXTCAP",       0x0000, -2 },
675     { "PRIVATE-DO-1", 0x0101 },
676     { "PRIVATE-DO-2", 0x0102 },
677     { "PRIVATE-DO-3", 0x0103 },
678     { "PRIVATE-DO-4", 0x0104 },
679     { NULL, 0 }
680   };
681   int idx, i;
682   void *relptr;
683   unsigned char *value;
684   size_t valuelen;
685
686   for (idx=0; table[idx].name && strcmp (table[idx].name, name); idx++)
687     ;
688   if (!table[idx].name)
689     return gpg_error (GPG_ERR_INV_NAME); 
690   
691   if (table[idx].special == -1)
692     {
693       /* The serial number is very special.  We could have used the
694          AID DO to retrieve it, but we have it already in the app
695          context and the stamp argument is required anyway which we
696          can't by other means. The AID DO is available anyway but not
697          hex formatted. */
698       char *serial;
699       time_t stamp;
700       char tmp[50];
701
702       if (!app_get_serial_and_stamp (app, &serial, &stamp))
703         {
704           sprintf (tmp, "%lu", (unsigned long)stamp);
705           send_status_info (ctrl, "SERIALNO",
706                             serial, strlen (serial),
707                             tmp, strlen (tmp),
708                             NULL, 0);
709           xfree (serial);
710         }
711       return 0;
712     }
713   if (table[idx].special == -2)
714     {
715       char tmp[50];
716
717       sprintf (tmp, "gc=%d ki=%d fc=%d pd=%d", 
718                app->app_local->extcap.get_challenge,
719                app->app_local->extcap.key_import,
720                app->app_local->extcap.change_force_chv,
721                app->app_local->extcap.private_dos);
722       send_status_info (ctrl, table[idx].name, tmp, strlen (tmp), NULL, 0);
723       return 0;
724     }
725
726   relptr = get_one_do (app, table[idx].tag, &value, &valuelen);
727   if (relptr)
728     {
729       if (table[idx].special == 1)
730         {
731           char numbuf[7*23];
732           
733           for (i=0,*numbuf=0; i < valuelen && i < 7; i++)
734             sprintf (numbuf+strlen (numbuf), " %d", value[i]); 
735           send_status_info (ctrl, table[idx].name,
736                             numbuf, strlen (numbuf), NULL, 0);
737         }
738       else if (table[idx].special == 2)
739         {
740           char numbuf[50];
741
742           sprintf (numbuf, "%lu", convert_sig_counter_value (value, valuelen));
743           send_status_info (ctrl, table[idx].name,
744                             numbuf, strlen (numbuf), NULL, 0);
745         }
746       else if (table[idx].special == 3)
747         {
748           if (valuelen >= 60)
749             for (i=0; i < 3; i++)
750               send_fpr_if_not_null (ctrl, table[idx].name, i+1, value+i*20);
751         }
752       else if (table[idx].special == 4)
753         {
754           if (valuelen >= 12)
755             for (i=0; i < 3; i++)
756               send_fprtime_if_not_null (ctrl, table[idx].name, i+1, value+i*4);
757         }
758       else
759         send_status_info (ctrl, table[idx].name, value, valuelen, NULL, 0);
760
761       xfree (relptr);
762     }
763   return 0;
764 }
765
766
767 /* Get the public key for KEYNO and store it as an S-expresion with
768    the APP handle.  On error that field gets cleared.  If we already
769    know about the public key we will just return.  Note that this does
770    not mean a key is available; this is soley indicated by the
771    presence of the app->app_local->pk[KEYNO-1].key field.
772
773    Note that GnuPG 1.x does not need this and it would be too time
774    consuming to send it just for the fun of it.  */
775 #if GNUPG_MAJOR_VERSION > 1
776 static gpg_error_t
777 get_public_key (app_t app, int keyno)
778 {
779   gpg_error_t err = 0;
780   unsigned char *buffer;
781   const unsigned char *keydata, *m, *e;
782   size_t buflen, keydatalen, mlen, elen;
783   gcry_sexp_t sexp;
784
785   if (keyno < 1 || keyno > 3)
786     return gpg_error (GPG_ERR_INV_ID);
787   keyno--;
788
789   /* Already cached? */
790   if (app->app_local->pk[keyno].read_done)
791     return 0;
792
793   gcry_sexp_release (app->app_local->pk[keyno].key);
794   app->app_local->pk[keyno].key = NULL;
795
796   if (app->card_version > 0x0100)
797     {
798       /* We may simply read the public key out of these cards.  */
799       err = iso7816_read_public_key (app->slot, 
800                                     keyno == 0? "\xB6" :
801                                     keyno == 1? "\xB8" : "\xA4",
802                                     2,  
803                                     &buffer, &buflen);
804       if (err)
805         {
806           log_error (_("reading public key failed: %s\n"), gpg_strerror (err));
807           goto leave;
808         }
809
810       keydata = find_tlv (buffer, buflen, 0x7F49, &keydatalen);
811       if (!keydata)
812         {
813           err = gpg_error (GPG_ERR_CARD);
814           log_error (_("response does not contain the public key data\n"));
815           goto leave;
816         }
817  
818       m = find_tlv (keydata, keydatalen, 0x0081, &mlen);
819       if (!m)
820         {
821           err = gpg_error (GPG_ERR_CARD);
822           log_error (_("response does not contain the RSA modulus\n"));
823           goto leave;
824         }
825
826       e = find_tlv (keydata, keydatalen, 0x0082, &elen);
827       if (!e)
828         {
829           err = gpg_error (GPG_ERR_CARD);
830           log_error (_("response does not contain the RSA public exponent\n"));
831           goto leave;
832         }
833
834       err = gcry_sexp_build (&sexp, NULL,
835                              "(public-key (rsa (n %b) (e %b)))",
836                              (int)mlen, m,(int)elen, e);
837
838       if (err)
839         {
840           log_error ("error formatting the key into an S-expression: %s\n",
841                      gpg_strerror (err));
842           goto leave;
843         }
844       app->app_local->pk[keyno].key = sexp;
845
846     }
847   else
848     {
849       /* Due to a design problem in v1.0 cards we can't get the public
850          key out of these cards without doing a verify on CHV3.
851          Clearly that is not an option and thus we try to locate the
852          key using an external helper.  */
853
854       buffer = NULL;
855       /* FIXME */
856
857     }
858
859  leave:
860   /* Set a flag to indicate that we tried to read the key.  */
861   app->app_local->pk[keyno].read_done = 1;
862
863   xfree (buffer);
864   return 0;
865 }
866 #endif /* GNUPG_MAJOR_VERSION > 1 */
867
868
869
870 /* Send the KEYPAIRINFO back. KEYNO needs to be in the range [1,3].
871    This is used by the LEARN command. */
872 static gpg_error_t
873 send_keypair_info (app_t app, ctrl_t ctrl, int keyno)
874 {
875   gpg_error_t err = 0;
876   /* Note that GnuPG 1.x does not need this and it would be too time
877      consuming to send it just for the fun of it. */
878 #if GNUPG_MAJOR_VERSION > 1
879   gcry_sexp_t sexp;
880   unsigned char grip[20];
881   char gripstr[41];
882   char idbuf[50];
883   int i;
884
885   err = get_public_key (app, keyno);
886   if (err)
887     goto leave;
888   
889   assert (keyno >= 1 && keyno <= 3);
890   sexp = app->app_local->pk[keyno-1].key;
891   if (!sexp)
892     goto leave; /* No such key.  */
893
894   if (!gcry_pk_get_keygrip (sexp, grip))
895     {
896       err = gpg_error (GPG_ERR_INTERNAL); 
897       goto leave;  
898     }
899   
900   for (i=0; i < 20; i++)
901     sprintf (gripstr+i*2, "%02X", grip[i]);
902
903   sprintf (idbuf, "OPENPGP.%d", keyno);
904   send_status_info (ctrl, "KEYPAIRINFO", 
905                     gripstr, 40, 
906                     idbuf, strlen (idbuf), 
907                     NULL, (size_t)0);
908
909  leave:
910 #endif /* GNUPG_MAJOR_VERSION > 1 */
911
912   return err; 
913 }
914
915
916 /* Handle the LEARN command for OpenPGP.  */
917 static int
918 do_learn_status (app_t app, ctrl_t ctrl)
919 {
920   do_getattr (app, ctrl, "EXTCAP");
921   do_getattr (app, ctrl, "DISP-NAME");
922   do_getattr (app, ctrl, "DISP-LANG");
923   do_getattr (app, ctrl, "DISP-SEX");
924   do_getattr (app, ctrl, "PUBKEY-URL");
925   do_getattr (app, ctrl, "LOGIN-DATA");
926   do_getattr (app, ctrl, "KEY-FPR");
927   if (app->card_version > 0x0100)
928     do_getattr (app, ctrl, "KEY-TIME");
929   do_getattr (app, ctrl, "CA-FPR");
930   do_getattr (app, ctrl, "CHV-STATUS");
931   do_getattr (app, ctrl, "SIG-COUNTER");
932   if (app->app_local->extcap.private_dos)
933     {
934       do_getattr (app, ctrl, "PRIVATE-DO-1");
935       do_getattr (app, ctrl, "PRIVATE-DO-2");
936       if (app->did_chv2)
937         do_getattr (app, ctrl, "PRIVATE-DO-3");
938       if (app->did_chv3)
939         do_getattr (app, ctrl, "PRIVATE-DO-4");
940     }
941   send_keypair_info (app, ctrl, 1);
942   send_keypair_info (app, ctrl, 2);
943   send_keypair_info (app, ctrl, 3);
944   return 0;
945 }
946
947
948 /* Handle the READKEY command for OpenPGP.  On success a canonical
949    encoded S-expression with the public key will get stored at PK and
950    its length (for assertions) at PKLEN; the caller must release that
951    buffer. On error PK and PKLEN are not changed and an error code is
952    returned.  */
953 static int
954 do_readkey (app_t app, const char *keyid, unsigned char **pk, size_t *pklen)
955 {
956   gpg_error_t err;
957   int keyno;
958   size_t n;
959   unsigned char *buf;
960   gcry_sexp_t sexp;
961
962   if (!strcmp (keyid, "OPENPGP.1"))
963     keyno = 1;
964   else if (!strcmp (keyid, "OPENPGP.2"))
965     keyno = 2;
966   else if (!strcmp (keyid, "OPENPGP.3"))
967     keyno = 3;
968   else
969     return gpg_error (GPG_ERR_INV_ID);
970
971   err = get_public_key (app, keyno);
972   if (err)
973     return err;
974
975   sexp = app->app_local->pk[keyno-1].key;
976   if (!sexp)
977     return gpg_error (GPG_ERR_NO_PUBKEY);
978
979   n = gcry_sexp_sprint (sexp, GCRYSEXP_FMT_CANON, NULL, 0);
980   if (!n)
981     return gpg_error (GPG_ERR_BUG);
982   buf = xtrymalloc (n);
983   if (!buf)
984     return gpg_error_from_errno (errno);
985   n = gcry_sexp_sprint (sexp, GCRYSEXP_FMT_CANON, buf, n);
986   if (!n)
987     {
988       xfree (buf);
989       return gpg_error (GPG_ERR_BUG);
990     }
991   *pk = buf;
992   *pklen = n;
993   return 0;
994 }
995
996
997
998 /* Verify CHV2 if required.  Depending on the configuration of the
999    card CHV1 will also be verified. */
1000 static int
1001 verify_chv2 (app_t app,
1002              int (*pincb)(void*, const char *, char **),
1003              void *pincb_arg)
1004 {
1005   int rc = 0;
1006
1007   if (!app->did_chv2) 
1008     {
1009       char *pinvalue;
1010
1011       rc = pincb (pincb_arg, "PIN", &pinvalue); 
1012       if (rc)
1013         {
1014           log_info (_("PIN callback returned error: %s\n"), gpg_strerror (rc));
1015           return rc;
1016         }
1017
1018       if (strlen (pinvalue) < 6)
1019         {
1020           log_error (_("PIN for CHV%d is too short;"
1021                        " minimum length is %d\n"), 2, 6);
1022           xfree (pinvalue);
1023           return gpg_error (GPG_ERR_BAD_PIN);
1024         }
1025
1026       rc = iso7816_verify (app->slot, 0x82, pinvalue, strlen (pinvalue));
1027       if (rc)
1028         {
1029           log_error (_("verify CHV%d failed: %s\n"), 2, gpg_strerror (rc));
1030           xfree (pinvalue);
1031           flush_cache_after_error (app);
1032           return rc;
1033         }
1034       app->did_chv2 = 1;
1035
1036       if (!app->did_chv1 && !app->force_chv1)
1037         {
1038           rc = iso7816_verify (app->slot, 0x81, pinvalue, strlen (pinvalue));
1039           if (gpg_err_code (rc) == GPG_ERR_BAD_PIN)
1040             rc = gpg_error (GPG_ERR_PIN_NOT_SYNCED);
1041           if (rc)
1042             {
1043               log_error (_("verify CHV%d failed: %s\n"), 1, gpg_strerror (rc));
1044               xfree (pinvalue);
1045               flush_cache_after_error (app);
1046               return rc;
1047             }
1048           app->did_chv1 = 1;
1049         }
1050       xfree (pinvalue);
1051     }
1052   return rc;
1053 }
1054
1055 /* Verify CHV3 if required. */
1056 static int
1057 verify_chv3 (app_t app,
1058              int (*pincb)(void*, const char *, char **),
1059              void *pincb_arg)
1060 {
1061   int rc = 0;
1062
1063 #if GNUPG_MAJOR_VERSION != 1
1064   if (!opt.allow_admin)
1065     {
1066       log_info (_("access to admin commands is not configured\n"));
1067       return gpg_error (GPG_ERR_EACCES);
1068     }
1069 #endif
1070       
1071   if (!app->did_chv3) 
1072     {
1073       char *pinvalue;
1074       void *relptr;
1075       unsigned char *value;
1076       size_t valuelen;
1077
1078       relptr = get_one_do (app, 0x00C4, &value, &valuelen);
1079       if (!relptr || valuelen < 7)
1080         {
1081           log_error (_("error retrieving CHV status from card\n"));
1082           xfree (relptr);
1083           return gpg_error (GPG_ERR_CARD);
1084         }
1085       if (value[6] == 0)
1086         {
1087           log_info (_("card is permanently locked!\n"));
1088           xfree (relptr);
1089           return gpg_error (GPG_ERR_BAD_PIN);
1090         }
1091
1092       log_info(_("%d Admin PIN attempts remaining before card"
1093                  " is permanently locked\n"), value[6]);
1094       xfree (relptr);
1095
1096       /* TRANSLATORS: Do not translate the "|A|" prefix but
1097          keep it at the start of the string.  We need this elsewhere
1098          to get some infos on the string. */
1099       rc = pincb (pincb_arg, _("|A|Admin PIN"), &pinvalue); 
1100       if (rc)
1101         {
1102           log_info (_("PIN callback returned error: %s\n"), gpg_strerror (rc));
1103           return rc;
1104         }
1105
1106       if (strlen (pinvalue) < 8)
1107         {
1108           log_error (_("PIN for CHV%d is too short;"
1109                        " minimum length is %d\n"), 3, 8);
1110           xfree (pinvalue);
1111           return gpg_error (GPG_ERR_BAD_PIN);
1112         }
1113
1114       rc = iso7816_verify (app->slot, 0x83, pinvalue, strlen (pinvalue));
1115       xfree (pinvalue);
1116       if (rc)
1117         {
1118           log_error (_("verify CHV%d failed: %s\n"), 3, gpg_strerror (rc));
1119           flush_cache_after_error (app);
1120           return rc;
1121         }
1122       app->did_chv3 = 1;
1123     }
1124   return rc;
1125 }
1126
1127
1128 /* Handle the SETATTR operation. All arguments are already basically
1129    checked. */
1130 static int 
1131 do_setattr (app_t app, const char *name,
1132             int (*pincb)(void*, const char *, char **),
1133             void *pincb_arg,
1134             const unsigned char *value, size_t valuelen)
1135 {
1136   gpg_error_t rc;
1137   int idx;
1138   static struct {
1139     const char *name;
1140     int tag;
1141     int need_chv;
1142     int special;
1143   } table[] = {
1144     { "DISP-NAME",    0x005B, 3 },
1145     { "LOGIN-DATA",   0x005E, 3, 2 },
1146     { "DISP-LANG",    0x5F2D, 3 },
1147     { "DISP-SEX",     0x5F35, 3 },
1148     { "PUBKEY-URL",   0x5F50, 3 },
1149     { "CHV-STATUS-1", 0x00C4, 3, 1 },
1150     { "CA-FPR-1",     0x00CA, 3 },
1151     { "CA-FPR-2",     0x00CB, 3 },
1152     { "CA-FPR-3",     0x00CC, 3 },
1153     { "PRIVATE-DO-1", 0x0101, 2 },
1154     { "PRIVATE-DO-2", 0x0102, 3 },
1155     { "PRIVATE-DO-3", 0x0103, 2 },
1156     { "PRIVATE-DO-4", 0x0104, 3 },
1157     { NULL, 0 }
1158   };
1159
1160
1161   for (idx=0; table[idx].name && strcmp (table[idx].name, name); idx++)
1162     ;
1163   if (!table[idx].name)
1164     return gpg_error (GPG_ERR_INV_NAME); 
1165
1166   switch (table[idx].need_chv)
1167     {
1168     case 2:
1169       rc = verify_chv2 (app, pincb, pincb_arg);
1170       break;
1171     case 3:
1172       rc = verify_chv3 (app, pincb, pincb_arg);
1173       break;
1174     default:
1175       rc = 0;
1176     }
1177   if (rc)
1178     return rc;
1179
1180   /* Flush the cache before writing it, so that the next get operation
1181      will reread the data from the card and thus get synced in case of
1182      errors (e.g. data truncated by the card). */
1183   flush_cache_item (app, table[idx].tag);
1184   rc = iso7816_put_data (app->slot, table[idx].tag, value, valuelen);
1185   if (rc)
1186     log_error ("failed to set `%s': %s\n", table[idx].name, gpg_strerror (rc));
1187
1188   if (table[idx].special == 1)
1189     app->force_chv1 = (valuelen && *value == 0);
1190   else if (table[idx].special == 2)
1191     parse_login_data (app);
1192
1193   return rc;
1194 }
1195
1196
1197 /* Handle the PASSWD command. */
1198 static int 
1199 do_change_pin (app_t app, ctrl_t ctrl,  const char *chvnostr, int reset_mode,
1200                int (*pincb)(void*, const char *, char **),
1201                void *pincb_arg)
1202 {
1203   int rc = 0;
1204   int chvno = atoi (chvnostr);
1205   char *pinvalue;
1206
1207   if (reset_mode && chvno == 3)
1208     {
1209       rc = gpg_error (GPG_ERR_INV_ID);
1210       goto leave;
1211     }
1212   else if (reset_mode || chvno == 3)
1213     {
1214       /* we always require that the PIN is entered. */
1215       app->did_chv3 = 0;
1216       rc = verify_chv3 (app, pincb, pincb_arg);
1217       if (rc)
1218         goto leave;
1219     }
1220   else if (chvno == 1 || chvno == 2)
1221     {
1222       /* CHV1 and CVH2 should always have the same value, thus we
1223          enforce it here.  */
1224       int save_force = app->force_chv1;
1225
1226       app->force_chv1 = 0;
1227       app->did_chv1 = 0;
1228       app->did_chv2 = 0;
1229       rc = verify_chv2 (app, pincb, pincb_arg);
1230       app->force_chv1 = save_force;
1231       if (rc)
1232         goto leave;
1233     }
1234   else
1235     {
1236       rc = gpg_error (GPG_ERR_INV_ID);
1237       goto leave;
1238     }
1239
1240   if (chvno == 3)
1241     app->did_chv3 = 0;
1242   else
1243     app->did_chv1 = app->did_chv2 = 0;
1244
1245   /* Note to translators: Do not translate the "|*|" prefixes but
1246      keep it at the start of the string.  We need this elsewhere
1247      to get some infos on the string. */
1248   rc = pincb (pincb_arg, chvno == 3? _("|AN|New Admin PIN") : _("|N|New PIN"), 
1249               &pinvalue); 
1250   if (rc)
1251     {
1252       log_error (_("error getting new PIN: %s\n"), gpg_strerror (rc));
1253       goto leave;
1254     }
1255
1256   if (reset_mode)
1257     {
1258       rc = iso7816_reset_retry_counter (app->slot, 0x81,
1259                                         pinvalue, strlen (pinvalue));
1260       if (!rc)
1261         rc = iso7816_reset_retry_counter (app->slot, 0x82,
1262                                           pinvalue, strlen (pinvalue));
1263     }
1264   else
1265     {
1266       if (chvno == 1 || chvno == 2)
1267         {
1268           rc = iso7816_change_reference_data (app->slot, 0x81, NULL, 0,
1269                                               pinvalue, strlen (pinvalue));
1270           if (!rc)
1271             rc = iso7816_change_reference_data (app->slot, 0x82, NULL, 0,
1272                                                 pinvalue, strlen (pinvalue));
1273         }
1274       else
1275         rc = iso7816_change_reference_data (app->slot, 0x80 + chvno, NULL, 0,
1276                                             pinvalue, strlen (pinvalue));
1277     }
1278   xfree (pinvalue);
1279   if (rc)
1280     flush_cache_after_error (app);
1281
1282  leave:
1283   return rc;
1284 }
1285
1286
1287
1288 /* Handle the GENKEY command. */
1289 static int 
1290 do_genkey (app_t app, ctrl_t ctrl,  const char *keynostr, unsigned int flags,
1291           int (*pincb)(void*, const char *, char **),
1292           void *pincb_arg)
1293 {
1294   int rc;
1295   int i;
1296   char numbuf[30];
1297   unsigned char fprbuf[20];
1298   const unsigned char *fpr;
1299   const unsigned char *keydata, *m, *e;
1300   unsigned char *buffer;
1301   size_t buflen, keydatalen, n, mlen, elen;
1302   time_t created_at;
1303   int keyno = atoi (keynostr);
1304   int force = (flags & 1);
1305   time_t start_at;
1306
1307   if (keyno < 1 || keyno > 3)
1308     return gpg_error (GPG_ERR_INV_ID);
1309   keyno--;
1310
1311   /* We flush the cache to increase the traffic before a key
1312      generation.  This _might_ help a card to gather more entropy. */
1313   flush_cache (app);
1314
1315   /* Obviously we need to remove the cached public key.  */
1316   gcry_sexp_release (app->app_local->pk[keyno].key);
1317   app->app_local->pk[keyno].read_done = 0;
1318
1319   /* Check whether a key already exists.  */
1320   rc = iso7816_get_data (app->slot, 0x006E, &buffer, &buflen);
1321   if (rc)
1322     {
1323       log_error (_("error reading application data\n"));
1324       return gpg_error (GPG_ERR_GENERAL);
1325     }
1326   fpr = find_tlv (buffer, buflen, 0x00C5, &n);
1327   if (!fpr || n != 60)
1328     {
1329       rc = gpg_error (GPG_ERR_GENERAL);
1330       log_error (_("error reading fingerprint DO\n"));
1331       goto leave;
1332     }
1333   fpr += 20*keyno;
1334   for (i=0; i < 20 && !fpr[i]; i++)
1335     ;
1336   if (i!=20 && !force)
1337     {
1338       rc = gpg_error (GPG_ERR_EEXIST);
1339       log_error (_("key already exists\n"));
1340       goto leave;
1341     }
1342   else if (i!=20)
1343     log_info (_("existing key will be replaced\n"));
1344   else
1345     log_info (_("generating new key\n"));
1346
1347   
1348   /* Prepare for key generation by verifying the ADmin PIN.  */
1349   rc = verify_chv3 (app, pincb, pincb_arg);
1350   if (rc)
1351     goto leave;
1352    
1353   xfree (buffer); buffer = NULL;
1354
1355 #if 1
1356   log_info (_("please wait while key is being generated ...\n"));
1357   start_at = time (NULL);
1358   rc = iso7816_generate_keypair 
1359 #else
1360 #warning key generation temporary replaced by reading an existing key.
1361   rc = iso7816_read_public_key
1362 #endif
1363                               (app->slot, 
1364                                  keyno == 0? "\xB6" :
1365                                  keyno == 1? "\xB8" : "\xA4",
1366                                  2,
1367                                  &buffer, &buflen);
1368   if (rc)
1369     {
1370       rc = gpg_error (GPG_ERR_CARD);
1371       log_error (_("generating key failed\n"));
1372       goto leave;
1373     }
1374   log_info (_("key generation completed (%d seconds)\n"),
1375             (int)(time (NULL) - start_at));
1376   keydata = find_tlv (buffer, buflen, 0x7F49, &keydatalen);
1377   if (!keydata)
1378     {
1379       rc = gpg_error (GPG_ERR_CARD);
1380       log_error (_("response does not contain the public key data\n"));
1381       goto leave;
1382     }
1383  
1384   m = find_tlv (keydata, keydatalen, 0x0081, &mlen);
1385   if (!m)
1386     {
1387       rc = gpg_error (GPG_ERR_CARD);
1388       log_error (_("response does not contain the RSA modulus\n"));
1389       goto leave;
1390     }
1391 /*    log_printhex ("RSA n:", m, mlen); */
1392   send_key_data (ctrl, "n", m, mlen);
1393
1394   e = find_tlv (keydata, keydatalen, 0x0082, &elen);
1395   if (!e)
1396     {
1397       rc = gpg_error (GPG_ERR_CARD);
1398       log_error (_("response does not contain the RSA public exponent\n"));
1399       goto leave;
1400     }
1401 /*    log_printhex ("RSA e:", e, elen); */
1402   send_key_data (ctrl, "e", e, elen);
1403
1404   created_at = gnupg_get_time ();
1405   sprintf (numbuf, "%lu", (unsigned long)created_at);
1406   send_status_info (ctrl, "KEY-CREATED-AT",
1407                     numbuf, (size_t)strlen(numbuf), NULL, 0);
1408
1409   rc = store_fpr (app->slot, keyno, (u32)created_at,
1410                   m, mlen, e, elen, fprbuf, app->card_version);
1411   if (rc)
1412     goto leave;
1413   send_fpr_if_not_null (ctrl, "KEY-FPR", -1, fprbuf);
1414
1415
1416  leave:
1417   xfree (buffer);
1418   return rc;
1419 }
1420
1421
1422 static unsigned long
1423 convert_sig_counter_value (const unsigned char *value, size_t valuelen)
1424 {
1425   unsigned long ul;
1426
1427   if (valuelen == 3 )
1428     ul = (value[0] << 16) | (value[1] << 8) | value[2];
1429   else
1430     {
1431       log_error (_("invalid structure of OpenPGP card (DO 0x93)\n"));
1432       ul = 0;
1433     }
1434   return ul;
1435 }
1436
1437 static unsigned long
1438 get_sig_counter (app_t app)
1439 {
1440   void *relptr;
1441   unsigned char *value;
1442   size_t valuelen;
1443   unsigned long ul;
1444
1445   relptr = get_one_do (app, 0x0093, &value, &valuelen);
1446   if (!relptr)
1447     return 0;
1448   ul = convert_sig_counter_value (value, valuelen);
1449   xfree (relptr);
1450   return ul;
1451 }
1452
1453 static int
1454 compare_fingerprint (app_t app, int keyno, unsigned char *sha1fpr)
1455 {
1456   const unsigned char *fpr;
1457   unsigned char *buffer;
1458   size_t buflen, n;
1459   int rc, i;
1460   
1461   assert (keyno >= 1 && keyno <= 3);
1462
1463   rc = get_cached_data (app, 0x006E, &buffer, &buflen, 0);
1464   if (rc)
1465     {
1466       log_error (_("error reading application data\n"));
1467       return gpg_error (GPG_ERR_GENERAL);
1468     }
1469   fpr = find_tlv (buffer, buflen, 0x00C5, &n);
1470   if (!fpr || n != 60)
1471     {
1472       xfree (buffer);
1473       log_error (_("error reading fingerprint DO\n"));
1474       return gpg_error (GPG_ERR_GENERAL);
1475     }
1476   fpr += (keyno-1)*20;
1477   for (i=0; i < 20; i++)
1478     if (sha1fpr[i] != fpr[i])
1479       {
1480         xfree (buffer);
1481         return gpg_error (GPG_ERR_WRONG_SECKEY);
1482       }
1483   xfree (buffer);
1484   return 0;
1485 }
1486
1487
1488   /* If a fingerprint has been specified check it against the one on
1489      the card.  This is allows for a meaningful error message in case
1490      the key on the card has been replaced but the shadow information
1491      known to gpg was not updated.  If there is no fingerprint we
1492      assume that this is okay. */
1493 static int
1494 check_against_given_fingerprint (app_t app, const char *fpr, int keyno)
1495 {
1496   unsigned char tmp[20];
1497   const char *s;
1498   int n;
1499
1500   for (s=fpr, n=0; hexdigitp (s); s++, n++)
1501     ;
1502   if (n != 40)
1503     return gpg_error (GPG_ERR_INV_ID);
1504   else if (!*s)
1505     ; /* okay */
1506   else
1507     return gpg_error (GPG_ERR_INV_ID);
1508
1509   for (s=fpr, n=0; n < 20; s += 2, n++)
1510         tmp[n] = xtoi_2 (s);
1511   return compare_fingerprint (app, keyno, tmp);
1512 }
1513
1514
1515
1516 /* Compute a digital signature on INDATA which is expected to be the
1517    raw message digest. For this application the KEYIDSTR consists of
1518    the serialnumber and the fingerprint delimited by a slash.
1519
1520    Note that this fucntion may return the error code
1521    GPG_ERR_WRONG_CARD to indicate that the card currently present does
1522    not match the one required for the requested action (e.g. the
1523    serial number does not match). */
1524 static int 
1525 do_sign (app_t app, const char *keyidstr, int hashalgo,
1526          int (*pincb)(void*, const char *, char **),
1527          void *pincb_arg,
1528          const void *indata, size_t indatalen,
1529          unsigned char **outdata, size_t *outdatalen )
1530 {
1531   static unsigned char sha1_prefix[15] = /* Object ID is 1.3.14.3.2.26 */
1532   { 0x30, 0x21, 0x30, 0x09, 0x06, 0x05, 0x2b, 0x0e, 0x03,
1533     0x02, 0x1a, 0x05, 0x00, 0x04, 0x14 };
1534   static unsigned char rmd160_prefix[15] = /* Object ID is 1.3.36.3.2.1 */
1535   { 0x30, 0x21, 0x30, 0x09, 0x06, 0x05, 0x2b, 0x24, 0x03,
1536     0x02, 0x01, 0x05, 0x00, 0x04, 0x14 };
1537   int rc;
1538   unsigned char data[35];
1539   unsigned char tmp_sn[20]; /* actually 16 but we use it also for the fpr. */
1540   const char *s;
1541   int n;
1542   const char *fpr = NULL;
1543   unsigned long sigcount;
1544
1545   if (!keyidstr || !*keyidstr)
1546     return gpg_error (GPG_ERR_INV_VALUE);
1547   if (indatalen != 20)
1548     return gpg_error (GPG_ERR_INV_VALUE);
1549
1550   /* Check whether an OpenPGP card of any version has been requested. */
1551   if (strlen (keyidstr) < 32 || strncmp (keyidstr, "D27600012401", 12))
1552     return gpg_error (GPG_ERR_INV_ID);
1553   
1554   for (s=keyidstr, n=0; hexdigitp (s); s++, n++)
1555     ;
1556   if (n != 32)
1557     return gpg_error (GPG_ERR_INV_ID);
1558   else if (!*s)
1559     ; /* no fingerprint given: we allow this for now. */
1560   else if (*s == '/')
1561     fpr = s + 1; 
1562   else
1563     return gpg_error (GPG_ERR_INV_ID);
1564
1565   for (s=keyidstr, n=0; n < 16; s += 2, n++)
1566     tmp_sn[n] = xtoi_2 (s);
1567
1568   if (app->serialnolen != 16)
1569     return gpg_error (GPG_ERR_INV_CARD);
1570   if (memcmp (app->serialno, tmp_sn, 16))
1571     return gpg_error (GPG_ERR_WRONG_CARD);
1572
1573   /* If a fingerprint has been specified check it against the one on
1574      the card.  This is allows for a meaningful error message in case
1575      the key on the card has been replaced but the shadow information
1576      known to gpg was not updated.  If there is no fingerprint, gpg
1577      will detect a bogus signature anyway due to the
1578      verify-after-signing feature. */
1579   rc = fpr? check_against_given_fingerprint (app, fpr, 1) : 0;
1580   if (rc)
1581     return rc;
1582
1583   if (hashalgo == GCRY_MD_SHA1)
1584     memcpy (data, sha1_prefix, 15);
1585   else if (hashalgo == GCRY_MD_RMD160)
1586     memcpy (data, rmd160_prefix, 15);
1587   else 
1588     return gpg_error (GPG_ERR_UNSUPPORTED_ALGORITHM);
1589   memcpy (data+15, indata, indatalen);
1590
1591   sigcount = get_sig_counter (app);
1592   log_info (_("signatures created so far: %lu\n"), sigcount);
1593
1594   if (!app->did_chv1 || app->force_chv1 ) 
1595     {
1596       char *pinvalue;
1597
1598       {
1599         char *prompt;
1600 #define PROMPTSTRING  _("PIN [sigs done: %lu]")
1601
1602         prompt = malloc (strlen (PROMPTSTRING) + 50);
1603         if (!prompt)
1604           return gpg_error_from_errno (errno);
1605         sprintf (prompt, PROMPTSTRING, sigcount);
1606         rc = pincb (pincb_arg, prompt, &pinvalue); 
1607         free (prompt);
1608 #undef PROMPTSTRING
1609       }
1610       if (rc)
1611         {
1612           log_info (_("PIN callback returned error: %s\n"), gpg_strerror (rc));
1613           return rc;
1614         }
1615
1616       if (strlen (pinvalue) < 6)
1617         {
1618           log_error (_("PIN for CHV%d is too short;"
1619                        " minimum length is %d\n"), 1, 6);
1620           xfree (pinvalue);
1621           return gpg_error (GPG_ERR_BAD_PIN);
1622         }
1623
1624       rc = iso7816_verify (app->slot, 0x81, pinvalue, strlen (pinvalue));
1625       if (rc)
1626         {
1627           log_error (_("verify CHV%d failed: %s\n"), 1, gpg_strerror (rc));
1628           xfree (pinvalue);
1629           flush_cache_after_error (app);
1630           return rc;
1631         }
1632       app->did_chv1 = 1;
1633       if (!app->did_chv2)
1634         {
1635           /* We should also verify CHV2. */
1636           rc = iso7816_verify (app->slot, 0x82, pinvalue, strlen (pinvalue));
1637           if (gpg_err_code (rc) == GPG_ERR_BAD_PIN)
1638             rc = gpg_error (GPG_ERR_PIN_NOT_SYNCED);
1639           if (rc)
1640             {
1641               log_error (_("verify CHV%d failed: %s\n"), 2, gpg_strerror (rc));
1642               xfree (pinvalue);
1643               flush_cache_after_error (app);
1644               return rc;
1645             }
1646           app->did_chv2 = 1;
1647         }
1648       xfree (pinvalue);
1649     }
1650
1651   rc = iso7816_compute_ds (app->slot, data, 35, outdata, outdatalen);
1652   return rc;
1653 }
1654
1655 /* Compute a digital signature using the INTERNAL AUTHENTICATE command
1656    on INDATA which is expected to be the raw message digest. For this
1657    application the KEYIDSTR consists of the serialnumber and the
1658    fingerprint delimited by a slash.
1659
1660    Note that this fucntion may return the error code
1661    GPG_ERR_WRONG_CARD to indicate that the card currently present does
1662    not match the one required for the requested action (e.g. the
1663    serial number does not match). */
1664 static int 
1665 do_auth (app_t app, const char *keyidstr,
1666          int (*pincb)(void*, const char *, char **),
1667          void *pincb_arg,
1668          const void *indata, size_t indatalen,
1669          unsigned char **outdata, size_t *outdatalen )
1670 {
1671   int rc;
1672   unsigned char tmp_sn[20]; /* actually 16 but we use it also for the fpr. */
1673   const char *s;
1674   int n;
1675   const char *fpr = NULL;
1676
1677   if (!keyidstr || !*keyidstr)
1678     return gpg_error (GPG_ERR_INV_VALUE);
1679   if (indatalen > 50) /* For a 1024 bit key. */
1680     return gpg_error (GPG_ERR_INV_VALUE);
1681
1682   /* Check whether an OpenPGP card of any version has been requested. */
1683   if (strlen (keyidstr) < 32 || strncmp (keyidstr, "D27600012401", 12))
1684     return gpg_error (GPG_ERR_INV_ID);
1685   
1686   for (s=keyidstr, n=0; hexdigitp (s); s++, n++)
1687     ;
1688   if (n != 32)
1689     return gpg_error (GPG_ERR_INV_ID);
1690   else if (!*s)
1691     ; /* no fingerprint given: we allow this for now. */
1692   else if (*s == '/')
1693     fpr = s + 1; 
1694   else
1695     return gpg_error (GPG_ERR_INV_ID);
1696
1697   for (s=keyidstr, n=0; n < 16; s += 2, n++)
1698     tmp_sn[n] = xtoi_2 (s);
1699
1700   if (app->serialnolen != 16)
1701     return gpg_error (GPG_ERR_INV_CARD);
1702   if (memcmp (app->serialno, tmp_sn, 16))
1703     return gpg_error (GPG_ERR_WRONG_CARD);
1704
1705   /* If a fingerprint has been specified check it against the one on
1706      the card.  This is allows for a meaningful error message in case
1707      the key on the card has been replaced but the shadow information
1708      known to gpg was not updated.  If there is no fingerprint, gpg
1709      will detect a bogus signature anyway due to the
1710      verify-after-signing feature. */
1711   rc = fpr? check_against_given_fingerprint (app, fpr, 3) : 0;
1712   if (rc)
1713     return rc;
1714
1715   rc = verify_chv2 (app, pincb, pincb_arg);
1716   if (!rc)
1717     rc = iso7816_internal_authenticate (app->slot, indata, indatalen,
1718                                         outdata, outdatalen);
1719   return rc;
1720 }
1721
1722
1723 static int 
1724 do_decipher (app_t app, const char *keyidstr,
1725              int (pincb)(void*, const char *, char **),
1726              void *pincb_arg,
1727              const void *indata, size_t indatalen,
1728              unsigned char **outdata, size_t *outdatalen )
1729 {
1730   int rc;
1731   unsigned char tmp_sn[20]; /* actually 16 but we use it also for the fpr. */
1732   const char *s;
1733   int n;
1734   const char *fpr = NULL;
1735
1736   if (!keyidstr || !*keyidstr || !indatalen)
1737     return gpg_error (GPG_ERR_INV_VALUE);
1738
1739   /* Check whether an OpenPGP card of any version has been requested. */
1740   if (strlen (keyidstr) < 32 || strncmp (keyidstr, "D27600012401", 12))
1741     return gpg_error (GPG_ERR_INV_ID);
1742   
1743   for (s=keyidstr, n=0; hexdigitp (s); s++, n++)
1744     ;
1745   if (n != 32)
1746     return gpg_error (GPG_ERR_INV_ID);
1747   else if (!*s)
1748     ; /* no fingerprint given: we allow this for now. */
1749   else if (*s == '/')
1750     fpr = s + 1; 
1751   else
1752     return gpg_error (GPG_ERR_INV_ID);
1753
1754   for (s=keyidstr, n=0; n < 16; s += 2, n++)
1755     tmp_sn[n] = xtoi_2 (s);
1756
1757   if (app->serialnolen != 16)
1758     return gpg_error (GPG_ERR_INV_CARD);
1759   if (memcmp (app->serialno, tmp_sn, 16))
1760     return gpg_error (GPG_ERR_WRONG_CARD);
1761
1762   /* If a fingerprint has been specified check it against the one on
1763      the card.  This is allows for a meaningful error message in case
1764      the key on the card has been replaced but the shadow information
1765      known to gpg was not updated.  If there is no fingerprint, the
1766      decryption will won't produce the right plaintext anyway. */
1767   rc = fpr? check_against_given_fingerprint (app, fpr, 2) : 0;
1768   if (rc)
1769     return rc;
1770
1771   rc = verify_chv2 (app, pincb, pincb_arg);
1772   if (!rc)
1773     rc = iso7816_decipher (app->slot, indata, indatalen, 0,
1774                            outdata, outdatalen);
1775   return rc;
1776 }
1777
1778
1779 /* Perform a simple verify operation for CHV1 and CHV2, so that
1780    further operations won't ask for CHV2 and it is possible to do a
1781    cheap check on the PIN: If there is something wrong with the PIN
1782    entry system, only the regular CHV will get blocked and not the
1783    dangerous CHV3.  KEYIDSTR is the usual card's serial number; an
1784    optional fingerprint part will be ignored. */
1785 static int 
1786 do_check_pin (app_t app, const char *keyidstr,
1787               int (pincb)(void*, const char *, char **),
1788               void *pincb_arg)
1789 {
1790   unsigned char tmp_sn[20]; 
1791   const char *s;
1792   int n;
1793
1794   if (!keyidstr || !*keyidstr)
1795     return gpg_error (GPG_ERR_INV_VALUE);
1796
1797   /* Check whether an OpenPGP card of any version has been requested. */
1798   if (strlen (keyidstr) < 32 || strncmp (keyidstr, "D27600012401", 12))
1799     return gpg_error (GPG_ERR_INV_ID);
1800   
1801   for (s=keyidstr, n=0; hexdigitp (s); s++, n++)
1802     ;
1803   if (n != 32)
1804     return gpg_error (GPG_ERR_INV_ID);
1805   else if (!*s)
1806     ; /* No fingerprint given: we allow this for now. */
1807   else if (*s == '/')
1808     ; /* We ignore a fingerprint. */
1809   else
1810     return gpg_error (GPG_ERR_INV_ID);
1811
1812   for (s=keyidstr, n=0; n < 16; s += 2, n++)
1813     tmp_sn[n] = xtoi_2 (s);
1814
1815   if (app->serialnolen != 16)
1816     return gpg_error (GPG_ERR_INV_CARD);
1817   if (memcmp (app->serialno, tmp_sn, 16))
1818     return gpg_error (GPG_ERR_WRONG_CARD);
1819   /* Yes, there is a race conditions: The user might pull the card
1820      right here and we won't notice that.  However this is not a
1821      problem and the check above is merely for a graceful failure
1822      between operations. */
1823
1824   return verify_chv2 (app, pincb, pincb_arg);
1825 }
1826
1827
1828
1829
1830 /* Select the OpenPGP application on the card in SLOT.  This function
1831    must be used before any other OpenPGP application functions. */
1832 int
1833 app_select_openpgp (app_t app)
1834 {
1835   static char const aid[] = { 0xD2, 0x76, 0x00, 0x01, 0x24, 0x01 };
1836   int slot = app->slot;
1837   int rc;
1838   unsigned char *buffer;
1839   size_t buflen;
1840   void *relptr;
1841   
1842   rc = iso7816_select_application (slot, aid, sizeof aid);
1843   if (!rc)
1844     {
1845       unsigned int manufacturer;
1846
1847       app->apptype = "OPENPGP";
1848
1849       app->did_chv1 = 0;
1850       app->did_chv2 = 0;
1851       app->did_chv3 = 0;
1852       app->app_local = NULL;
1853
1854       /* The OpenPGP card returns the serial number as part of the
1855          AID; because we prefer to use OpenPGP serial numbers, we
1856          replace a possibly already set one from a EF.GDO with this
1857          one.  Note, that for current OpenPGP cards, no EF.GDO exists
1858          and thus it won't matter at all. */
1859       rc = iso7816_get_data (slot, 0x004F, &buffer, &buflen);
1860       if (rc)
1861         goto leave;
1862       if (opt.verbose)
1863         {
1864           log_info ("AID: ");
1865           log_printhex ("", buffer, buflen);
1866         }
1867
1868       app->card_version = buffer[6] << 8;
1869       app->card_version |= buffer[7];
1870       manufacturer = (buffer[8]<<8 | buffer[9]);
1871
1872       xfree (app->serialno);
1873       app->serialno = buffer;
1874       app->serialnolen = buflen;
1875       buffer = NULL;
1876       app->app_local = xtrycalloc (1, sizeof *app->app_local);
1877       if (!app->app_local)
1878         {
1879           rc = gpg_error (gpg_err_code_from_errno (errno));
1880           goto leave;
1881         }
1882
1883       relptr = get_one_do (app, 0x00C4, &buffer, &buflen);
1884       if (!relptr)
1885         {
1886           log_error (_("can't access %s - invalid OpenPGP card?\n"),
1887                      "CHV Status Bytes");
1888           goto leave;
1889         }
1890       app->force_chv1 = (buflen && *buffer == 0);
1891       xfree (relptr);
1892
1893       relptr = get_one_do (app, 0x00C0, &buffer, &buflen);
1894       if (!relptr)
1895         {
1896           log_error (_("can't access %s - invalid OpenPGP card?\n"),
1897                      "Extended Capability Flags" );
1898           goto leave;
1899         }
1900       if (buflen)
1901         {
1902           app->app_local->extcap.get_challenge    = !!(*buffer & 0x40);
1903           app->app_local->extcap.key_import       = !!(*buffer & 0x20);
1904           app->app_local->extcap.change_force_chv = !!(*buffer & 0x10);
1905           app->app_local->extcap.private_dos      = !!(*buffer & 0x08);
1906         }
1907       xfree (relptr);
1908       
1909       /* Some of the first cards accidently don't set the
1910          CHANGE_FORCE_CHV bit but allow it anyway. */
1911       if (app->card_version <= 0x0100 && manufacturer == 1)
1912         app->app_local->extcap.change_force_chv = 1;
1913
1914       parse_login_data (app);
1915
1916       if (opt.verbose > 1)
1917         dump_all_do (slot);
1918
1919       app->fnc.deinit = do_deinit;
1920       app->fnc.learn_status = do_learn_status;
1921       app->fnc.readkey = do_readkey;
1922       app->fnc.getattr = do_getattr;
1923       app->fnc.setattr = do_setattr;
1924       app->fnc.genkey = do_genkey;
1925       app->fnc.sign = do_sign;
1926       app->fnc.auth = do_auth;
1927       app->fnc.decipher = do_decipher;
1928       app->fnc.change_pin = do_change_pin;
1929       app->fnc.check_pin = do_check_pin;
1930    }
1931
1932 leave:
1933   if (rc)
1934     do_deinit (app);
1935   return rc;
1936 }
1937
1938
1939
1940 /* This function is a hack to retrieve essential information about the
1941    card to be displayed by simple tools.  It mostly resembles what the
1942    LEARN command returns. All parameters return allocated strings or
1943    buffers or NULL if the data object is not available.  All returned
1944    values are sanitized. */
1945 int
1946 app_openpgp_cardinfo (app_t app,
1947                       char **serialno,
1948                       char **disp_name,
1949                       char **pubkey_url,
1950                       unsigned char **fpr1,
1951                       unsigned char **fpr2,
1952                       unsigned char **fpr3)
1953 {
1954   int rc;
1955   void *relptr;
1956   unsigned char *value;
1957   size_t valuelen;
1958
1959   if (serialno)
1960     {
1961       time_t dummy;
1962
1963       *serialno = NULL;
1964       rc = app_get_serial_and_stamp (app, serialno, &dummy);
1965       if (rc)
1966         {
1967           log_error (_("error getting serial number: %s\n"),
1968                      gpg_strerror (rc));
1969           return rc;
1970         }
1971     }
1972       
1973   if (disp_name)
1974     {
1975       *disp_name = NULL;
1976       relptr = get_one_do (app, 0x005B, &value, &valuelen);
1977       if (relptr)
1978         {
1979           *disp_name = make_printable_string (value, valuelen, 0);
1980           xfree (relptr);
1981         }
1982     }
1983
1984   if (pubkey_url)
1985     {
1986       *pubkey_url = NULL;
1987       relptr = get_one_do (app, 0x5F50, &value, &valuelen);
1988       if (relptr)
1989         {
1990           *pubkey_url = make_printable_string (value, valuelen, 0);
1991           xfree (relptr);
1992         }
1993     }
1994
1995   if (fpr1)
1996     *fpr1 = NULL;
1997   if (fpr2)
1998     *fpr2 = NULL;
1999   if (fpr3)
2000     *fpr3 = NULL;
2001   relptr = get_one_do (app, 0x00C5, &value, &valuelen);
2002   if (relptr && valuelen >= 60)
2003     {
2004       if (fpr1)
2005         {
2006           *fpr1 = xmalloc (20);
2007           memcpy (*fpr1, value +  0, 20);
2008         }
2009       if (fpr2)
2010         {
2011           *fpr2 = xmalloc (20);
2012           memcpy (*fpr2, value + 20, 20);
2013         }
2014       if (fpr3)
2015         {
2016           *fpr3 = xmalloc (20);
2017           memcpy (*fpr3, value + 40, 20);
2018         }
2019     }
2020   xfree (relptr);
2021
2022   return 0;
2023 }
2024
2025
2026
2027 /* This function is currently only used by the sc-copykeys program to
2028    store a key on the smartcard.  app_t ist the application handle,
2029    KEYNO is the number of the key and PINCB, PINCB_ARG are used to ask
2030    for the SO PIN.  TEMPLATE and TEMPLATE_LEN describe a buffer with
2031    the key template to store. CREATED_AT is the timestamp used to
2032    create the fingerprint. M, MLEN is the RSA modulus and E, ELEN the
2033    RSA public exponent. This function silently overwrites an existing
2034    key.*/
2035 int 
2036 app_openpgp_storekey (app_t app, int keyno,
2037                       unsigned char *template, size_t template_len,
2038                       time_t created_at,
2039                       const unsigned char *m, size_t mlen,
2040                       const unsigned char *e, size_t elen,
2041                       int (*pincb)(void*, const char *, char **),
2042                       void *pincb_arg)
2043 {
2044   int rc;
2045   unsigned char fprbuf[20];
2046
2047   if (keyno < 1 || keyno > 3)
2048     return gpg_error (GPG_ERR_INV_ID);
2049   keyno--;
2050
2051   rc = verify_chv3 (app, pincb, pincb_arg);
2052   if (rc)
2053     goto leave;
2054
2055   flush_cache (app);
2056
2057   gcry_sexp_release (app->app_local->pk[keyno].key);
2058   app->app_local->pk[keyno].read_done = 0;
2059
2060   rc = iso7816_put_data (app->slot,
2061                          (app->card_version > 0x0007? 0xE0 : 0xE9) + keyno,
2062                          template, template_len);
2063   if (rc)
2064     {
2065       log_error (_("failed to store the key: %s\n"), gpg_strerror (rc));
2066       rc = gpg_error (GPG_ERR_CARD);
2067       goto leave;
2068     }
2069  
2070 /*    log_printhex ("RSA n:", m, mlen);  */
2071 /*    log_printhex ("RSA e:", e, elen);  */
2072
2073   rc = store_fpr (app->slot, keyno, (u32)created_at,
2074                   m, mlen, e, elen, fprbuf, app->card_version);
2075
2076  leave:
2077   return rc;
2078 }
2079
2080
2081 /* Utility function for external tools: Read the public RSA key at
2082    KEYNO and return modulus and exponent in (M,MLEN) and (E,ELEN). */
2083 int 
2084 app_openpgp_readkey (app_t app, int keyno, unsigned char **m, size_t *mlen,
2085                      unsigned char **e, size_t *elen)
2086 {
2087   int rc;
2088   const unsigned char *keydata, *a;
2089   unsigned char *buffer;
2090   size_t buflen, keydatalen, alen;
2091
2092   *m = NULL;
2093   *e = NULL;
2094
2095   if (keyno < 1 || keyno > 3)
2096     return gpg_error (GPG_ERR_INV_ID);
2097   keyno--;
2098
2099   rc = iso7816_read_public_key(app->slot, 
2100                                keyno == 0? "\xB6" :
2101                                keyno == 1? "\xB8" : "\xA4",
2102                                2,
2103                                &buffer, &buflen);
2104   if (rc)
2105     {
2106       rc = gpg_error (GPG_ERR_CARD);
2107       log_error (_("reading the key failed\n"));
2108       goto leave;
2109     }
2110
2111   keydata = find_tlv (buffer, buflen, 0x7F49, &keydatalen);
2112   if (!keydata)
2113     {
2114       log_error (_("response does not contain the public key data\n"));
2115       rc = gpg_error (GPG_ERR_CARD);
2116       goto leave;
2117     }
2118  
2119   a = find_tlv (keydata, keydatalen, 0x0081, &alen);
2120   if (!a)
2121     {
2122       log_error (_("response does not contain the RSA modulus\n"));
2123       rc = gpg_error (GPG_ERR_CARD);
2124       goto leave;
2125     }
2126   *mlen = alen;
2127   *m = xmalloc (alen);
2128   memcpy (*m, a, alen);
2129   
2130   a = find_tlv (keydata, keydatalen, 0x0082, &alen);
2131   if (!a)
2132     {
2133       log_error (_("response does not contain the RSA public exponent\n"));
2134       rc = gpg_error (GPG_ERR_CARD);
2135       goto leave;
2136     }
2137   *elen = alen;
2138   *e = xmalloc (alen);
2139   memcpy (*e, a, alen);
2140
2141  leave:
2142   xfree (buffer);
2143   if (rc)
2144     { 
2145       xfree (*m); *m = NULL;
2146       xfree (*e); *e = NULL;
2147     }
2148   return rc;
2149 }