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