New. Taken from gnupg 1.9.
[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   int idx;
545   static struct {
546     const char *name;
547     int tag;
548   } table[] = {
549     { "DISP-NAME",    0x005B },
550     { "LOGIN-DATA",   0x005E },
551     { "DISP-LANG",    0x5F2D },
552     { "DISP-SEX",     0x5F35 },
553     { "PUBKEY-URL",   0x5F50 },
554     { "CHV-STATUS-1", 0x00C4 },
555     { "CA-FPR-1",     0x00CA },
556     { "CA-FPR-2",     0x00CB },
557     { "CA-FPR-3",     0x00CC },
558     { NULL, 0 }
559   };
560
561
562   for (idx=0; table[idx].name && strcmp (table[idx].name, name); idx++)
563     ;
564   if (!table[idx].name)
565     return gpg_error (GPG_ERR_INV_NAME); 
566
567   if (!app->did_chv3)
568     {
569       char *pinvalue;
570
571       rc = pincb (pincb_arg, "Admin PIN (CHV3)",
572                   &pinvalue);
573 /*        pinvalue = xstrdup ("12345678"); */
574 /*        rc = 0; */
575       if (rc)
576         {
577           log_info ("PIN callback returned error: %s\n", gpg_strerror (rc));
578           return rc;
579         }
580
581       rc = iso7816_verify (app->slot, 0x83, pinvalue, strlen (pinvalue));
582       xfree (pinvalue);
583       if (rc)
584         {
585           log_error ("verify CHV3 failed\n");
586           rc = gpg_error (GPG_ERR_GENERAL);
587           return rc;
588         }
589       app->did_chv3 = 1;
590     }
591
592   rc = iso7816_put_data (app->slot, table[idx].tag, value, valuelen);
593   if (rc)
594     log_error ("failed to set `%s': %s\n", table[idx].name, gpg_strerror (rc));
595   /* FIXME: If this fails we should *once* try again after
596      doing a verify command, so that in case of a problem with
597      tracking the verify operation we have a fallback. */
598
599   return rc;
600 }
601
602 /* Handle the PASSWD command. */
603 static int 
604 do_change_pin (APP app, CTRL ctrl,  const char *chvnostr, int reset_mode,
605                int (*pincb)(void*, const char *, char **),
606                void *pincb_arg)
607 {
608   int rc = 0;
609   int chvno = atoi (chvnostr);
610   char *pinvalue;
611
612   if (reset_mode && chvno == 3)
613     {
614       rc = gpg_error (GPG_ERR_INV_ID);
615       goto leave;
616     }
617   else if (reset_mode || chvno == 3)
618     {
619       rc = pincb (pincb_arg, "Admin PIN", &pinvalue); 
620       if (rc)
621         {
622           log_error ("error getting PIN: %s\n", gpg_strerror (rc));
623           goto leave;
624         }
625       rc = iso7816_verify (app->slot, 0x83, pinvalue, strlen (pinvalue));
626       xfree (pinvalue);
627       if (rc)
628         {
629           log_error ("verify CHV3 failed: rc=%04X\n", rc);
630           goto leave;
631         }
632     }
633   else if (chvno == 1)
634     {
635       rc = pincb (pincb_arg, "Signature PIN", &pinvalue); 
636       if (rc)
637         {
638           log_error ("error getting PIN: %s\n", gpg_strerror (rc));
639           goto leave;
640         }
641       rc = iso7816_verify (app->slot, 0x81, pinvalue, strlen (pinvalue));
642       xfree (pinvalue);
643       if (rc)
644         {
645           log_error ("verify CHV1 failed: rc=%04X\n", rc);
646           goto leave;
647         }
648     }
649   else if (chvno == 2)
650     {
651       rc = pincb (pincb_arg, "Decryption PIN", &pinvalue); 
652       if (rc)
653         {
654           log_error ("error getting PIN: %s\n", gpg_strerror (rc));
655           goto leave;
656         }
657       rc = iso7816_verify (app->slot, 0x82, pinvalue, strlen (pinvalue));
658       xfree (pinvalue);
659       if (rc)
660         {
661           log_error ("verify CHV2 failed: rc=%04X\n", rc);
662           goto leave;
663         }
664     }
665   else
666     {
667       rc = gpg_error (GPG_ERR_INV_ID);
668       goto leave;
669     }
670
671   
672   rc = pincb (pincb_arg, chvno == 1? "New Signature PIN" :
673                          chvno == 2? "New Decryption PIN" :
674                          chvno == 3? "New Admin PIN" : "?", &pinvalue); 
675   if (rc)
676     {
677       log_error ("error getting new PIN: %s\n", gpg_strerror (rc));
678       goto leave;
679     }
680
681   if (reset_mode)
682     rc = iso7816_reset_retry_counter (app->slot, 0x80 + chvno,
683                                       pinvalue, strlen (pinvalue));
684   else
685     rc = iso7816_change_reference_data (app->slot, 0x80 + chvno,
686                                         NULL, 0,
687                                         pinvalue, strlen (pinvalue));
688   xfree (pinvalue);
689
690
691  leave:
692   return rc;
693 }
694
695
696
697 /* Handle the GENKEY command. */
698 static int 
699 do_genkey (APP app, CTRL ctrl,  const char *keynostr, unsigned int flags,
700           int (*pincb)(void*, const char *, char **),
701           void *pincb_arg)
702 {
703   int rc;
704   int i;
705   char numbuf[30];
706   unsigned char fprbuf[20];
707   const unsigned char *fpr;
708   const unsigned char *keydata, *m, *e;
709   unsigned char *buffer;
710   size_t buflen, keydatalen, n, mlen, elen;
711   time_t created_at;
712   int keyno = atoi (keynostr);
713   int force = (flags & 1);
714   time_t start_at;
715
716   if (keyno < 1 || keyno > 3)
717     return gpg_error (GPG_ERR_INV_ID);
718   keyno--;
719
720   rc = iso7816_get_data (app->slot, 0x006E, &buffer, &buflen);
721   if (rc)
722     {
723       log_error ("error reading application data\n");
724       return gpg_error (GPG_ERR_GENERAL);
725     }
726   fpr = find_tlv (buffer, buflen, 0x00C5, &n, 0);
727   if (!fpr || n != 60)
728     {
729       rc = gpg_error (GPG_ERR_GENERAL);
730       log_error ("error reading fingerprint DO\n");
731       goto leave;
732     }
733   fpr += 20*keyno;
734   for (i=0; i < 20 && !fpr[i]; i++)
735     ;
736   if (i!=20 && !force)
737     {
738       rc = gpg_error (GPG_ERR_EEXIST);
739       log_error ("key already exists\n");
740       goto leave;
741     }
742   else if (i!=20)
743     log_info ("existing key will be replaced\n");
744   else
745     log_info ("generating new key\n");
746
747   {
748     char *pinvalue;
749     rc = pincb (pincb_arg, "Admin PIN", &pinvalue); 
750     if (rc)
751       {
752         log_error ("error getting PIN: %s\n", gpg_strerror (rc));
753         return rc;
754       }
755     rc = iso7816_verify (app->slot, 0x83, pinvalue, strlen (pinvalue));
756     xfree (pinvalue);
757   }
758   if (rc)
759     {
760       log_error ("verify CHV3 failed: rc=%04X\n", rc);
761       goto leave;
762     }
763
764   xfree (buffer); buffer = NULL;
765 #if 1
766   log_info ("please wait while key is being generated ...\n");
767   start_at = time (NULL);
768   rc = iso7816_generate_keypair 
769 #else
770 #warning key generation temporary replaced by reading an existing key.
771   rc = iso7816_read_public_key
772 #endif
773                               (app->slot, 
774                                  keyno == 0? "\xB6" :
775                                  keyno == 1? "\xB8" : "\xA4",
776                                  2,
777                                  &buffer, &buflen);
778   if (rc)
779     {
780       rc = gpg_error (GPG_ERR_CARD);
781       log_error ("generating key failed\n");
782       goto leave;
783     }
784   log_info ("key generation completed (%d seconds)\n",
785             (int)(time (NULL) - start_at));
786   keydata = find_tlv (buffer, buflen, 0x7F49, &keydatalen, 0);
787   if (!keydata)
788     {
789       rc = gpg_error (GPG_ERR_CARD);
790       log_error ("response does not contain the public key data\n");
791       goto leave;
792     }
793  
794   m = find_tlv (keydata, keydatalen, 0x0081, &mlen, 0);
795   if (!m)
796     {
797       rc = gpg_error (GPG_ERR_CARD);
798       log_error ("response does not contain the RSA modulus\n");
799       goto leave;
800     }
801 /*    log_printhex ("RSA n:", m, mlen); */
802   send_key_data (ctrl, "n", m, mlen);
803
804   e = find_tlv (keydata, keydatalen, 0x0082, &elen, 0);
805   if (!e)
806     {
807       rc = gpg_error (GPG_ERR_CARD);
808       log_error ("response does not contain the RSA public exponent\n");
809       goto leave;
810     }
811 /*    log_printhex ("RSA e:", e, elen); */
812   send_key_data (ctrl, "e", e, elen);
813
814   created_at = gnupg_get_time ();
815   sprintf (numbuf, "%lu", (unsigned long)created_at);
816   send_status_info (ctrl, "KEY-CREATED-AT",
817                     numbuf, (size_t)strlen(numbuf), NULL, 0);
818
819   rc = store_fpr (app->slot, keyno, (u32)created_at,
820                   m, mlen, e, elen, fprbuf, app->card_version);
821   if (rc)
822     goto leave;
823   send_fpr_if_not_null (ctrl, "KEY-FPR", -1, fprbuf);
824
825
826  leave:
827   xfree (buffer);
828   return rc;
829 }
830
831
832 static unsigned long
833 get_sig_counter (APP app)
834 {
835   void *relptr;
836   unsigned char *value;
837   size_t valuelen;
838   unsigned long ul;
839
840   relptr = get_one_do (app->slot, 0x0093, &value, &valuelen);
841   if (!relptr)
842     return 0;
843   if (valuelen == 3 )
844     ul = (value[0] << 16) | (value[1] << 8) | value[2];
845   else
846     {
847       log_error ("invalid structure of OpenPGP card (DO 0x93)\n");
848       ul = 0;
849     }
850   xfree (relptr);
851   return ul;
852 }
853
854 static int
855 compare_fingerprint (APP app, int keyno, unsigned char *sha1fpr)
856 {
857   const unsigned char *fpr;
858   unsigned char *buffer;
859   size_t buflen, n;
860   int rc, i;
861   
862   assert (keyno >= 1 && keyno <= 3);
863
864   rc = iso7816_get_data (app->slot, 0x006E, &buffer, &buflen);
865   if (rc)
866     {
867       log_error ("error reading application data\n");
868       return gpg_error (GPG_ERR_GENERAL);
869     }
870   fpr = find_tlv (buffer, buflen, 0x00C5, &n, 0);
871   if (!fpr || n != 60)
872     {
873       xfree (buffer);
874       log_error ("error reading fingerprint DO\n");
875       return gpg_error (GPG_ERR_GENERAL);
876     }
877   fpr += (keyno-1)*20;
878   for (i=0; i < 20; i++)
879     if (sha1fpr[i] != fpr[i])
880       {
881         xfree (buffer);
882         return gpg_error (GPG_ERR_WRONG_SECKEY);
883       }
884   xfree (buffer);
885   return 0;
886 }
887
888
889
890 /* Compute a digital signature on INDATA which is expected to be the
891    raw message digest. For this application the KEYIDSTR consists of
892    the serialnumber and the fingerprint delimited by a slash.
893
894    Note that this fucntion may return the error code
895    GPG_ERR_WRONG_CARD to indicate that the card currently present does
896    not match the one required for the requested action (e.g. the
897    serial number does not match). */
898 static int 
899 do_sign (APP app, const char *keyidstr, int hashalgo,
900          int (*pincb)(void*, const char *, char **),
901          void *pincb_arg,
902          const void *indata, size_t indatalen,
903          unsigned char **outdata, size_t *outdatalen )
904 {
905   static unsigned char sha1_prefix[15] = /* Object ID is 1.3.14.3.2.26 */
906   { 0x30, 0x21, 0x30, 0x09, 0x06, 0x05, 0x2b, 0x0e, 0x03,
907     0x02, 0x1a, 0x05, 0x00, 0x04, 0x14 };
908   static unsigned char rmd160_prefix[15] = /* Object ID is 1.3.36.3.2.1 */
909   { 0x30, 0x21, 0x30, 0x09, 0x06, 0x05, 0x2b, 0x24, 0x03,
910     0x02, 0x01, 0x05, 0x00, 0x04, 0x14 };
911   int rc;
912   unsigned char data[35];
913   unsigned char tmp_sn[20]; /* actually 16 but we use it also for the fpr. */
914   const char *s;
915   int n;
916   const char *fpr = NULL;
917   unsigned long sigcount;
918
919   if (!keyidstr || !*keyidstr)
920     return gpg_error (GPG_ERR_INV_VALUE);
921   if (indatalen != 20)
922     return gpg_error (GPG_ERR_INV_VALUE);
923
924   /* Check whether an OpenPGP card of any version has been requested. */
925   if (strlen (keyidstr) < 32 || strncmp (keyidstr, "D27600012401", 12))
926     return gpg_error (GPG_ERR_INV_ID);
927   
928   for (s=keyidstr, n=0; hexdigitp (s); s++, n++)
929     ;
930   if (n != 32)
931     return gpg_error (GPG_ERR_INV_ID);
932   else if (!*s)
933     ; /* no fingerprint given: we allow this for now. */
934   else if (*s == '/')
935     fpr = s + 1; 
936   else
937     return gpg_error (GPG_ERR_INV_ID);
938
939   for (s=keyidstr, n=0; n < 16; s += 2, n++)
940     tmp_sn[n] = xtoi_2 (s);
941
942   if (app->serialnolen != 16)
943     return gpg_error (GPG_ERR_INV_CARD);
944   if (memcmp (app->serialno, tmp_sn, 16))
945     return gpg_error (GPG_ERR_WRONG_CARD);
946
947   /* If a fingerprint has been specified check it against the one on
948      the card.  This is allows for a meaningful error message in case
949      the key on the card has been replaced but the shadow information
950      known to gpg was not updated.  If there is no fingerprint, gpg
951      will detect a bogus signature anyway due to the
952      verify-after-signing feature. */
953   if (fpr)
954     {
955       for (s=fpr, n=0; hexdigitp (s); s++, n++)
956         ;
957       if (n != 40)
958         return gpg_error (GPG_ERR_INV_ID);
959       else if (!*s)
960         ; /* okay */
961       else
962         return gpg_error (GPG_ERR_INV_ID);
963
964       for (s=fpr, n=0; n < 20; s += 2, n++)
965         tmp_sn[n] = xtoi_2 (s);
966       rc = compare_fingerprint (app, 1, tmp_sn);
967       if (rc)
968         return rc;
969     }
970
971   if (hashalgo == GCRY_MD_SHA1)
972     memcpy (data, sha1_prefix, 15);
973   else if (hashalgo == GCRY_MD_RMD160)
974     memcpy (data, rmd160_prefix, 15);
975   else 
976     return gpg_error (GPG_ERR_UNSUPPORTED_ALGORITHM);
977   memcpy (data+15, indata, indatalen);
978
979   sigcount = get_sig_counter (app);
980   log_info ("signatures created so far: %lu\n", sigcount);
981
982   /* FIXME: Check whether we are really required to enter the PIN for
983      each signature. There is a DO for this. */
984   if (!app->did_chv1 || 1) 
985     {
986       char *pinvalue;
987
988       {
989         char *prompt;
990         if (asprintf (&prompt, "Signature PIN [sigs done: %lu]", sigcount) < 0)
991           return gpg_error_from_errno (errno);
992         rc = pincb (pincb_arg, prompt, &pinvalue); 
993         free (prompt);
994       }
995 /*        pinvalue = xstrdup ("123456"); */
996 /*        rc = 0; */
997       if (rc)
998         {
999           log_info ("PIN callback returned error: %s\n", gpg_strerror (rc));
1000           return rc;
1001         }
1002
1003       rc = iso7816_verify (app->slot, 0x81, pinvalue, strlen (pinvalue));
1004       xfree (pinvalue);
1005       if (rc)
1006         {
1007           log_error ("verify CHV1 failed\n");
1008           rc = gpg_error (GPG_ERR_GENERAL);
1009           return rc;
1010         }
1011       app->did_chv1 = 1;
1012     }
1013
1014   rc = iso7816_compute_ds (app->slot, data, 35, outdata, outdatalen);
1015   return rc;
1016 }
1017
1018 /* Compute a digital signature using the INTERNAL AUTHENTICATE command
1019    on INDATA which is expected to be the raw message digest. For this
1020    application the KEYIDSTR consists of the serialnumber and the
1021    fingerprint delimited by a slash.
1022
1023    Note that this fucntion may return the error code
1024    GPG_ERR_WRONG_CARD to indicate that the card currently present does
1025    not match the one required for the requested action (e.g. the
1026    serial number does not match). */
1027 static int 
1028 do_auth (APP app, const char *keyidstr,
1029          int (*pincb)(void*, const char *, char **),
1030          void *pincb_arg,
1031          const void *indata, size_t indatalen,
1032          unsigned char **outdata, size_t *outdatalen )
1033 {
1034   int rc;
1035   unsigned char tmp_sn[20]; /* actually 16 but we use it also for the fpr. */
1036   const char *s;
1037   int n;
1038   const char *fpr = NULL;
1039
1040   if (!keyidstr || !*keyidstr)
1041     return gpg_error (GPG_ERR_INV_VALUE);
1042   if (indatalen > 50) /* For a 1024 bit key. */
1043     return gpg_error (GPG_ERR_INV_VALUE);
1044
1045   /* Check whether an OpenPGP card of any version has been requested. */
1046   if (strlen (keyidstr) < 32 || strncmp (keyidstr, "D27600012401", 12))
1047     return gpg_error (GPG_ERR_INV_ID);
1048   
1049   for (s=keyidstr, n=0; hexdigitp (s); s++, n++)
1050     ;
1051   if (n != 32)
1052     return gpg_error (GPG_ERR_INV_ID);
1053   else if (!*s)
1054     ; /* no fingerprint given: we allow this for now. */
1055   else if (*s == '/')
1056     fpr = s + 1; 
1057   else
1058     return gpg_error (GPG_ERR_INV_ID);
1059
1060   for (s=keyidstr, n=0; n < 16; s += 2, n++)
1061     tmp_sn[n] = xtoi_2 (s);
1062
1063   if (app->serialnolen != 16)
1064     return gpg_error (GPG_ERR_INV_CARD);
1065   if (memcmp (app->serialno, tmp_sn, 16))
1066     return gpg_error (GPG_ERR_WRONG_CARD);
1067
1068   /* If a fingerprint has been specified check it against the one on
1069      the card.  This is allows for a meaningful error message in case
1070      the key on the card has been replaced but the shadow information
1071      known to gpg was not updated.  If there is no fingerprint, gpg
1072      will detect a bogus signature anyway due to the
1073      verify-after-signing feature. */
1074   if (fpr)
1075     {
1076       for (s=fpr, n=0; hexdigitp (s); s++, n++)
1077         ;
1078       if (n != 40)
1079         return gpg_error (GPG_ERR_INV_ID);
1080       else if (!*s)
1081         ; /* okay */
1082       else
1083         return gpg_error (GPG_ERR_INV_ID);
1084
1085       for (s=fpr, n=0; n < 20; s += 2, n++)
1086         tmp_sn[n] = xtoi_2 (s);
1087       rc = compare_fingerprint (app, 3, tmp_sn);
1088       if (rc)
1089         return rc;
1090     }
1091
1092   if (!app->did_chv2) 
1093     {
1094       char *pinvalue;
1095
1096       rc = pincb (pincb_arg, "Authentication/Decryption PIN", &pinvalue); 
1097       if (rc)
1098         {
1099           log_info ("PIN callback returned error: %s\n", gpg_strerror (rc));
1100           return rc;
1101         }
1102
1103       rc = iso7816_verify (app->slot, 0x82, pinvalue, strlen (pinvalue));
1104       xfree (pinvalue);
1105       if (rc)
1106         {
1107           log_error ("verify CHV2 failed\n");
1108           rc = gpg_error (GPG_ERR_GENERAL);
1109           return rc;
1110         }
1111       app->did_chv2 = 1;
1112     }
1113
1114   rc = iso7816_internal_authenticate (app->slot, indata, indatalen,
1115                                       outdata, outdatalen);
1116   return rc;
1117 }
1118
1119
1120 static int 
1121 do_decipher (APP app, const char *keyidstr,
1122              int (pincb)(void*, const char *, char **),
1123              void *pincb_arg,
1124              const void *indata, size_t indatalen,
1125              unsigned char **outdata, size_t *outdatalen )
1126 {
1127   int rc;
1128   unsigned char tmp_sn[20]; /* actually 16 but we use it also for the fpr. */
1129   const char *s;
1130   int n;
1131   const char *fpr = NULL;
1132
1133   if (!keyidstr || !*keyidstr || !indatalen)
1134     return gpg_error (GPG_ERR_INV_VALUE);
1135
1136   /* Check whether an OpenPGP card of any version has been requested. */
1137   if (strlen (keyidstr) < 32 || strncmp (keyidstr, "D27600012401", 12))
1138     return gpg_error (GPG_ERR_INV_ID);
1139   
1140   for (s=keyidstr, n=0; hexdigitp (s); s++, n++)
1141     ;
1142   if (n != 32)
1143     return gpg_error (GPG_ERR_INV_ID);
1144   else if (!*s)
1145     ; /* no fingerprint given: we allow this for now. */
1146   else if (*s == '/')
1147     fpr = s + 1; 
1148   else
1149     return gpg_error (GPG_ERR_INV_ID);
1150
1151   for (s=keyidstr, n=0; n < 16; s += 2, n++)
1152     tmp_sn[n] = xtoi_2 (s);
1153
1154   if (app->serialnolen != 16)
1155     return gpg_error (GPG_ERR_INV_CARD);
1156   if (memcmp (app->serialno, tmp_sn, 16))
1157     return gpg_error (GPG_ERR_WRONG_CARD);
1158
1159   /* If a fingerprint has been specified check it against the one on
1160      the card.  This is allows for a meaningful error message in case
1161      the key on the card has been replaced but the shadow information
1162      known to gpg was not updated.  If there is no fingerprint, the
1163      decryption will won't produce the right plaintext anyway. */
1164   if (fpr)
1165     {
1166       for (s=fpr, n=0; hexdigitp (s); s++, n++)
1167         ;
1168       if (n != 40)
1169         return gpg_error (GPG_ERR_INV_ID);
1170       else if (!*s)
1171         ; /* okay */
1172       else
1173         return gpg_error (GPG_ERR_INV_ID);
1174
1175       for (s=fpr, n=0; n < 20; s += 2, n++)
1176         tmp_sn[n] = xtoi_2 (s);
1177       rc = compare_fingerprint (app, 2, tmp_sn);
1178       if (rc)
1179         return rc;
1180     }
1181
1182   if (!app->did_chv2) 
1183     {
1184       char *pinvalue;
1185
1186       rc = pincb (pincb_arg, "Decryption PIN", &pinvalue); 
1187 /*        pinvalue = xstrdup ("123456"); */
1188 /*        rc = 0; */
1189       if (rc)
1190         {
1191           log_info ("PIN callback returned error: %s\n", gpg_strerror (rc));
1192           return rc;
1193         }
1194
1195       rc = iso7816_verify (app->slot, 0x82, pinvalue, strlen (pinvalue));
1196       xfree (pinvalue);
1197       if (rc)
1198         {
1199           log_error ("verify CHV2 failed\n");
1200           rc = gpg_error (GPG_ERR_GENERAL);
1201           return rc;
1202         }
1203       app->did_chv2 = 1;
1204     }
1205   
1206   rc = iso7816_decipher (app->slot, indata, indatalen, outdata, outdatalen);
1207   return rc;
1208 }
1209
1210
1211
1212
1213 /* Select the OpenPGP application on the card in SLOT.  This function
1214    must be used before any other OpenPGP application functions. */
1215 int
1216 app_select_openpgp (APP app, unsigned char **sn, size_t *snlen)
1217 {
1218   static char const aid[] = { 0xD2, 0x76, 0x00, 0x01, 0x24, 0x01 };
1219   int slot = app->slot;
1220   int rc;
1221   unsigned char *buffer;
1222   size_t buflen;
1223   
1224   rc = iso7816_select_application (slot, aid, sizeof aid);
1225   if (!rc)
1226     {
1227       /* fixme: get the full AID and check that the version is okay
1228          with us. */
1229       rc = iso7816_get_data (slot, 0x004F, &buffer, &buflen);
1230       if (rc)
1231         goto leave;
1232       if (opt.verbose)
1233         {
1234           log_info ("got AID: ");
1235           log_printhex ("", buffer, buflen);
1236         }
1237
1238       if (sn)
1239         {
1240           *sn = buffer;
1241           *snlen = buflen;
1242           app->card_version = buffer[6] << 8;
1243           app->card_version |= buffer[7];
1244         }
1245       else
1246         xfree (buffer);
1247
1248       if (opt.verbose > 1)
1249         dump_all_do (slot);
1250
1251       app->fnc.learn_status = do_learn_status;
1252       app->fnc.setattr = do_setattr;
1253       app->fnc.genkey = do_genkey;
1254       app->fnc.sign = do_sign;
1255       app->fnc.auth = do_auth;
1256       app->fnc.decipher = do_decipher;
1257       app->fnc.change_pin = do_change_pin;
1258    }
1259
1260 leave:
1261   return rc;
1262 }
1263
1264
1265
1266 /* This function is a hack to retrieve essential information about the
1267    card to be displayed by simple tools.  It mostly resembles what the
1268    LEARN command returns. All parameters return allocated strings or
1269    buffers or NULL if the data object is not available.  All returned
1270    values are sanitized. */
1271 int
1272 app_openpgp_cardinfo (APP app,
1273                       char **serialno,
1274                       char **disp_name,
1275                       char **pubkey_url,
1276                       unsigned char **fpr1,
1277                       unsigned char **fpr2,
1278                       unsigned char **fpr3)
1279 {
1280   int rc;
1281   void *relptr;
1282   unsigned char *value;
1283   size_t valuelen;
1284
1285   if (serialno)
1286     {
1287       time_t dummy;
1288
1289       *serialno = NULL;
1290       rc = app_get_serial_and_stamp (app, serialno, &dummy);
1291       if (rc)
1292         {
1293           log_error ("error getting serial number: %s\n", gpg_strerror (rc));
1294           return rc;
1295         }
1296     }
1297       
1298   if (disp_name)
1299     {
1300       *disp_name = NULL;
1301       relptr = get_one_do (app->slot, 0x005B, &value, &valuelen);
1302       if (relptr)
1303         {
1304           *disp_name = make_printable_string (value, valuelen, 0);
1305           xfree (relptr);
1306         }
1307     }
1308
1309   if (pubkey_url)
1310     {
1311       *pubkey_url = NULL;
1312       relptr = get_one_do (app->slot, 0x5F50, &value, &valuelen);
1313       if (relptr)
1314         {
1315           *pubkey_url = make_printable_string (value, valuelen, 0);
1316           xfree (relptr);
1317         }
1318     }
1319
1320   if (fpr1)
1321     *fpr1 = NULL;
1322   if (fpr2)
1323     *fpr2 = NULL;
1324   if (fpr3)
1325     *fpr3 = NULL;
1326   relptr = get_one_do (app->slot, 0x00C5, &value, &valuelen);
1327   if (relptr && valuelen >= 60)
1328     {
1329       if (fpr1)
1330         {
1331           *fpr1 = xmalloc (20);
1332           memcpy (*fpr1, value +  0, 20);
1333         }
1334       if (fpr2)
1335         {
1336           *fpr2 = xmalloc (20);
1337           memcpy (*fpr2, value + 20, 20);
1338         }
1339       if (fpr3)
1340         {
1341           *fpr3 = xmalloc (20);
1342           memcpy (*fpr3, value + 40, 20);
1343         }
1344     }
1345   xfree (relptr);
1346
1347   return 0;
1348 }
1349
1350
1351
1352 /* This function is currently only used by the sc-copykeys program to
1353    store a key on the smartcard.  APP ist the application handle,
1354    KEYNO is the number of the key and PINCB, PINCB_ARG are used to ask
1355    for the SO PIN.  TEMPLATE and TEMPLATE_LEN describe a buffer with
1356    the key template to store. CREATED_AT is the timestamp used to
1357    create the fingerprint. M, MLEN is the RSA modulus and E, ELEN the
1358    RSA public exponent. This function silently overwrites an existing
1359    key.*/
1360 int 
1361 app_openpgp_storekey (APP app, int keyno,
1362                       unsigned char *template, size_t template_len,
1363                       time_t created_at,
1364                       const unsigned char *m, size_t mlen,
1365                       const unsigned char *e, size_t elen,
1366                       int (*pincb)(void*, const char *, char **),
1367                       void *pincb_arg)
1368 {
1369   int rc;
1370   unsigned char fprbuf[20];
1371
1372   if (keyno < 1 || keyno > 3)
1373     return gpg_error (GPG_ERR_INV_ID);
1374   keyno--;
1375
1376   {
1377     char *pinvalue;
1378     rc = pincb (pincb_arg, "Admin PIN", &pinvalue); 
1379     if (rc)
1380       {
1381         log_error ("error getting PIN: %s\n", gpg_strerror (rc));
1382         return rc;
1383       }
1384     rc = iso7816_verify (app->slot, 0x83, pinvalue, strlen (pinvalue));
1385     xfree (pinvalue);
1386   }
1387   if (rc)
1388     {
1389       log_error ("verify CHV3 failed: rc=%04X\n", rc);
1390       goto leave;
1391     }
1392
1393   rc = iso7816_put_data (app->slot,
1394                          (app->card_version > 0x0007? 0xE0 : 0xE9) + keyno,
1395                          template, template_len);
1396   if (rc)
1397     {
1398       log_error ("failed to store the key: rc=%04X\n", rc);
1399       rc = gpg_error (GPG_ERR_CARD);
1400       goto leave;
1401     }
1402  
1403 /*    log_printhex ("RSA n:", m, mlen);  */
1404 /*    log_printhex ("RSA e:", e, elen);  */
1405
1406   rc = store_fpr (app->slot, keyno, (u32)created_at,
1407                   m, mlen, e, elen, fprbuf, app->card_version);
1408
1409  leave:
1410   return rc;
1411 }
1412
1413
1414 /* Utility function for external tools: Read the public RSA key at
1415    KEYNO and return modulus and exponent in (M,MLEN) and (E,ELEN). */
1416 int 
1417 app_openpgp_readkey (APP app, int keyno, unsigned char **m, size_t *mlen,
1418                      unsigned char **e, size_t *elen)
1419 {
1420   int rc;
1421   const unsigned char *keydata, *a;
1422   unsigned char *buffer;
1423   size_t buflen, keydatalen, alen;
1424
1425   *m = NULL;
1426   *e = NULL;
1427
1428   if (keyno < 1 || keyno > 3)
1429     return gpg_error (GPG_ERR_INV_ID);
1430   keyno--;
1431
1432   rc = iso7816_read_public_key(app->slot, 
1433                                keyno == 0? "\xB6" :
1434                                keyno == 1? "\xB8" : "\xA4",
1435                                2,
1436                                &buffer, &buflen);
1437   if (rc)
1438     {
1439       rc = gpg_error (GPG_ERR_CARD);
1440       log_error ("reading key failed\n");
1441       goto leave;
1442     }
1443
1444   keydata = find_tlv (buffer, buflen, 0x7F49, &keydatalen, 0);
1445   if (!keydata)
1446     {
1447       log_error ("response does not contain the public key data\n");
1448       rc = gpg_error (GPG_ERR_CARD);
1449       goto leave;
1450     }
1451  
1452   a = find_tlv (keydata, keydatalen, 0x0081, &alen, 0);
1453   if (!a)
1454     {
1455       log_error ("response does not contain the RSA modulus\n");
1456       rc = gpg_error (GPG_ERR_CARD);
1457       goto leave;
1458     }
1459   *mlen = alen;
1460   *m = xmalloc (alen);
1461   memcpy (*m, a, alen);
1462   
1463   a = find_tlv (keydata, keydatalen, 0x0082, &alen, 0);
1464   if (!e)
1465     {
1466       log_error ("response does not contain the RSA public exponent\n");
1467       rc = gpg_error (GPG_ERR_CARD);
1468       goto leave;
1469     }
1470   *elen = alen;
1471   *e = xmalloc (alen);
1472   memcpy (*e, a, alen);
1473
1474  leave:
1475   xfree (buffer);
1476   if (rc)
1477     { 
1478       xfree (*m); *m = NULL;
1479       xfree (*e); *e = NULL;
1480     }
1481   return rc;
1482 }