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