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