6ebc13704c2fd8c8e7ace0ae375f2451891a311f
[gnupg.git] / scd / app-openpgp.c
1 /* app-openpgp.c - The OpenPGP card application.
2  *      Copyright (C) 2003, 2004, 2005 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  * $Id$
21  */
22
23 #include <config.h>
24 #include <errno.h>
25 #include <stdio.h>
26 #include <stdlib.h>
27 #include <string.h>
28 #include <assert.h>
29 #include <time.h>
30
31 #if GNUPG_MAJOR_VERSION == 1
32 /* This is used with GnuPG version < 1.9.  The code has been source
33    copied from the current GnuPG >= 1.9  and is maintained over
34    there. */
35 #include "options.h"
36 #include "errors.h"
37 #include "memory.h"
38 #include "util.h"
39 #include "cardglue.h"
40 #else /* GNUPG_MAJOR_VERSION != 1 */
41 #include "scdaemon.h"
42 #endif /* GNUPG_MAJOR_VERSION != 1 */
43
44 #include "i18n.h"
45 #include "iso7816.h"
46 #include "app-common.h"
47 #include "tlv.h"
48
49
50 static struct {
51   int tag;
52   int constructed;
53   int get_from;  /* Constructed DO with this DO or 0 for direct access. */
54   int binary;
55   int dont_cache;
56   int flush_on_error;
57   int get_immediate_in_v11; /* Enable a hack to bypass the cache of
58                                this data object if it is used in 1.1
59                                and later versions of the card.  This
60                                does not work with composite DO and is
61                                currently only useful for the CHV
62                                status bytes. */
63   char *desc;
64 } data_objects[] = {
65   { 0x005E, 0,    0, 1, 0, 0, 0, "Login Data" },
66   { 0x5F50, 0,    0, 0, 0, 0, 0, "URL" },
67   { 0x0065, 1,    0, 1, 0, 0, 0, "Cardholder Related Data"},
68   { 0x005B, 0, 0x65, 0, 0, 0, 0, "Name" },
69   { 0x5F2D, 0, 0x65, 0, 0, 0, 0, "Language preferences" },
70   { 0x5F35, 0, 0x65, 0, 0, 0, 0, "Sex" },
71   { 0x006E, 1,    0, 1, 0, 0, 0, "Application Related Data" },
72   { 0x004F, 0, 0x6E, 1, 0, 0, 0, "AID" },
73   { 0x0073, 1,    0, 1, 0, 0, 0, "Discretionary Data Objects" },
74   { 0x0047, 0, 0x6E, 1, 1, 0, 0, "Card Capabilities" },
75   { 0x00C0, 0, 0x6E, 1, 1, 0, 0, "Extended Card Capabilities" },
76   { 0x00C1, 0, 0x6E, 1, 1, 0, 0, "Algorithm Attributes Signature" },
77   { 0x00C2, 0, 0x6E, 1, 1, 0, 0, "Algorithm Attributes Decryption" },
78   { 0x00C3, 0, 0x6E, 1, 1, 0, 0, "Algorithm Attributes Authentication" },
79   { 0x00C4, 0, 0x6E, 1, 0, 1, 1, "CHV Status Bytes" },
80   { 0x00C5, 0, 0x6E, 1, 0, 0, 0, "Fingerprints" },
81   { 0x00C6, 0, 0x6E, 1, 0, 0, 0, "CA Fingerprints" },
82   { 0x00CD, 0, 0x6E, 1, 0, 0, 0, "Generation time" },
83   { 0x007A, 1,    0, 1, 0, 0, 0, "Security Support Template" },
84   { 0x0093, 0, 0x7A, 1, 1, 0, 0, "Digital Signature Counter" },
85   { 0x0101, 0,    0, 0, 0, 0, 0, "Private DO 1"},
86   { 0x0102, 0,    0, 0, 0, 0, 0, "Private DO 2"},
87   { 0x0103, 0,    0, 0, 0, 0, 0, "Private DO 3"},
88   { 0x0104, 0,    0, 0, 0, 0, 0, "Private DO 4"},
89   { 0 }
90 };
91
92
93 /* One cache item for DOs.  */
94 struct cache_s {
95   struct cache_s *next;
96   int tag;
97   size_t length;
98   unsigned char data[1];
99 };
100
101
102 /* Object with application (i.e. OpenPGP card) specific data.  */
103 struct app_local_s {
104   /* A linked list with cached DOs.  */
105   struct cache_s *cache;
106   
107   /* Keep track of the public keys.  */
108   struct
109   {
110     int read_done;   /* True if we have at least tried to read them.  */
111     gcry_sexp_t key; /* Might be NULL if key is not available.  */
112   } pk[3];
113
114   /* Keep track of card capabilities.  */
115   struct 
116   {
117     unsigned int get_challenge:1;
118     unsigned int key_import:1;
119     unsigned int change_force_chv:1;
120     unsigned int private_dos:1;
121   } extcap;
122
123   /* Flags used to control the application.  */
124   struct
125   {
126     unsigned int no_sync:1;   /* Do not sync CHV1 and CHV2 */
127     unsigned int def_chv2:1;  /* Use 123456 for CHV2.  */
128   } flags;
129 };
130
131
132
133 /***** Local prototypes  *****/
134 static unsigned long convert_sig_counter_value (const unsigned char *value,
135                                                 size_t valuelen);
136 static unsigned long get_sig_counter (app_t app);
137
138
139
140
141 \f
142 /* Deconstructor. */
143 static void
144 do_deinit (app_t app)
145 {
146   if (app && app->app_local)
147     {
148       struct cache_s *c, *c2;
149       int i;
150
151       for (c = app->app_local->cache; c; c = c2)
152         {
153           c2 = c->next;
154           xfree (c);
155         }
156
157       for (i=0; i < DIM (app->app_local->pk); i++)
158         {
159           gcry_sexp_release (app->app_local->pk[i].key);
160           app->app_local->pk[i].read_done = 0;
161         }
162       xfree (app->app_local);
163       app->app_local = NULL;
164     }
165 }
166
167
168 /* Wrapper around iso7816_get_data which first tries to get the data
169    from the cache.  With GET_IMMEDIATE passed as true, the cache is
170    bypassed. */
171 static gpg_error_t
172 get_cached_data (app_t app, int tag, 
173                  unsigned char **result, size_t *resultlen,
174                  int get_immediate)
175 {
176   gpg_error_t err;
177   int i;
178   unsigned char *p;
179   size_t len;
180   struct cache_s *c;
181
182   *result = NULL;
183   *resultlen = 0;
184
185   if (!get_immediate)
186     {
187       for (c=app->app_local->cache; c; c = c->next)
188         if (c->tag == tag)
189           {
190             if(c->length)
191               {
192                 p = xtrymalloc (c->length);
193                 if (!p)
194                   return gpg_error (gpg_err_code_from_errno (errno));
195                 memcpy (p, c->data, c->length);
196                 *result = p;
197               }
198             
199             *resultlen = c->length;
200             
201             return 0;
202           }
203     }
204   
205   err = iso7816_get_data (app->slot, tag, &p, &len);
206   if (err)
207     return err;
208   *result = p;
209   *resultlen = len;
210
211   /* Check whether we should cache this object. */
212   if (get_immediate)
213     return 0;
214
215   for (i=0; data_objects[i].tag; i++)
216     if (data_objects[i].tag == tag)
217       {
218         if (data_objects[i].dont_cache)
219           return 0;
220         break;
221       }
222
223   /* Okay, cache it. */
224   for (c=app->app_local->cache; c; c = c->next)
225     assert (c->tag != tag);
226   
227   c = xtrymalloc (sizeof *c + len);
228   if (c)
229     {
230       memcpy (c->data, p, len);
231       c->length = len;
232       c->tag = tag;
233       c->next = app->app_local->cache;
234       app->app_local->cache = c;
235     }
236
237   return 0;
238 }
239
240 /* Remove DO at TAG from the cache. */
241 static void
242 flush_cache_item (app_t app, int tag)
243 {
244   struct cache_s *c, *cprev;
245   int i;
246
247   if (!app->app_local)
248     return;
249
250   for (c=app->app_local->cache, cprev=NULL; c ; cprev=c, c = c->next)
251     if (c->tag == tag)
252       {
253         if (cprev)
254           cprev->next = c->next;
255         else
256           app->app_local->cache = c->next;
257         xfree (c);
258
259         for (c=app->app_local->cache; c ; c = c->next)
260           {
261             assert (c->tag != tag); /* Oops: duplicated entry. */
262           }
263         return;
264       }
265
266   /* Try again if we have an outer tag. */
267   for (i=0; data_objects[i].tag; i++)
268     if (data_objects[i].tag == tag && data_objects[i].get_from
269         && data_objects[i].get_from != tag)
270       flush_cache_item (app, data_objects[i].get_from);
271 }
272
273 /* Flush all entries from the cache which might be out of sync after
274    an error. */
275 static void
276 flush_cache_after_error (app_t app)
277 {
278   int i;
279
280   for (i=0; data_objects[i].tag; i++)
281     if (data_objects[i].flush_on_error)
282       flush_cache_item (app, data_objects[i].tag);
283 }
284
285
286 /* Flush the entire cache. */
287 static void
288 flush_cache (app_t app)
289 {
290   if (app && app->app_local)
291     {
292       struct cache_s *c, *c2;
293
294       for (c = app->app_local->cache; c; c = c2)
295         {
296           c2 = c->next;
297           xfree (c);
298         }
299       app->app_local->cache = NULL;
300     }
301 }
302
303
304 /* Get the DO identified by TAG from the card in SLOT and return a
305    buffer with its content in RESULT and NBYTES.  The return value is
306    NULL if not found or a pointer which must be used to release the
307    buffer holding value. */
308 static void *
309 get_one_do (app_t app, int tag, unsigned char **result, size_t *nbytes,
310             int *r_rc)
311 {
312   int rc, i;
313   unsigned char *buffer;
314   size_t buflen;
315   unsigned char *value;
316   size_t valuelen;
317   int dummyrc;
318
319   if (!r_rc)
320     r_rc = &dummyrc;
321
322   *result = NULL;
323   *nbytes = 0;
324   *r_rc = 0;
325   for (i=0; data_objects[i].tag && data_objects[i].tag != tag; i++)
326     ;
327
328   if (app->card_version > 0x0100 && data_objects[i].get_immediate_in_v11)
329     {
330       rc = iso7816_get_data (app->slot, tag, &buffer, &buflen);
331       if (rc)
332         {
333           *r_rc = rc;
334           return NULL;
335         }
336       *result = buffer;
337       *nbytes = buflen;
338       return buffer;
339     }
340
341   value = NULL;
342   rc = -1;
343   if (data_objects[i].tag && data_objects[i].get_from)
344     {
345       rc = get_cached_data (app, data_objects[i].get_from,
346                             &buffer, &buflen,
347                             (data_objects[i].dont_cache 
348                              || data_objects[i].get_immediate_in_v11));
349       if (!rc)
350         {
351           const unsigned char *s;
352
353           s = find_tlv (buffer, buflen, tag, &valuelen);
354           if (!s)
355             value = NULL; /* not found */
356           else if (valuelen > buflen - (s - buffer))
357             {
358               log_error ("warning: constructed DO too short\n");
359               value = NULL;
360               xfree (buffer); buffer = NULL;
361             }
362           else
363             value = buffer + (s - buffer);
364         }
365     }
366
367   if (!value) /* Not in a constructed DO, try simple. */
368     {
369       rc = get_cached_data (app, tag, &buffer, &buflen,
370                             (data_objects[i].dont_cache 
371                              || data_objects[i].get_immediate_in_v11));
372       if (!rc)
373         {
374           value = buffer;
375           valuelen = buflen;
376         }
377     }
378
379   if (!rc)
380     {
381       *nbytes = valuelen;
382       *result = value;
383       return buffer;
384     }
385   *r_rc = rc;
386   return NULL;
387 }
388
389
390 static void
391 dump_all_do (int slot)
392 {
393   int rc, i, j;
394   unsigned char *buffer;
395   size_t buflen;
396   
397   for (i=0; data_objects[i].tag; i++)
398     {
399       if (data_objects[i].get_from)
400         continue;
401
402       rc = iso7816_get_data (slot, data_objects[i].tag, &buffer, &buflen);
403       if (gpg_err_code (rc) == GPG_ERR_NO_OBJ)
404         ;
405       else if (rc) 
406         log_info ("DO `%s' not available: %s\n",
407                   data_objects[i].desc, gpg_strerror (rc));
408       else
409         {
410           if (data_objects[i].binary)
411             {
412               log_info ("DO `%s': ", data_objects[i].desc);
413               log_printhex ("", buffer, buflen);
414             }
415           else
416             log_info ("DO `%s': `%.*s'\n",
417                       data_objects[i].desc,
418                       (int)buflen, buffer); /* FIXME: sanitize */
419
420           if (data_objects[i].constructed)
421             {
422               for (j=0; data_objects[j].tag; j++)
423                 {
424                   const unsigned char *value;
425                   size_t valuelen;
426                   
427                   if (j==i || data_objects[i].tag != data_objects[j].get_from)
428                     continue;
429                   value = find_tlv (buffer, buflen,
430                                     data_objects[j].tag, &valuelen);
431                   if (!value)
432                     ; /* not found */
433                   else if (valuelen > buflen - (value - buffer))
434                     log_error ("warning: constructed DO too short\n");
435                   else
436                     {
437                       if (data_objects[j].binary)
438                         {
439                           log_info ("DO `%s': ", data_objects[j].desc);
440                           log_printhex ("", value, valuelen);
441                         }
442                       else
443                         log_info ("DO `%s': `%.*s'\n",
444                                   data_objects[j].desc,
445                                   (int)valuelen, value); /* FIXME: sanitize */
446                     }
447                 }
448             }
449         }
450       xfree (buffer); buffer = NULL;
451     }
452 }
453
454
455 /* Count the number of bits, assuming the A represents an unsigned big
456    integer of length LEN bytes. */
457 static unsigned int
458 count_bits (const unsigned char *a, size_t len)
459 {
460   unsigned int n = len * 8;
461   int i;
462
463   for (; len && !*a; len--, a++, n -=8)
464     ;
465   if (len)
466     {
467       for (i=7; i && !(*a & (1<<i)); i--)
468         n--;
469     }
470   return n;
471 }
472
473 /* GnuPG makes special use of the login-data DO, this fucntion parses
474    the login data to store the flags for later use.  It may be called
475    at any time and should be called after changing the login-data DO.
476
477    Everything up to a LF is considered a mailbox or account name.  If
478    the first LF is followed by DC4 (0x14) control sequence are
479    expected up to the next LF.  Control sequences are separated by FS
480    (0x28) and consist of key=value pairs.  There is one key defined:
481
482     F=<flags>
483
484     Were FLAGS is a plain hexadecimal number representing flag values.
485     The lsb is here the rightmost bit.  Defined flags bits are:
486
487       Bit 0 = CHV1 and CHV2 are not syncronized
488       Bit 1 = CHV2 has been been set to the default PIN of "123456"
489               (this implies that bit 0 is also set).
490
491 */
492 static void
493 parse_login_data (app_t app)
494 {
495   unsigned char *buffer, *p;
496   size_t buflen, len;
497   void *relptr;
498
499   /* Set defaults.  */
500   app->app_local->flags.no_sync = 0;
501   app->app_local->flags.def_chv2 = 0;
502
503   /* Read the DO.  */
504   relptr = get_one_do (app, 0x005E, &buffer, &buflen, NULL);
505   if (!relptr)
506     return; /* Ooops. */
507   for (; buflen; buflen--, buffer++)
508     if (*buffer == '\n')
509       break;
510   if (buflen < 2 || buffer[1] != '\x14')
511     return; /* No control sequences.  */
512   buflen--;
513   buffer++;
514   do
515     {
516       buflen--;
517       buffer++;
518       if (buflen > 1 && *buffer == 'F' && buffer[1] == '=')
519         {
520           /* Flags control sequence found.  */
521           int lastdig = 0;
522
523           /* For now we are only interested in the last digit, so skip
524              any leading digits but bail out on invalid characters. */
525           for (p=buffer+2, len = buflen-2; len && hexdigitp (p); p++, len--)
526             lastdig = xtoi_1 (p);
527           if (len && !(*p == '\n' || *p == '\x18'))
528             goto next;  /* Invalid characters in field.  */
529           app->app_local->flags.no_sync = !!(lastdig & 1);
530           app->app_local->flags.def_chv2 = (lastdig & 3) == 3;
531         }
532     next:
533       for (; buflen && *buffer != '\x18'; buflen--, buffer++)
534         if (*buffer == '\n')
535           buflen = 1; 
536     }
537   while (buflen);
538
539   xfree (relptr);
540 }
541
542 /* Note, that FPR must be at least 20 bytes. */
543 static int 
544 store_fpr (int slot, int keynumber, u32 timestamp,
545            const unsigned char *m, size_t mlen,
546            const unsigned char *e, size_t elen, 
547            unsigned char *fpr, unsigned int card_version)
548 {
549   unsigned int n, nbits;
550   unsigned char *buffer, *p;
551   int rc;
552   
553   for (; mlen && !*m; mlen--, m++) /* strip leading zeroes */
554     ;
555   for (; elen && !*e; elen--, e++) /* strip leading zeroes */
556     ;
557
558   n = 6 + 2 + mlen + 2 + elen;
559   p = buffer = xtrymalloc (3 + n);
560   if (!buffer)
561     return gpg_error (gpg_err_code_from_errno (errno));
562   
563   *p++ = 0x99;     /* ctb */
564   *p++ = n >> 8;   /* 2 byte length header */
565   *p++ = n;
566   *p++ = 4;        /* key packet version */
567   *p++ = timestamp >> 24;
568   *p++ = timestamp >> 16;
569   *p++ = timestamp >>  8;
570   *p++ = timestamp;
571   *p++ = 1; /* RSA */
572   nbits = count_bits (m, mlen);
573   *p++ = nbits >> 8;
574   *p++ = nbits;
575   memcpy (p, m, mlen); p += mlen;
576   nbits = count_bits (e, elen);
577   *p++ = nbits >> 8;
578   *p++ = nbits;
579   memcpy (p, e, elen); p += elen;
580     
581   gcry_md_hash_buffer (GCRY_MD_SHA1, fpr, buffer, n+3);
582
583   xfree (buffer);
584
585   rc = iso7816_put_data (slot, (card_version > 0x0007? 0xC7 : 0xC6)
586                                + keynumber, fpr, 20);
587   if (rc)
588     log_error (_("failed to store the fingerprint: %s\n"),gpg_strerror (rc));
589
590   if (!rc && card_version > 0x0100)
591     {
592       unsigned char buf[4];
593
594       buf[0] = timestamp >> 24;
595       buf[1] = timestamp >> 16;
596       buf[2] = timestamp >>  8;
597       buf[3] = timestamp;
598
599       rc = iso7816_put_data (slot, 0xCE + keynumber, buf, 4);
600       if (rc)
601         log_error (_("failed to store the creation date: %s\n"),
602                    gpg_strerror (rc));
603     }
604
605   return rc;
606 }
607
608        
609 static void
610 send_fpr_if_not_null (ctrl_t ctrl, const char *keyword,
611                       int number, const unsigned char *fpr)
612 {                      
613   int i;
614   char buf[41];
615   char numbuf[25];
616
617   for (i=0; i < 20 && !fpr[i]; i++)
618     ;
619   if (i==20)
620     return; /* All zero. */
621   for (i=0; i< 20; i++)
622     sprintf (buf+2*i, "%02X", fpr[i]);
623   if (number == -1)
624     *numbuf = 0; /* Don't print the key number */
625   else
626     sprintf (numbuf, "%d", number);
627   send_status_info (ctrl, keyword,
628                     numbuf, (size_t)strlen(numbuf),
629                     buf, (size_t)strlen (buf), NULL, 0);
630 }
631
632 static void
633 send_fprtime_if_not_null (ctrl_t ctrl, const char *keyword,
634                           int number, const unsigned char *stamp)
635 {                      
636   char numbuf1[50], numbuf2[50];
637   unsigned long value;
638
639   value = (stamp[0] << 24) | (stamp[1]<<16) | (stamp[2]<<8) | stamp[3];
640   if (!value)
641     return;
642   sprintf (numbuf1, "%d", number);
643   sprintf (numbuf2, "%lu", value);
644   send_status_info (ctrl, keyword,
645                     numbuf1, (size_t)strlen(numbuf1),
646                     numbuf2, (size_t)strlen(numbuf2), NULL, 0);
647 }
648
649 static void
650 send_key_data (ctrl_t ctrl, const char *name, 
651                const unsigned char *a, size_t alen)
652 {
653   char *p, *buf = xmalloc (alen*2+1);
654   
655   for (p=buf; alen; a++, alen--, p += 2)
656     sprintf (p, "%02X", *a);
657
658   send_status_info (ctrl, "KEY-DATA",
659                     name, (size_t)strlen(name), 
660                     buf, (size_t)strlen (buf),
661                     NULL, 0);
662   xfree (buf);
663 }
664
665 /* Implement the GETATTR command.  This is similar to the LEARN
666    command but returns just one value via the status interface. */
667 static int 
668 do_getattr (app_t app, ctrl_t ctrl, const char *name)
669 {
670   static struct {
671     const char *name;
672     int tag;
673     int special;
674   } table[] = {
675     { "DISP-NAME",    0x005B },
676     { "LOGIN-DATA",   0x005E },
677     { "DISP-LANG",    0x5F2D },
678     { "DISP-SEX",     0x5F35 },
679     { "PUBKEY-URL",   0x5F50 },
680     { "KEY-FPR",      0x00C5, 3 },
681     { "KEY-TIME",     0x00CD, 4 },
682     { "CA-FPR",       0x00C6, 3 },
683     { "CHV-STATUS",   0x00C4, 1 }, 
684     { "SIG-COUNTER",  0x0093, 2 },
685     { "SERIALNO",     0x004F, -1 },
686     { "AID",          0x004F },
687     { "EXTCAP",       0x0000, -2 },
688     { "PRIVATE-DO-1", 0x0101 },
689     { "PRIVATE-DO-2", 0x0102 },
690     { "PRIVATE-DO-3", 0x0103 },
691     { "PRIVATE-DO-4", 0x0104 },
692     { NULL, 0 }
693   };
694   int idx, i, rc;
695   void *relptr;
696   unsigned char *value;
697   size_t valuelen;
698
699   for (idx=0; table[idx].name && strcmp (table[idx].name, name); idx++)
700     ;
701   if (!table[idx].name)
702     return gpg_error (GPG_ERR_INV_NAME); 
703   
704   if (table[idx].special == -1)
705     {
706       /* The serial number is very special.  We could have used the
707          AID DO to retrieve it, but we have it already in the app
708          context and the stamp argument is required anyway which we
709          can't by other means. The AID DO is available anyway but not
710          hex formatted. */
711       char *serial;
712       time_t stamp;
713       char tmp[50];
714
715       if (!app_get_serial_and_stamp (app, &serial, &stamp))
716         {
717           sprintf (tmp, "%lu", (unsigned long)stamp);
718           send_status_info (ctrl, "SERIALNO",
719                             serial, strlen (serial),
720                             tmp, strlen (tmp),
721                             NULL, 0);
722           xfree (serial);
723         }
724       return 0;
725     }
726   if (table[idx].special == -2)
727     {
728       char tmp[50];
729
730       sprintf (tmp, "gc=%d ki=%d fc=%d pd=%d", 
731                app->app_local->extcap.get_challenge,
732                app->app_local->extcap.key_import,
733                app->app_local->extcap.change_force_chv,
734                app->app_local->extcap.private_dos);
735       send_status_info (ctrl, table[idx].name, tmp, strlen (tmp), NULL, 0);
736       return 0;
737     }
738
739   relptr = get_one_do (app, table[idx].tag, &value, &valuelen, &rc);
740   if (relptr)
741     {
742       if (table[idx].special == 1)
743         {
744           char numbuf[7*23];
745           
746           for (i=0,*numbuf=0; i < valuelen && i < 7; i++)
747             sprintf (numbuf+strlen (numbuf), " %d", value[i]); 
748           send_status_info (ctrl, table[idx].name,
749                             numbuf, strlen (numbuf), NULL, 0);
750         }
751       else if (table[idx].special == 2)
752         {
753           char numbuf[50];
754
755           sprintf (numbuf, "%lu", convert_sig_counter_value (value, valuelen));
756           send_status_info (ctrl, table[idx].name,
757                             numbuf, strlen (numbuf), NULL, 0);
758         }
759       else if (table[idx].special == 3)
760         {
761           if (valuelen >= 60)
762             for (i=0; i < 3; i++)
763               send_fpr_if_not_null (ctrl, table[idx].name, i+1, value+i*20);
764         }
765       else if (table[idx].special == 4)
766         {
767           if (valuelen >= 12)
768             for (i=0; i < 3; i++)
769               send_fprtime_if_not_null (ctrl, table[idx].name, i+1, value+i*4);
770         }
771       else
772         send_status_info (ctrl, table[idx].name, value, valuelen, NULL, 0);
773
774       xfree (relptr);
775     }
776   return rc;
777 }
778
779
780 /* Get the public key for KEYNO and store it as an S-expresion with
781    the APP handle.  On error that field gets cleared.  If we already
782    know about the public key we will just return.  Note that this does
783    not mean a key is available; this is soley indicated by the
784    presence of the app->app_local->pk[KEYNO-1].key field.
785
786    Note that GnuPG 1.x does not need this and it would be too time
787    consuming to send it just for the fun of it.  */
788 #if GNUPG_MAJOR_VERSION > 1
789 static gpg_error_t
790 get_public_key (app_t app, int keyno)
791 {
792   gpg_error_t err = 0;
793   unsigned char *buffer;
794   const unsigned char *keydata, *m, *e;
795   size_t buflen, keydatalen, mlen, elen;
796   gcry_sexp_t sexp;
797   unsigned char *mbuf = NULL;
798   unsigned char *ebuf = NULL;
799
800   if (keyno < 1 || keyno > 3)
801     return gpg_error (GPG_ERR_INV_ID);
802   keyno--;
803
804   /* Already cached? */
805   if (app->app_local->pk[keyno].read_done)
806     return 0;
807
808   gcry_sexp_release (app->app_local->pk[keyno].key);
809   app->app_local->pk[keyno].key = NULL;
810
811   if (app->card_version > 0x0100)
812     {
813       /* We may simply read the public key out of these cards.  */
814       err = iso7816_read_public_key (app->slot, 
815                                     keyno == 0? "\xB6" :
816                                     keyno == 1? "\xB8" : "\xA4",
817                                     2,  
818                                     &buffer, &buflen);
819       if (err)
820         {
821           log_error (_("reading public key failed: %s\n"), gpg_strerror (err));
822           goto leave;
823         }
824
825       keydata = find_tlv (buffer, buflen, 0x7F49, &keydatalen);
826       if (!keydata)
827         {
828           err = gpg_error (GPG_ERR_CARD);
829           log_error (_("response does not contain the public key data\n"));
830           goto leave;
831         }
832  
833       m = find_tlv (keydata, keydatalen, 0x0081, &mlen);
834       if (!m)
835         {
836           err = gpg_error (GPG_ERR_CARD);
837           log_error (_("response does not contain the RSA modulus\n"));
838           goto leave;
839         }
840       
841
842       e = find_tlv (keydata, keydatalen, 0x0082, &elen);
843       if (!e)
844         {
845           err = gpg_error (GPG_ERR_CARD);
846           log_error (_("response does not contain the RSA public exponent\n"));
847           goto leave;
848         }
849
850       /* Prepend numbers with a 0 if needed.  */
851       if (mlen && (*m & 0x80))
852         {
853           mbuf = xtrymalloc ( mlen + 1);
854           if (!mbuf)
855             {
856               err = gpg_error_from_errno (errno);
857               goto leave;
858             }
859           *mbuf = 0;
860           memcpy (mbuf+1, m, mlen);
861           mlen++;
862           m = mbuf;
863         }
864       if (elen && (*e & 0x80))
865         {
866           ebuf = xtrymalloc ( elen + 1);
867           if (!ebuf)
868             {
869               err = gpg_error_from_errno (errno);
870               goto leave;
871             }
872           *ebuf = 0;
873           memcpy (ebuf+1, e, elen);
874           elen++;
875           e = ebuf;
876         }
877
878
879       err = gcry_sexp_build (&sexp, NULL,
880                              "(public-key (rsa (n %b) (e %b)))",
881                              (int)mlen, m,(int)elen, e);
882       if (err)
883         {
884           log_error ("error formatting the key into an S-expression: %s\n",
885                      gpg_strerror (err));
886           goto leave;
887         }
888       app->app_local->pk[keyno].key = sexp;
889
890     }
891   else
892     {
893       /* Due to a design problem in v1.0 cards we can't get the public
894          key out of these cards without doing a verify on CHV3.
895          Clearly that is not an option and thus we try to locate the
896          key using an external helper.  */
897
898       buffer = NULL;
899       /* FIXME */
900
901     }
902
903  leave:
904   /* Set a flag to indicate that we tried to read the key.  */
905   app->app_local->pk[keyno].read_done = 1;
906
907   xfree (buffer);
908   xfree (mbuf);
909   xfree (ebuf);
910   return 0;
911 }
912 #endif /* GNUPG_MAJOR_VERSION > 1 */
913
914
915
916 /* Send the KEYPAIRINFO back. KEYNO needs to be in the range [1,3].
917    This is used by the LEARN command. */
918 static gpg_error_t
919 send_keypair_info (app_t app, ctrl_t ctrl, int keyno)
920 {
921   gpg_error_t err = 0;
922   /* Note that GnuPG 1.x does not need this and it would be too time
923      consuming to send it just for the fun of it. */
924 #if GNUPG_MAJOR_VERSION > 1
925   gcry_sexp_t sexp;
926   unsigned char grip[20];
927   char gripstr[41];
928   char idbuf[50];
929   int i;
930
931   err = get_public_key (app, keyno);
932   if (err)
933     goto leave;
934   
935   assert (keyno >= 1 && keyno <= 3);
936   sexp = app->app_local->pk[keyno-1].key;
937   if (!sexp)
938     goto leave; /* No such key.  */
939
940   if (!gcry_pk_get_keygrip (sexp, grip))
941     {
942       err = gpg_error (GPG_ERR_INTERNAL); 
943       goto leave;  
944     }
945   
946   for (i=0; i < 20; i++)
947     sprintf (gripstr+i*2, "%02X", grip[i]);
948
949   sprintf (idbuf, "OPENPGP.%d", keyno);
950   send_status_info (ctrl, "KEYPAIRINFO", 
951                     gripstr, 40, 
952                     idbuf, strlen (idbuf), 
953                     NULL, (size_t)0);
954
955  leave:
956 #endif /* GNUPG_MAJOR_VERSION > 1 */
957
958   return err; 
959 }
960
961
962 /* Handle the LEARN command for OpenPGP.  */
963 static int
964 do_learn_status (app_t app, ctrl_t ctrl)
965 {
966   do_getattr (app, ctrl, "EXTCAP");
967   do_getattr (app, ctrl, "DISP-NAME");
968   do_getattr (app, ctrl, "DISP-LANG");
969   do_getattr (app, ctrl, "DISP-SEX");
970   do_getattr (app, ctrl, "PUBKEY-URL");
971   do_getattr (app, ctrl, "LOGIN-DATA");
972   do_getattr (app, ctrl, "KEY-FPR");
973   if (app->card_version > 0x0100)
974     do_getattr (app, ctrl, "KEY-TIME");
975   do_getattr (app, ctrl, "CA-FPR");
976   do_getattr (app, ctrl, "CHV-STATUS");
977   do_getattr (app, ctrl, "SIG-COUNTER");
978   if (app->app_local->extcap.private_dos)
979     {
980       do_getattr (app, ctrl, "PRIVATE-DO-1");
981       do_getattr (app, ctrl, "PRIVATE-DO-2");
982       if (app->did_chv2)
983         do_getattr (app, ctrl, "PRIVATE-DO-3");
984       if (app->did_chv3)
985         do_getattr (app, ctrl, "PRIVATE-DO-4");
986     }
987   send_keypair_info (app, ctrl, 1);
988   send_keypair_info (app, ctrl, 2);
989   send_keypair_info (app, ctrl, 3);
990   return 0;
991 }
992
993
994 /* Handle the READKEY command for OpenPGP.  On success a canonical
995    encoded S-expression with the public key will get stored at PK and
996    its length (for assertions) at PKLEN; the caller must release that
997    buffer. On error PK and PKLEN are not changed and an error code is
998    returned.  */
999 static int
1000 do_readkey (app_t app, const char *keyid, unsigned char **pk, size_t *pklen)
1001 {
1002   gpg_error_t err;
1003   int keyno;
1004   size_t n;
1005   unsigned char *buf;
1006   gcry_sexp_t sexp;
1007
1008   if (!strcmp (keyid, "OPENPGP.1"))
1009     keyno = 1;
1010   else if (!strcmp (keyid, "OPENPGP.2"))
1011     keyno = 2;
1012   else if (!strcmp (keyid, "OPENPGP.3"))
1013     keyno = 3;
1014   else
1015     return gpg_error (GPG_ERR_INV_ID);
1016
1017   err = get_public_key (app, keyno);
1018   if (err)
1019     return err;
1020
1021   sexp = app->app_local->pk[keyno-1].key;
1022   if (!sexp)
1023     return gpg_error (GPG_ERR_NO_PUBKEY);
1024
1025   n = gcry_sexp_sprint (sexp, GCRYSEXP_FMT_CANON, NULL, 0);
1026   if (!n)
1027     return gpg_error (GPG_ERR_BUG);
1028   buf = xtrymalloc (n);
1029   if (!buf)
1030     return gpg_error_from_errno (errno);
1031   n = gcry_sexp_sprint (sexp, GCRYSEXP_FMT_CANON, buf, n);
1032   if (!n)
1033     {
1034       xfree (buf);
1035       return gpg_error (GPG_ERR_BUG);
1036     }
1037   *pk = buf;
1038   *pklen = n;
1039   return 0;
1040 }
1041
1042
1043
1044 /* Verify CHV2 if required.  Depending on the configuration of the
1045    card CHV1 will also be verified. */
1046 static int
1047 verify_chv2 (app_t app,
1048              int (*pincb)(void*, const char *, char **),
1049              void *pincb_arg)
1050 {
1051   int rc = 0;
1052
1053   if (!app->did_chv2) 
1054     {
1055       char *pinvalue;
1056
1057       rc = pincb (pincb_arg, "PIN", &pinvalue); 
1058       if (rc)
1059         {
1060           log_info (_("PIN callback returned error: %s\n"), gpg_strerror (rc));
1061           return rc;
1062         }
1063
1064       if (strlen (pinvalue) < 6)
1065         {
1066           log_error (_("PIN for CHV%d is too short;"
1067                        " minimum length is %d\n"), 2, 6);
1068           xfree (pinvalue);
1069           return gpg_error (GPG_ERR_BAD_PIN);
1070         }
1071
1072       rc = iso7816_verify (app->slot, 0x82, pinvalue, strlen (pinvalue));
1073       if (rc)
1074         {
1075           log_error (_("verify CHV%d failed: %s\n"), 2, gpg_strerror (rc));
1076           xfree (pinvalue);
1077           flush_cache_after_error (app);
1078           return rc;
1079         }
1080       app->did_chv2 = 1;
1081
1082       if (!app->did_chv1 && !app->force_chv1)
1083         {
1084           rc = iso7816_verify (app->slot, 0x81, pinvalue, strlen (pinvalue));
1085           if (gpg_err_code (rc) == GPG_ERR_BAD_PIN)
1086             rc = gpg_error (GPG_ERR_PIN_NOT_SYNCED);
1087           if (rc)
1088             {
1089               log_error (_("verify CHV%d failed: %s\n"), 1, gpg_strerror (rc));
1090               xfree (pinvalue);
1091               flush_cache_after_error (app);
1092               return rc;
1093             }
1094           app->did_chv1 = 1;
1095         }
1096       xfree (pinvalue);
1097     }
1098   return rc;
1099 }
1100
1101 /* Verify CHV3 if required. */
1102 static int
1103 verify_chv3 (app_t app,
1104              int (*pincb)(void*, const char *, char **),
1105              void *pincb_arg)
1106 {
1107   int rc = 0;
1108
1109 #if GNUPG_MAJOR_VERSION != 1
1110   if (!opt.allow_admin)
1111     {
1112       log_info (_("access to admin commands is not configured\n"));
1113       return gpg_error (GPG_ERR_EACCES);
1114     }
1115 #endif
1116       
1117   if (!app->did_chv3) 
1118     {
1119       char *pinvalue;
1120       void *relptr;
1121       unsigned char *value;
1122       size_t valuelen;
1123
1124       relptr = get_one_do (app, 0x00C4, &value, &valuelen, NULL);
1125       if (!relptr || valuelen < 7)
1126         {
1127           log_error (_("error retrieving CHV status from card\n"));
1128           xfree (relptr);
1129           return gpg_error (GPG_ERR_CARD);
1130         }
1131       if (value[6] == 0)
1132         {
1133           log_info (_("card is permanently locked!\n"));
1134           xfree (relptr);
1135           return gpg_error (GPG_ERR_BAD_PIN);
1136         }
1137
1138       log_info(_("%d Admin PIN attempts remaining before card"
1139                  " is permanently locked\n"), value[6]);
1140       xfree (relptr);
1141
1142       /* TRANSLATORS: Do not translate the "|A|" prefix but
1143          keep it at the start of the string.  We need this elsewhere
1144          to get some infos on the string. */
1145       rc = pincb (pincb_arg, _("|A|Admin PIN"), &pinvalue); 
1146       if (rc)
1147         {
1148           log_info (_("PIN callback returned error: %s\n"), gpg_strerror (rc));
1149           return rc;
1150         }
1151
1152       if (strlen (pinvalue) < 8)
1153         {
1154           log_error (_("PIN for CHV%d is too short;"
1155                        " minimum length is %d\n"), 3, 8);
1156           xfree (pinvalue);
1157           return gpg_error (GPG_ERR_BAD_PIN);
1158         }
1159
1160       rc = iso7816_verify (app->slot, 0x83, pinvalue, strlen (pinvalue));
1161       xfree (pinvalue);
1162       if (rc)
1163         {
1164           log_error (_("verify CHV%d failed: %s\n"), 3, gpg_strerror (rc));
1165           flush_cache_after_error (app);
1166           return rc;
1167         }
1168       app->did_chv3 = 1;
1169     }
1170   return rc;
1171 }
1172
1173
1174 /* Handle the SETATTR operation. All arguments are already basically
1175    checked. */
1176 static int 
1177 do_setattr (app_t app, const char *name,
1178             int (*pincb)(void*, const char *, char **),
1179             void *pincb_arg,
1180             const unsigned char *value, size_t valuelen)
1181 {
1182   gpg_error_t rc;
1183   int idx;
1184   static struct {
1185     const char *name;
1186     int tag;
1187     int need_chv;
1188     int special;
1189   } table[] = {
1190     { "DISP-NAME",    0x005B, 3 },
1191     { "LOGIN-DATA",   0x005E, 3, 2 },
1192     { "DISP-LANG",    0x5F2D, 3 },
1193     { "DISP-SEX",     0x5F35, 3 },
1194     { "PUBKEY-URL",   0x5F50, 3 },
1195     { "CHV-STATUS-1", 0x00C4, 3, 1 },
1196     { "CA-FPR-1",     0x00CA, 3 },
1197     { "CA-FPR-2",     0x00CB, 3 },
1198     { "CA-FPR-3",     0x00CC, 3 },
1199     { "PRIVATE-DO-1", 0x0101, 2 },
1200     { "PRIVATE-DO-2", 0x0102, 3 },
1201     { "PRIVATE-DO-3", 0x0103, 2 },
1202     { "PRIVATE-DO-4", 0x0104, 3 },
1203     { NULL, 0 }
1204   };
1205
1206
1207   for (idx=0; table[idx].name && strcmp (table[idx].name, name); idx++)
1208     ;
1209   if (!table[idx].name)
1210     return gpg_error (GPG_ERR_INV_NAME); 
1211
1212   switch (table[idx].need_chv)
1213     {
1214     case 2:
1215       rc = verify_chv2 (app, pincb, pincb_arg);
1216       break;
1217     case 3:
1218       rc = verify_chv3 (app, pincb, pincb_arg);
1219       break;
1220     default:
1221       rc = 0;
1222     }
1223   if (rc)
1224     return rc;
1225
1226   /* Flush the cache before writing it, so that the next get operation
1227      will reread the data from the card and thus get synced in case of
1228      errors (e.g. data truncated by the card). */
1229   flush_cache_item (app, table[idx].tag);
1230   rc = iso7816_put_data (app->slot, table[idx].tag, value, valuelen);
1231   if (rc)
1232     log_error ("failed to set `%s': %s\n", table[idx].name, gpg_strerror (rc));
1233
1234   if (table[idx].special == 1)
1235     app->force_chv1 = (valuelen && *value == 0);
1236   else if (table[idx].special == 2)
1237     parse_login_data (app);
1238
1239   return rc;
1240 }
1241
1242
1243 /* Handle the PASSWD command. */
1244 static int 
1245 do_change_pin (app_t app, ctrl_t ctrl,  const char *chvnostr, int reset_mode,
1246                int (*pincb)(void*, const char *, char **),
1247                void *pincb_arg)
1248 {
1249   int rc = 0;
1250   int chvno = atoi (chvnostr);
1251   char *pinvalue;
1252
1253   if (reset_mode && chvno == 3)
1254     {
1255       rc = gpg_error (GPG_ERR_INV_ID);
1256       goto leave;
1257     }
1258   else if (reset_mode || chvno == 3)
1259     {
1260       /* we always require that the PIN is entered. */
1261       app->did_chv3 = 0;
1262       rc = verify_chv3 (app, pincb, pincb_arg);
1263       if (rc)
1264         goto leave;
1265     }
1266   else if (chvno == 1 || chvno == 2)
1267     {
1268       /* CHV1 and CVH2 should always have the same value, thus we
1269          enforce it here.  */
1270       int save_force = app->force_chv1;
1271
1272       app->force_chv1 = 0;
1273       app->did_chv1 = 0;
1274       app->did_chv2 = 0;
1275       rc = verify_chv2 (app, pincb, pincb_arg);
1276       app->force_chv1 = save_force;
1277       if (rc)
1278         goto leave;
1279     }
1280   else
1281     {
1282       rc = gpg_error (GPG_ERR_INV_ID);
1283       goto leave;
1284     }
1285
1286   if (chvno == 3)
1287     app->did_chv3 = 0;
1288   else
1289     app->did_chv1 = app->did_chv2 = 0;
1290
1291   /* Note to translators: Do not translate the "|*|" prefixes but
1292      keep it at the start of the string.  We need this elsewhere
1293      to get some infos on the string. */
1294   rc = pincb (pincb_arg, chvno == 3? _("|AN|New Admin PIN") : _("|N|New PIN"), 
1295               &pinvalue); 
1296   if (rc)
1297     {
1298       log_error (_("error getting new PIN: %s\n"), gpg_strerror (rc));
1299       goto leave;
1300     }
1301
1302   if (reset_mode)
1303     {
1304       rc = iso7816_reset_retry_counter (app->slot, 0x81,
1305                                         pinvalue, strlen (pinvalue));
1306       if (!rc)
1307         rc = iso7816_reset_retry_counter (app->slot, 0x82,
1308                                           pinvalue, strlen (pinvalue));
1309     }
1310   else
1311     {
1312       if (chvno == 1 || chvno == 2)
1313         {
1314           rc = iso7816_change_reference_data (app->slot, 0x81, NULL, 0,
1315                                               pinvalue, strlen (pinvalue));
1316           if (!rc)
1317             rc = iso7816_change_reference_data (app->slot, 0x82, NULL, 0,
1318                                                 pinvalue, strlen (pinvalue));
1319         }
1320       else
1321         rc = iso7816_change_reference_data (app->slot, 0x80 + chvno, NULL, 0,
1322                                             pinvalue, strlen (pinvalue));
1323     }
1324   xfree (pinvalue);
1325   if (rc)
1326     flush_cache_after_error (app);
1327
1328  leave:
1329   return rc;
1330 }
1331
1332
1333
1334 /* Handle the GENKEY command. */
1335 static int 
1336 do_genkey (app_t app, ctrl_t ctrl,  const char *keynostr, unsigned int flags,
1337           int (*pincb)(void*, const char *, char **),
1338           void *pincb_arg)
1339 {
1340   int rc;
1341   int i;
1342   char numbuf[30];
1343   unsigned char fprbuf[20];
1344   const unsigned char *fpr;
1345   const unsigned char *keydata, *m, *e;
1346   unsigned char *buffer;
1347   size_t buflen, keydatalen, n, mlen, elen;
1348   time_t created_at;
1349   int keyno = atoi (keynostr);
1350   int force = (flags & 1);
1351   time_t start_at;
1352
1353   if (keyno < 1 || keyno > 3)
1354     return gpg_error (GPG_ERR_INV_ID);
1355   keyno--;
1356
1357   /* We flush the cache to increase the traffic before a key
1358      generation.  This _might_ help a card to gather more entropy. */
1359   flush_cache (app);
1360
1361   /* Obviously we need to remove the cached public key.  */
1362   gcry_sexp_release (app->app_local->pk[keyno].key);
1363   app->app_local->pk[keyno].read_done = 0;
1364
1365   /* Check whether a key already exists.  */
1366   rc = iso7816_get_data (app->slot, 0x006E, &buffer, &buflen);
1367   if (rc)
1368     {
1369       log_error (_("error reading application data\n"));
1370       return gpg_error (GPG_ERR_GENERAL);
1371     }
1372   fpr = find_tlv (buffer, buflen, 0x00C5, &n);
1373   if (!fpr || n != 60)
1374     {
1375       rc = gpg_error (GPG_ERR_GENERAL);
1376       log_error (_("error reading fingerprint DO\n"));
1377       goto leave;
1378     }
1379   fpr += 20*keyno;
1380   for (i=0; i < 20 && !fpr[i]; i++)
1381     ;
1382   if (i!=20 && !force)
1383     {
1384       rc = gpg_error (GPG_ERR_EEXIST);
1385       log_error (_("key already exists\n"));
1386       goto leave;
1387     }
1388   else if (i!=20)
1389     log_info (_("existing key will be replaced\n"));
1390   else
1391     log_info (_("generating new key\n"));
1392
1393   
1394   /* Prepare for key generation by verifying the ADmin PIN.  */
1395   rc = verify_chv3 (app, pincb, pincb_arg);
1396   if (rc)
1397     goto leave;
1398    
1399   xfree (buffer); buffer = NULL;
1400
1401 #if 1
1402   log_info (_("please wait while key is being generated ...\n"));
1403   start_at = time (NULL);
1404   rc = iso7816_generate_keypair 
1405 #else
1406 #warning key generation temporary replaced by reading an existing key.
1407   rc = iso7816_read_public_key
1408 #endif
1409                               (app->slot, 
1410                                  keyno == 0? "\xB6" :
1411                                  keyno == 1? "\xB8" : "\xA4",
1412                                  2,
1413                                  &buffer, &buflen);
1414   if (rc)
1415     {
1416       rc = gpg_error (GPG_ERR_CARD);
1417       log_error (_("generating key failed\n"));
1418       goto leave;
1419     }
1420   log_info (_("key generation completed (%d seconds)\n"),
1421             (int)(time (NULL) - start_at));
1422   keydata = find_tlv (buffer, buflen, 0x7F49, &keydatalen);
1423   if (!keydata)
1424     {
1425       rc = gpg_error (GPG_ERR_CARD);
1426       log_error (_("response does not contain the public key data\n"));
1427       goto leave;
1428     }
1429  
1430   m = find_tlv (keydata, keydatalen, 0x0081, &mlen);
1431   if (!m)
1432     {
1433       rc = gpg_error (GPG_ERR_CARD);
1434       log_error (_("response does not contain the RSA modulus\n"));
1435       goto leave;
1436     }
1437 /*    log_printhex ("RSA n:", m, mlen); */
1438   send_key_data (ctrl, "n", m, mlen);
1439
1440   e = find_tlv (keydata, keydatalen, 0x0082, &elen);
1441   if (!e)
1442     {
1443       rc = gpg_error (GPG_ERR_CARD);
1444       log_error (_("response does not contain the RSA public exponent\n"));
1445       goto leave;
1446     }
1447 /*    log_printhex ("RSA e:", e, elen); */
1448   send_key_data (ctrl, "e", e, elen);
1449
1450   created_at = gnupg_get_time ();
1451   sprintf (numbuf, "%lu", (unsigned long)created_at);
1452   send_status_info (ctrl, "KEY-CREATED-AT",
1453                     numbuf, (size_t)strlen(numbuf), NULL, 0);
1454
1455   rc = store_fpr (app->slot, keyno, (u32)created_at,
1456                   m, mlen, e, elen, fprbuf, app->card_version);
1457   if (rc)
1458     goto leave;
1459   send_fpr_if_not_null (ctrl, "KEY-FPR", -1, fprbuf);
1460
1461
1462  leave:
1463   xfree (buffer);
1464   return rc;
1465 }
1466
1467
1468 static unsigned long
1469 convert_sig_counter_value (const unsigned char *value, size_t valuelen)
1470 {
1471   unsigned long ul;
1472
1473   if (valuelen == 3 )
1474     ul = (value[0] << 16) | (value[1] << 8) | value[2];
1475   else
1476     {
1477       log_error (_("invalid structure of OpenPGP card (DO 0x93)\n"));
1478       ul = 0;
1479     }
1480   return ul;
1481 }
1482
1483 static unsigned long
1484 get_sig_counter (app_t app)
1485 {
1486   void *relptr;
1487   unsigned char *value;
1488   size_t valuelen;
1489   unsigned long ul;
1490
1491   relptr = get_one_do (app, 0x0093, &value, &valuelen, NULL);
1492   if (!relptr)
1493     return 0;
1494   ul = convert_sig_counter_value (value, valuelen);
1495   xfree (relptr);
1496   return ul;
1497 }
1498
1499 static int
1500 compare_fingerprint (app_t app, int keyno, unsigned char *sha1fpr)
1501 {
1502   const unsigned char *fpr;
1503   unsigned char *buffer;
1504   size_t buflen, n;
1505   int rc, i;
1506   
1507   assert (keyno >= 1 && keyno <= 3);
1508
1509   rc = get_cached_data (app, 0x006E, &buffer, &buflen, 0);
1510   if (rc)
1511     {
1512       log_error (_("error reading application data\n"));
1513       return gpg_error (GPG_ERR_GENERAL);
1514     }
1515   fpr = find_tlv (buffer, buflen, 0x00C5, &n);
1516   if (!fpr || n != 60)
1517     {
1518       xfree (buffer);
1519       log_error (_("error reading fingerprint DO\n"));
1520       return gpg_error (GPG_ERR_GENERAL);
1521     }
1522   fpr += (keyno-1)*20;
1523   for (i=0; i < 20; i++)
1524     if (sha1fpr[i] != fpr[i])
1525       {
1526         xfree (buffer);
1527         return gpg_error (GPG_ERR_WRONG_SECKEY);
1528       }
1529   xfree (buffer);
1530   return 0;
1531 }
1532
1533
1534   /* If a fingerprint has been specified check it against the one on
1535      the card.  This is allows for a meaningful error message in case
1536      the key on the card has been replaced but the shadow information
1537      known to gpg was not updated.  If there is no fingerprint we
1538      assume that this is okay. */
1539 static int
1540 check_against_given_fingerprint (app_t app, const char *fpr, int keyno)
1541 {
1542   unsigned char tmp[20];
1543   const char *s;
1544   int n;
1545
1546   for (s=fpr, n=0; hexdigitp (s); s++, n++)
1547     ;
1548   if (n != 40)
1549     return gpg_error (GPG_ERR_INV_ID);
1550   else if (!*s)
1551     ; /* okay */
1552   else
1553     return gpg_error (GPG_ERR_INV_ID);
1554
1555   for (s=fpr, n=0; n < 20; s += 2, n++)
1556         tmp[n] = xtoi_2 (s);
1557   return compare_fingerprint (app, keyno, tmp);
1558 }
1559
1560
1561
1562 /* Compute a digital signature on INDATA which is expected to be the
1563    raw message digest. For this application the KEYIDSTR consists of
1564    the serialnumber and the fingerprint delimited by a slash.
1565
1566    Note that this fucntion may return the error code
1567    GPG_ERR_WRONG_CARD to indicate that the card currently present does
1568    not match the one required for the requested action (e.g. the
1569    serial number does not match). */
1570 static int 
1571 do_sign (app_t app, const char *keyidstr, int hashalgo,
1572          int (*pincb)(void*, const char *, char **),
1573          void *pincb_arg,
1574          const void *indata, size_t indatalen,
1575          unsigned char **outdata, size_t *outdatalen )
1576 {
1577   static unsigned char sha1_prefix[15] = /* Object ID is 1.3.14.3.2.26 */
1578   { 0x30, 0x21, 0x30, 0x09, 0x06, 0x05, 0x2b, 0x0e, 0x03,
1579     0x02, 0x1a, 0x05, 0x00, 0x04, 0x14 };
1580   static unsigned char rmd160_prefix[15] = /* Object ID is 1.3.36.3.2.1 */
1581   { 0x30, 0x21, 0x30, 0x09, 0x06, 0x05, 0x2b, 0x24, 0x03,
1582     0x02, 0x01, 0x05, 0x00, 0x04, 0x14 };
1583   int rc;
1584   unsigned char data[35];
1585   unsigned char tmp_sn[20]; /* actually 16 but we use it also for the fpr. */
1586   const char *s;
1587   int n;
1588   const char *fpr = NULL;
1589   unsigned long sigcount;
1590
1591   if (!keyidstr || !*keyidstr)
1592     return gpg_error (GPG_ERR_INV_VALUE);
1593   if (indatalen == 20)
1594     ;
1595   else if (indatalen == (15 + 20) && hashalgo == GCRY_MD_SHA1
1596            && !memcmp (indata, sha1_prefix, 15))
1597     ;
1598   else if (indatalen == (15 + 20) && hashalgo == GCRY_MD_RMD160
1599            && !memcmp (indata, rmd160_prefix, 15))
1600     ;
1601   else
1602     return gpg_error (GPG_ERR_INV_VALUE);
1603
1604   /* Check whether an OpenPGP card of any version has been requested. */
1605   if (strlen (keyidstr) < 32 || strncmp (keyidstr, "D27600012401", 12))
1606     return gpg_error (GPG_ERR_INV_ID);
1607   
1608   for (s=keyidstr, n=0; hexdigitp (s); s++, n++)
1609     ;
1610   if (n != 32)
1611     return gpg_error (GPG_ERR_INV_ID);
1612   else if (!*s)
1613     ; /* no fingerprint given: we allow this for now. */
1614   else if (*s == '/')
1615     fpr = s + 1; 
1616   else
1617     return gpg_error (GPG_ERR_INV_ID);
1618
1619   for (s=keyidstr, n=0; n < 16; s += 2, n++)
1620     tmp_sn[n] = xtoi_2 (s);
1621
1622   if (app->serialnolen != 16)
1623     return gpg_error (GPG_ERR_INV_CARD);
1624   if (memcmp (app->serialno, tmp_sn, 16))
1625     return gpg_error (GPG_ERR_WRONG_CARD);
1626
1627   /* If a fingerprint has been specified check it against the one on
1628      the card.  This is allows for a meaningful error message in case
1629      the key on the card has been replaced but the shadow information
1630      known to gpg was not updated.  If there is no fingerprint, gpg
1631      will detect a bogus signature anyway due to the
1632      verify-after-signing feature. */
1633   rc = fpr? check_against_given_fingerprint (app, fpr, 1) : 0;
1634   if (rc)
1635     return rc;
1636
1637   if (hashalgo == GCRY_MD_SHA1)
1638     memcpy (data, sha1_prefix, 15);
1639   else if (hashalgo == GCRY_MD_RMD160)
1640     memcpy (data, rmd160_prefix, 15);
1641   else 
1642     return gpg_error (GPG_ERR_UNSUPPORTED_ALGORITHM);
1643   memcpy (data+15, indata, indatalen);
1644
1645   sigcount = get_sig_counter (app);
1646   log_info (_("signatures created so far: %lu\n"), sigcount);
1647
1648   if (!app->did_chv1 || app->force_chv1 ) 
1649     {
1650       char *pinvalue;
1651
1652       {
1653         char *prompt;
1654 #define PROMPTSTRING  _("PIN [sigs done: %lu]")
1655
1656         prompt = malloc (strlen (PROMPTSTRING) + 50);
1657         if (!prompt)
1658           return gpg_error_from_errno (errno);
1659         sprintf (prompt, PROMPTSTRING, sigcount);
1660         rc = pincb (pincb_arg, prompt, &pinvalue); 
1661         free (prompt);
1662 #undef PROMPTSTRING
1663       }
1664       if (rc)
1665         {
1666           log_info (_("PIN callback returned error: %s\n"), gpg_strerror (rc));
1667           return rc;
1668         }
1669
1670       if (strlen (pinvalue) < 6)
1671         {
1672           log_error (_("PIN for CHV%d is too short;"
1673                        " minimum length is %d\n"), 1, 6);
1674           xfree (pinvalue);
1675           return gpg_error (GPG_ERR_BAD_PIN);
1676         }
1677
1678       rc = iso7816_verify (app->slot, 0x81, pinvalue, strlen (pinvalue));
1679       if (rc)
1680         {
1681           log_error (_("verify CHV%d failed: %s\n"), 1, gpg_strerror (rc));
1682           xfree (pinvalue);
1683           flush_cache_after_error (app);
1684           return rc;
1685         }
1686       app->did_chv1 = 1;
1687       if (!app->did_chv2)
1688         {
1689           /* We should also verify CHV2. */
1690           rc = iso7816_verify (app->slot, 0x82, pinvalue, strlen (pinvalue));
1691           if (gpg_err_code (rc) == GPG_ERR_BAD_PIN)
1692             rc = gpg_error (GPG_ERR_PIN_NOT_SYNCED);
1693           if (rc)
1694             {
1695               log_error (_("verify CHV%d failed: %s\n"), 2, gpg_strerror (rc));
1696               xfree (pinvalue);
1697               flush_cache_after_error (app);
1698               return rc;
1699             }
1700           app->did_chv2 = 1;
1701         }
1702       xfree (pinvalue);
1703     }
1704
1705   rc = iso7816_compute_ds (app->slot, data, 35, outdata, outdatalen);
1706   return rc;
1707 }
1708
1709 /* Compute a digital signature using the INTERNAL AUTHENTICATE command
1710    on INDATA which is expected to be the raw message digest. For this
1711    application the KEYIDSTR consists of the serialnumber and the
1712    fingerprint delimited by a slash.  Optionally the id OPENPGP.3 may
1713    be given.
1714
1715    Note that this fucntion may return the error code
1716    GPG_ERR_WRONG_CARD to indicate that the card currently present does
1717    not match the one required for the requested action (e.g. the
1718    serial number does not match). */
1719 static int 
1720 do_auth (app_t app, const char *keyidstr,
1721          int (*pincb)(void*, const char *, char **),
1722          void *pincb_arg,
1723          const void *indata, size_t indatalen,
1724          unsigned char **outdata, size_t *outdatalen )
1725 {
1726   int rc;
1727   unsigned char tmp_sn[20]; /* actually 16 but we use it also for the fpr. */
1728   const char *s;
1729   int n;
1730   const char *fpr = NULL;
1731
1732   if (!keyidstr || !*keyidstr)
1733     return gpg_error (GPG_ERR_INV_VALUE);
1734   if (indatalen > 50) /* For a 1024 bit key. */
1735     return gpg_error (GPG_ERR_INV_VALUE);
1736
1737   /* Check whether an OpenPGP card of any version has been requested. */
1738   if (!strcmp (keyidstr, "OPENPGP.3"))
1739     ;
1740   else if (strlen (keyidstr) < 32 || strncmp (keyidstr, "D27600012401", 12))
1741     return gpg_error (GPG_ERR_INV_ID);
1742   else
1743     {
1744       for (s=keyidstr, n=0; hexdigitp (s); s++, n++)
1745         ;
1746       if (n != 32)
1747         return gpg_error (GPG_ERR_INV_ID);
1748       else if (!*s)
1749         ; /* no fingerprint given: we allow this for now. */
1750       else if (*s == '/')
1751         fpr = s + 1; 
1752       else
1753         return gpg_error (GPG_ERR_INV_ID);
1754
1755       for (s=keyidstr, n=0; n < 16; s += 2, n++)
1756         tmp_sn[n] = xtoi_2 (s);
1757       
1758       if (app->serialnolen != 16)
1759         return gpg_error (GPG_ERR_INV_CARD);
1760       if (memcmp (app->serialno, tmp_sn, 16))
1761         return gpg_error (GPG_ERR_WRONG_CARD);
1762     }
1763
1764   /* If a fingerprint has been specified check it against the one on
1765      the card.  This is allows for a meaningful error message in case
1766      the key on the card has been replaced but the shadow information
1767      known to gpg was not updated.  If there is no fingerprint, gpg
1768      will detect a bogus signature anyway due to the
1769      verify-after-signing feature. */
1770   rc = fpr? check_against_given_fingerprint (app, fpr, 3) : 0;
1771   if (rc)
1772     return rc;
1773
1774   rc = verify_chv2 (app, pincb, pincb_arg);
1775   if (!rc)
1776     rc = iso7816_internal_authenticate (app->slot, indata, indatalen,
1777                                         outdata, outdatalen);
1778   return rc;
1779 }
1780
1781
1782 static int 
1783 do_decipher (app_t app, const char *keyidstr,
1784              int (pincb)(void*, const char *, char **),
1785              void *pincb_arg,
1786              const void *indata, size_t indatalen,
1787              unsigned char **outdata, size_t *outdatalen )
1788 {
1789   int rc;
1790   unsigned char tmp_sn[20]; /* actually 16 but we use it also for the fpr. */
1791   const char *s;
1792   int n;
1793   const char *fpr = NULL;
1794
1795   if (!keyidstr || !*keyidstr || !indatalen)
1796     return gpg_error (GPG_ERR_INV_VALUE);
1797
1798   /* Check whether an OpenPGP card of any version has been requested. */
1799   if (strlen (keyidstr) < 32 || strncmp (keyidstr, "D27600012401", 12))
1800     return gpg_error (GPG_ERR_INV_ID);
1801   
1802   for (s=keyidstr, n=0; hexdigitp (s); s++, n++)
1803     ;
1804   if (n != 32)
1805     return gpg_error (GPG_ERR_INV_ID);
1806   else if (!*s)
1807     ; /* no fingerprint given: we allow this for now. */
1808   else if (*s == '/')
1809     fpr = s + 1; 
1810   else
1811     return gpg_error (GPG_ERR_INV_ID);
1812
1813   for (s=keyidstr, n=0; n < 16; s += 2, n++)
1814     tmp_sn[n] = xtoi_2 (s);
1815
1816   if (app->serialnolen != 16)
1817     return gpg_error (GPG_ERR_INV_CARD);
1818   if (memcmp (app->serialno, tmp_sn, 16))
1819     return gpg_error (GPG_ERR_WRONG_CARD);
1820
1821   /* If a fingerprint has been specified check it against the one on
1822      the card.  This is allows for a meaningful error message in case
1823      the key on the card has been replaced but the shadow information
1824      known to gpg was not updated.  If there is no fingerprint, the
1825      decryption will won't produce the right plaintext anyway. */
1826   rc = fpr? check_against_given_fingerprint (app, fpr, 2) : 0;
1827   if (rc)
1828     return rc;
1829
1830   rc = verify_chv2 (app, pincb, pincb_arg);
1831   if (!rc)
1832     rc = iso7816_decipher (app->slot, indata, indatalen, 0,
1833                            outdata, outdatalen);
1834   return rc;
1835 }
1836
1837
1838 /* Perform a simple verify operation for CHV1 and CHV2, so that
1839    further operations won't ask for CHV2 and it is possible to do a
1840    cheap check on the PIN: If there is something wrong with the PIN
1841    entry system, only the regular CHV will get blocked and not the
1842    dangerous CHV3.  KEYIDSTR is the usual card's serial number; an
1843    optional fingerprint part will be ignored. */
1844 static int 
1845 do_check_pin (app_t app, const char *keyidstr,
1846               int (pincb)(void*, const char *, char **),
1847               void *pincb_arg)
1848 {
1849   unsigned char tmp_sn[20]; 
1850   const char *s;
1851   int n;
1852
1853   if (!keyidstr || !*keyidstr)
1854     return gpg_error (GPG_ERR_INV_VALUE);
1855
1856   /* Check whether an OpenPGP card of any version has been requested. */
1857   if (strlen (keyidstr) < 32 || strncmp (keyidstr, "D27600012401", 12))
1858     return gpg_error (GPG_ERR_INV_ID);
1859   
1860   for (s=keyidstr, n=0; hexdigitp (s); s++, n++)
1861     ;
1862   if (n != 32)
1863     return gpg_error (GPG_ERR_INV_ID);
1864   else if (!*s)
1865     ; /* No fingerprint given: we allow this for now. */
1866   else if (*s == '/')
1867     ; /* We ignore a fingerprint. */
1868   else
1869     return gpg_error (GPG_ERR_INV_ID);
1870
1871   for (s=keyidstr, n=0; n < 16; s += 2, n++)
1872     tmp_sn[n] = xtoi_2 (s);
1873
1874   if (app->serialnolen != 16)
1875     return gpg_error (GPG_ERR_INV_CARD);
1876   if (memcmp (app->serialno, tmp_sn, 16))
1877     return gpg_error (GPG_ERR_WRONG_CARD);
1878   /* Yes, there is a race conditions: The user might pull the card
1879      right here and we won't notice that.  However this is not a
1880      problem and the check above is merely for a graceful failure
1881      between operations. */
1882
1883   return verify_chv2 (app, pincb, pincb_arg);
1884 }
1885
1886
1887
1888
1889 /* Select the OpenPGP application on the card in SLOT.  This function
1890    must be used before any other OpenPGP application functions. */
1891 int
1892 app_select_openpgp (app_t app)
1893 {
1894   static char const aid[] = { 0xD2, 0x76, 0x00, 0x01, 0x24, 0x01 };
1895   int slot = app->slot;
1896   int rc;
1897   unsigned char *buffer;
1898   size_t buflen;
1899   void *relptr;
1900   
1901   rc = iso7816_select_application (slot, aid, sizeof aid);
1902   if (!rc)
1903     {
1904       unsigned int manufacturer;
1905
1906       app->apptype = "OPENPGP";
1907
1908       app->did_chv1 = 0;
1909       app->did_chv2 = 0;
1910       app->did_chv3 = 0;
1911       app->app_local = NULL;
1912
1913       /* The OpenPGP card returns the serial number as part of the
1914          AID; because we prefer to use OpenPGP serial numbers, we
1915          replace a possibly already set one from a EF.GDO with this
1916          one.  Note, that for current OpenPGP cards, no EF.GDO exists
1917          and thus it won't matter at all. */
1918       rc = iso7816_get_data (slot, 0x004F, &buffer, &buflen);
1919       if (rc)
1920         goto leave;
1921       if (opt.verbose)
1922         {
1923           log_info ("AID: ");
1924           log_printhex ("", buffer, buflen);
1925         }
1926
1927       app->card_version = buffer[6] << 8;
1928       app->card_version |= buffer[7];
1929       manufacturer = (buffer[8]<<8 | buffer[9]);
1930
1931       xfree (app->serialno);
1932       app->serialno = buffer;
1933       app->serialnolen = buflen;
1934       buffer = NULL;
1935       app->app_local = xtrycalloc (1, sizeof *app->app_local);
1936       if (!app->app_local)
1937         {
1938           rc = gpg_error (gpg_err_code_from_errno (errno));
1939           goto leave;
1940         }
1941
1942       relptr = get_one_do (app, 0x00C4, &buffer, &buflen, NULL);
1943       if (!relptr)
1944         {
1945           log_error (_("can't access %s - invalid OpenPGP card?\n"),
1946                      "CHV Status Bytes");
1947           goto leave;
1948         }
1949       app->force_chv1 = (buflen && *buffer == 0);
1950       xfree (relptr);
1951
1952       relptr = get_one_do (app, 0x00C0, &buffer, &buflen, NULL);
1953       if (!relptr)
1954         {
1955           log_error (_("can't access %s - invalid OpenPGP card?\n"),
1956                      "Extended Capability Flags" );
1957           goto leave;
1958         }
1959       if (buflen)
1960         {
1961           app->app_local->extcap.get_challenge    = !!(*buffer & 0x40);
1962           app->app_local->extcap.key_import       = !!(*buffer & 0x20);
1963           app->app_local->extcap.change_force_chv = !!(*buffer & 0x10);
1964           app->app_local->extcap.private_dos      = !!(*buffer & 0x08);
1965         }
1966       xfree (relptr);
1967       
1968       /* Some of the first cards accidently don't set the
1969          CHANGE_FORCE_CHV bit but allow it anyway. */
1970       if (app->card_version <= 0x0100 && manufacturer == 1)
1971         app->app_local->extcap.change_force_chv = 1;
1972
1973       parse_login_data (app);
1974
1975       if (opt.verbose > 1)
1976         dump_all_do (slot);
1977
1978       app->fnc.deinit = do_deinit;
1979       app->fnc.learn_status = do_learn_status;
1980       app->fnc.readkey = do_readkey;
1981       app->fnc.getattr = do_getattr;
1982       app->fnc.setattr = do_setattr;
1983       app->fnc.genkey = do_genkey;
1984       app->fnc.sign = do_sign;
1985       app->fnc.auth = do_auth;
1986       app->fnc.decipher = do_decipher;
1987       app->fnc.change_pin = do_change_pin;
1988       app->fnc.check_pin = do_check_pin;
1989    }
1990
1991 leave:
1992   if (rc)
1993     do_deinit (app);
1994   return rc;
1995 }
1996
1997
1998
1999 /* This function is a hack to retrieve essential information about the
2000    card to be displayed by simple tools.  It mostly resembles what the
2001    LEARN command returns. All parameters return allocated strings or
2002    buffers or NULL if the data object is not available.  All returned
2003    values are sanitized. */
2004 int
2005 app_openpgp_cardinfo (app_t app,
2006                       char **serialno,
2007                       char **disp_name,
2008                       char **pubkey_url,
2009                       unsigned char **fpr1,
2010                       unsigned char **fpr2,
2011                       unsigned char **fpr3)
2012 {
2013   int rc;
2014   void *relptr;
2015   unsigned char *value;
2016   size_t valuelen;
2017
2018   if (serialno)
2019     {
2020       time_t dummy;
2021
2022       *serialno = NULL;
2023       rc = app_get_serial_and_stamp (app, serialno, &dummy);
2024       if (rc)
2025         {
2026           log_error (_("error getting serial number: %s\n"),
2027                      gpg_strerror (rc));
2028           return rc;
2029         }
2030     }
2031       
2032   if (disp_name)
2033     {
2034       *disp_name = NULL;
2035       relptr = get_one_do (app, 0x005B, &value, &valuelen, NULL);
2036       if (relptr)
2037         {
2038           *disp_name = make_printable_string (value, valuelen, 0);
2039           xfree (relptr);
2040         }
2041     }
2042
2043   if (pubkey_url)
2044     {
2045       *pubkey_url = NULL;
2046       relptr = get_one_do (app, 0x5F50, &value, &valuelen, NULL);
2047       if (relptr)
2048         {
2049           *pubkey_url = make_printable_string (value, valuelen, 0);
2050           xfree (relptr);
2051         }
2052     }
2053
2054   if (fpr1)
2055     *fpr1 = NULL;
2056   if (fpr2)
2057     *fpr2 = NULL;
2058   if (fpr3)
2059     *fpr3 = NULL;
2060   relptr = get_one_do (app, 0x00C5, &value, &valuelen, NULL);
2061   if (relptr && valuelen >= 60)
2062     {
2063       if (fpr1)
2064         {
2065           *fpr1 = xmalloc (20);
2066           memcpy (*fpr1, value +  0, 20);
2067         }
2068       if (fpr2)
2069         {
2070           *fpr2 = xmalloc (20);
2071           memcpy (*fpr2, value + 20, 20);
2072         }
2073       if (fpr3)
2074         {
2075           *fpr3 = xmalloc (20);
2076           memcpy (*fpr3, value + 40, 20);
2077         }
2078     }
2079   xfree (relptr);
2080
2081   return 0;
2082 }
2083
2084
2085
2086 /* This function is currently only used by the sc-copykeys program to
2087    store a key on the smartcard.  app_t ist the application handle,
2088    KEYNO is the number of the key and PINCB, PINCB_ARG are used to ask
2089    for the SO PIN.  TEMPLATE and TEMPLATE_LEN describe a buffer with
2090    the key template to store. CREATED_AT is the timestamp used to
2091    create the fingerprint. M, MLEN is the RSA modulus and E, ELEN the
2092    RSA public exponent. This function silently overwrites an existing
2093    key.*/
2094 int 
2095 app_openpgp_storekey (app_t app, int keyno,
2096                       unsigned char *template, size_t template_len,
2097                       time_t created_at,
2098                       const unsigned char *m, size_t mlen,
2099                       const unsigned char *e, size_t elen,
2100                       int (*pincb)(void*, const char *, char **),
2101                       void *pincb_arg)
2102 {
2103   int rc;
2104   unsigned char fprbuf[20];
2105
2106   if (keyno < 1 || keyno > 3)
2107     return gpg_error (GPG_ERR_INV_ID);
2108   keyno--;
2109
2110   rc = verify_chv3 (app, pincb, pincb_arg);
2111   if (rc)
2112     goto leave;
2113
2114   flush_cache (app);
2115
2116   gcry_sexp_release (app->app_local->pk[keyno].key);
2117   app->app_local->pk[keyno].read_done = 0;
2118
2119   rc = iso7816_put_data (app->slot,
2120                          (app->card_version > 0x0007? 0xE0 : 0xE9) + keyno,
2121                          template, template_len);
2122   if (rc)
2123     {
2124       log_error (_("failed to store the key: %s\n"), gpg_strerror (rc));
2125       rc = gpg_error (GPG_ERR_CARD);
2126       goto leave;
2127     }
2128  
2129 /*    log_printhex ("RSA n:", m, mlen);  */
2130 /*    log_printhex ("RSA e:", e, elen);  */
2131
2132   rc = store_fpr (app->slot, keyno, (u32)created_at,
2133                   m, mlen, e, elen, fprbuf, app->card_version);
2134
2135  leave:
2136   return rc;
2137 }
2138
2139
2140 /* Utility function for external tools: Read the public RSA key at
2141    KEYNO and return modulus and exponent in (M,MLEN) and (E,ELEN). */
2142 int 
2143 app_openpgp_readkey (app_t app, int keyno, unsigned char **m, size_t *mlen,
2144                      unsigned char **e, size_t *elen)
2145 {
2146   int rc;
2147   const unsigned char *keydata, *a;
2148   unsigned char *buffer;
2149   size_t buflen, keydatalen, alen;
2150
2151   *m = NULL;
2152   *e = NULL;
2153
2154   if (keyno < 1 || keyno > 3)
2155     return gpg_error (GPG_ERR_INV_ID);
2156   keyno--;
2157
2158   rc = iso7816_read_public_key(app->slot, 
2159                                keyno == 0? "\xB6" :
2160                                keyno == 1? "\xB8" : "\xA4",
2161                                2,
2162                                &buffer, &buflen);
2163   if (rc)
2164     {
2165       rc = gpg_error (GPG_ERR_CARD);
2166       log_error (_("reading the key failed\n"));
2167       goto leave;
2168     }
2169
2170   keydata = find_tlv (buffer, buflen, 0x7F49, &keydatalen);
2171   if (!keydata)
2172     {
2173       log_error (_("response does not contain the public key data\n"));
2174       rc = gpg_error (GPG_ERR_CARD);
2175       goto leave;
2176     }
2177  
2178   a = find_tlv (keydata, keydatalen, 0x0081, &alen);
2179   if (!a)
2180     {
2181       log_error (_("response does not contain the RSA modulus\n"));
2182       rc = gpg_error (GPG_ERR_CARD);
2183       goto leave;
2184     }
2185   *mlen = alen;
2186   *m = xmalloc (alen);
2187   memcpy (*m, a, alen);
2188   
2189   a = find_tlv (keydata, keydatalen, 0x0082, &alen);
2190   if (!a)
2191     {
2192       log_error (_("response does not contain the RSA public exponent\n"));
2193       rc = gpg_error (GPG_ERR_CARD);
2194       goto leave;
2195     }
2196   *elen = alen;
2197   *e = xmalloc (alen);
2198   memcpy (*e, a, alen);
2199
2200  leave:
2201   xfree (buffer);
2202   if (rc)
2203     { 
2204       xfree (*m); *m = NULL;
2205       xfree (*e); *e = NULL;
2206     }
2207   return rc;
2208 }