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