* command.c (scd_update_reader_status_file): Send a signal back to
[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 gpg_error (gpg_err_code_from_errno (errno));
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, 0,
1125                            outdata, outdatalen);
1126   return rc;
1127 }
1128
1129
1130 /* Perform a simple verify operation for CHV1 and CHV2, so that
1131    further operations won't ask for CHV2 and it is possible to do a
1132    cheap check on the PIN: If there is something wrong with the PIN
1133    entry system, only the regular CHV will get blocked and not the
1134    dangerous CHV3.  KEYIDSTR is the usual card's serial number; an
1135    optional fingerprint part will be ignored. */
1136 static int 
1137 do_check_pin (APP app, const char *keyidstr,
1138               int (pincb)(void*, const char *, char **),
1139               void *pincb_arg)
1140 {
1141   unsigned char tmp_sn[20]; 
1142   const char *s;
1143   int n;
1144
1145   if (!keyidstr || !*keyidstr)
1146     return gpg_error (GPG_ERR_INV_VALUE);
1147
1148   /* Check whether an OpenPGP card of any version has been requested. */
1149   if (strlen (keyidstr) < 32 || strncmp (keyidstr, "D27600012401", 12))
1150     return gpg_error (GPG_ERR_INV_ID);
1151   
1152   for (s=keyidstr, n=0; hexdigitp (s); s++, n++)
1153     ;
1154   if (n != 32)
1155     return gpg_error (GPG_ERR_INV_ID);
1156   else if (!*s)
1157     ; /* No fingerprint given: we allow this for now. */
1158   else if (*s == '/')
1159     ; /* We ignore a fingerprint. */
1160   else
1161     return gpg_error (GPG_ERR_INV_ID);
1162
1163   for (s=keyidstr, n=0; n < 16; s += 2, n++)
1164     tmp_sn[n] = xtoi_2 (s);
1165
1166   if (app->serialnolen != 16)
1167     return gpg_error (GPG_ERR_INV_CARD);
1168   if (memcmp (app->serialno, tmp_sn, 16))
1169     return gpg_error (GPG_ERR_WRONG_CARD);
1170   /* Yes, there is a race conditions: The user might pull the card
1171      right here and we won't notice that.  However this is not a
1172      problem and the check above is merely for a graceful failure
1173      between operations. */
1174
1175   return verify_chv2 (app, pincb, pincb_arg);
1176 }
1177
1178
1179
1180
1181 /* Select the OpenPGP application on the card in SLOT.  This function
1182    must be used before any other OpenPGP application functions. */
1183 int
1184 app_select_openpgp (APP app)
1185 {
1186   static char const aid[] = { 0xD2, 0x76, 0x00, 0x01, 0x24, 0x01 };
1187   int slot = app->slot;
1188   int rc;
1189   unsigned char *buffer;
1190   size_t buflen;
1191   void *relptr;
1192   
1193   rc = iso7816_select_application (slot, aid, sizeof aid);
1194   if (!rc)
1195     {
1196       app->apptype = "OPENPGP";
1197
1198       app->did_chv1 = 0;
1199       app->did_chv2 = 0;
1200       app->did_chv3 = 0;
1201
1202       /* The OpenPGP card returns the serial number as part of the
1203          AID; because we prefer to use OpenPGP serial numbers, we
1204          replace a possibly already set one from a EF.GDO with this
1205          one.  Note, that for current OpenPGP cards, no EF.GDO exists
1206          and thus it won't matter at all. */
1207       rc = iso7816_get_data (slot, 0x004F, &buffer, &buflen);
1208       if (rc)
1209         goto leave;
1210       if (opt.verbose)
1211         {
1212           log_info ("got AID: ");
1213           log_printhex ("", buffer, buflen);
1214         }
1215
1216       app->card_version = buffer[6] << 8;
1217       app->card_version |= buffer[7];
1218       xfree (app->serialno);
1219       app->serialno = buffer;
1220       app->serialnolen = buflen;
1221       buffer = NULL;
1222
1223       relptr = get_one_do (app->slot, 0x00C4, &buffer, &buflen);
1224       if (!relptr)
1225         {
1226           log_error ("can't access CHV Status Bytes - invalid OpenPGP card?\n");
1227           goto leave;
1228         }
1229       app->force_chv1 = (buflen && *buffer == 0);
1230       xfree (relptr);
1231         
1232       if (opt.verbose > 1)
1233         dump_all_do (slot);
1234
1235       app->fnc.learn_status = do_learn_status;
1236       app->fnc.readcert = NULL;
1237       app->fnc.getattr = do_getattr;
1238       app->fnc.setattr = do_setattr;
1239       app->fnc.genkey = do_genkey;
1240       app->fnc.sign = do_sign;
1241       app->fnc.auth = do_auth;
1242       app->fnc.decipher = do_decipher;
1243       app->fnc.change_pin = do_change_pin;
1244       app->fnc.check_pin = do_check_pin;
1245    }
1246
1247 leave:
1248   return rc;
1249 }
1250
1251
1252
1253 /* This function is a hack to retrieve essential information about the
1254    card to be displayed by simple tools.  It mostly resembles what the
1255    LEARN command returns. All parameters return allocated strings or
1256    buffers or NULL if the data object is not available.  All returned
1257    values are sanitized. */
1258 int
1259 app_openpgp_cardinfo (APP app,
1260                       char **serialno,
1261                       char **disp_name,
1262                       char **pubkey_url,
1263                       unsigned char **fpr1,
1264                       unsigned char **fpr2,
1265                       unsigned char **fpr3)
1266 {
1267   int rc;
1268   void *relptr;
1269   unsigned char *value;
1270   size_t valuelen;
1271
1272   if (serialno)
1273     {
1274       time_t dummy;
1275
1276       *serialno = NULL;
1277       rc = app_get_serial_and_stamp (app, serialno, &dummy);
1278       if (rc)
1279         {
1280           log_error ("error getting serial number: %s\n", gpg_strerror (rc));
1281           return rc;
1282         }
1283     }
1284       
1285   if (disp_name)
1286     {
1287       *disp_name = NULL;
1288       relptr = get_one_do (app->slot, 0x005B, &value, &valuelen);
1289       if (relptr)
1290         {
1291           *disp_name = make_printable_string (value, valuelen, 0);
1292           xfree (relptr);
1293         }
1294     }
1295
1296   if (pubkey_url)
1297     {
1298       *pubkey_url = NULL;
1299       relptr = get_one_do (app->slot, 0x5F50, &value, &valuelen);
1300       if (relptr)
1301         {
1302           *pubkey_url = make_printable_string (value, valuelen, 0);
1303           xfree (relptr);
1304         }
1305     }
1306
1307   if (fpr1)
1308     *fpr1 = NULL;
1309   if (fpr2)
1310     *fpr2 = NULL;
1311   if (fpr3)
1312     *fpr3 = NULL;
1313   relptr = get_one_do (app->slot, 0x00C5, &value, &valuelen);
1314   if (relptr && valuelen >= 60)
1315     {
1316       if (fpr1)
1317         {
1318           *fpr1 = xmalloc (20);
1319           memcpy (*fpr1, value +  0, 20);
1320         }
1321       if (fpr2)
1322         {
1323           *fpr2 = xmalloc (20);
1324           memcpy (*fpr2, value + 20, 20);
1325         }
1326       if (fpr3)
1327         {
1328           *fpr3 = xmalloc (20);
1329           memcpy (*fpr3, value + 40, 20);
1330         }
1331     }
1332   xfree (relptr);
1333
1334   return 0;
1335 }
1336
1337
1338
1339 /* This function is currently only used by the sc-copykeys program to
1340    store a key on the smartcard.  APP ist the application handle,
1341    KEYNO is the number of the key and PINCB, PINCB_ARG are used to ask
1342    for the SO PIN.  TEMPLATE and TEMPLATE_LEN describe a buffer with
1343    the key template to store. CREATED_AT is the timestamp used to
1344    create the fingerprint. M, MLEN is the RSA modulus and E, ELEN the
1345    RSA public exponent. This function silently overwrites an existing
1346    key.*/
1347 int 
1348 app_openpgp_storekey (APP app, int keyno,
1349                       unsigned char *template, size_t template_len,
1350                       time_t created_at,
1351                       const unsigned char *m, size_t mlen,
1352                       const unsigned char *e, size_t elen,
1353                       int (*pincb)(void*, const char *, char **),
1354                       void *pincb_arg)
1355 {
1356   int rc;
1357   unsigned char fprbuf[20];
1358
1359   if (keyno < 1 || keyno > 3)
1360     return gpg_error (GPG_ERR_INV_ID);
1361   keyno--;
1362
1363   rc = verify_chv3 (app, pincb, pincb_arg);
1364   if (rc)
1365     goto leave;
1366
1367
1368   rc = iso7816_put_data (app->slot,
1369                          (app->card_version > 0x0007? 0xE0 : 0xE9) + keyno,
1370                          template, template_len);
1371   if (rc)
1372     {
1373       log_error ("failed to store the key: rc=%s\n", gpg_strerror (rc));
1374       rc = gpg_error (GPG_ERR_CARD);
1375       goto leave;
1376     }
1377  
1378 /*    log_printhex ("RSA n:", m, mlen);  */
1379 /*    log_printhex ("RSA e:", e, elen);  */
1380
1381   rc = store_fpr (app->slot, keyno, (u32)created_at,
1382                   m, mlen, e, elen, fprbuf, app->card_version);
1383
1384  leave:
1385   return rc;
1386 }
1387
1388
1389 /* Utility function for external tools: Read the public RSA key at
1390    KEYNO and return modulus and exponent in (M,MLEN) and (E,ELEN). */
1391 int 
1392 app_openpgp_readkey (APP app, int keyno, unsigned char **m, size_t *mlen,
1393                      unsigned char **e, size_t *elen)
1394 {
1395   int rc;
1396   const unsigned char *keydata, *a;
1397   unsigned char *buffer;
1398   size_t buflen, keydatalen, alen;
1399
1400   *m = NULL;
1401   *e = NULL;
1402
1403   if (keyno < 1 || keyno > 3)
1404     return gpg_error (GPG_ERR_INV_ID);
1405   keyno--;
1406
1407   rc = iso7816_read_public_key(app->slot, 
1408                                keyno == 0? "\xB6" :
1409                                keyno == 1? "\xB8" : "\xA4",
1410                                2,
1411                                &buffer, &buflen);
1412   if (rc)
1413     {
1414       rc = gpg_error (GPG_ERR_CARD);
1415       log_error ("reading key failed\n");
1416       goto leave;
1417     }
1418
1419   keydata = find_tlv (buffer, buflen, 0x7F49, &keydatalen);
1420   if (!keydata)
1421     {
1422       log_error ("response does not contain the public key data\n");
1423       rc = gpg_error (GPG_ERR_CARD);
1424       goto leave;
1425     }
1426  
1427   a = find_tlv (keydata, keydatalen, 0x0081, &alen);
1428   if (!a)
1429     {
1430       log_error ("response does not contain the RSA modulus\n");
1431       rc = gpg_error (GPG_ERR_CARD);
1432       goto leave;
1433     }
1434   *mlen = alen;
1435   *m = xmalloc (alen);
1436   memcpy (*m, a, alen);
1437   
1438   a = find_tlv (keydata, keydatalen, 0x0082, &alen);
1439   if (!e)
1440     {
1441       log_error ("response does not contain the RSA public exponent\n");
1442       rc = gpg_error (GPG_ERR_CARD);
1443       goto leave;
1444     }
1445   *elen = alen;
1446   *e = xmalloc (alen);
1447   memcpy (*e, a, alen);
1448
1449  leave:
1450   xfree (buffer);
1451   if (rc)
1452     { 
1453       xfree (*m); *m = NULL;
1454       xfree (*e); *e = NULL;
1455     }
1456   return rc;
1457 }