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