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