Preparing a release.
[gnupg.git] / scd / app-openpgp.c
1 /* app-openpgp.c - The OpenPGP card application.
2  * Copyright (C) 2003, 2004, 2005, 2007, 2008 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 3 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, see <http://www.gnu.org/licenses/>.
18  *
19  * $Id$
20  */
21
22 #include <config.h>
23 #include <errno.h>
24 #include <stdio.h>
25 #include <stdlib.h>
26 #include <string.h>
27 #include <assert.h>
28 #include <time.h>
29
30 #if GNUPG_MAJOR_VERSION == 1
31 /* This is used with GnuPG version < 1.9.  The code has been source
32    copied from the current GnuPG >= 1.9  and is maintained over
33    there. */
34 #include "options.h"
35 #include "errors.h"
36 #include "memory.h"
37 #include "util.h"
38 #include "cardglue.h"
39 #else /* GNUPG_MAJOR_VERSION != 1 */
40 #include "scdaemon.h"
41 #endif /* GNUPG_MAJOR_VERSION != 1 */
42
43 #include "i18n.h"
44 #include "iso7816.h"
45 #include "app-common.h"
46 #include "tlv.h"
47
48
49 static struct {
50   int tag;
51   int constructed;
52   int get_from;  /* Constructed DO with this DO or 0 for direct access. */
53   int binary;
54   int dont_cache;
55   int flush_on_error;
56   int get_immediate_in_v11; /* Enable a hack to bypass the cache of
57                                this data object if it is used in 1.1
58                                and later versions of the card.  This
59                                does not work with composite DO and is
60                                currently only useful for the CHV
61                                status bytes. */
62   char *desc;
63 } data_objects[] = {
64   { 0x005E, 0,    0, 1, 0, 0, 0, "Login Data" },
65   { 0x5F50, 0,    0, 0, 0, 0, 0, "URL" },
66   { 0x0065, 1,    0, 1, 0, 0, 0, "Cardholder Related Data"},
67   { 0x005B, 0, 0x65, 0, 0, 0, 0, "Name" },
68   { 0x5F2D, 0, 0x65, 0, 0, 0, 0, "Language preferences" },
69   { 0x5F35, 0, 0x65, 0, 0, 0, 0, "Sex" },
70   { 0x006E, 1,    0, 1, 0, 0, 0, "Application Related Data" },
71   { 0x004F, 0, 0x6E, 1, 0, 0, 0, "AID" },
72   { 0x0073, 1,    0, 1, 0, 0, 0, "Discretionary Data Objects" },
73   { 0x0047, 0, 0x6E, 1, 1, 0, 0, "Card Capabilities" },
74   { 0x00C0, 0, 0x6E, 1, 1, 0, 0, "Extended Card Capabilities" },
75   { 0x00C1, 0, 0x6E, 1, 1, 0, 0, "Algorithm Attributes Signature" },
76   { 0x00C2, 0, 0x6E, 1, 1, 0, 0, "Algorithm Attributes Decryption" },
77   { 0x00C3, 0, 0x6E, 1, 1, 0, 0, "Algorithm Attributes Authentication" },
78   { 0x00C4, 0, 0x6E, 1, 0, 1, 1, "CHV Status Bytes" },
79   { 0x00C5, 0, 0x6E, 1, 0, 0, 0, "Fingerprints" },
80   { 0x00C6, 0, 0x6E, 1, 0, 0, 0, "CA Fingerprints" },
81   { 0x00CD, 0, 0x6E, 1, 0, 0, 0, "Generation time" },
82   { 0x007A, 1,    0, 1, 0, 0, 0, "Security Support Template" },
83   { 0x0093, 0, 0x7A, 1, 1, 0, 0, "Digital Signature Counter" },
84   { 0x0101, 0,    0, 0, 0, 0, 0, "Private DO 1"},
85   { 0x0102, 0,    0, 0, 0, 0, 0, "Private DO 2"},
86   { 0x0103, 0,    0, 0, 0, 0, 0, "Private DO 3"},
87   { 0x0104, 0,    0, 0, 0, 0, 0, "Private DO 4"},
88   { 0 }
89 };
90
91
92 /* One cache item for DOs.  */
93 struct cache_s {
94   struct cache_s *next;
95   int tag;
96   size_t length;
97   unsigned char data[1];
98 };
99
100
101 /* Object with application (i.e. OpenPGP card) specific data.  */
102 struct app_local_s {
103   /* A linked list with cached DOs.  */
104   struct cache_s *cache;
105   
106   /* Keep track of the public keys.  */
107   struct
108   {
109     int read_done;   /* True if we have at least tried to read them.  */
110     unsigned char *key; /* This is a malloced buffer with a canonical
111                            encoded S-expression encoding a public
112                            key. Might be NULL if key is not
113                            available.  */
114     size_t keylen;      /* The length of the above S-expression.  This
115                            is usullay only required for cross checks
116                            because the length of an S-expression is
117                            implicitly available.  */
118   } pk[3];
119
120   /* Keep track of card capabilities.  */
121   struct 
122   {
123     unsigned int get_challenge:1;
124     unsigned int key_import:1;
125     unsigned int change_force_chv:1;
126     unsigned int private_dos:1;
127   } extcap;
128
129   /* Flags used to control the application.  */
130   struct
131   {
132     unsigned int no_sync:1;   /* Do not sync CHV1 and CHV2 */
133     unsigned int def_chv2:1;  /* Use 123456 for CHV2.  */
134   } flags;
135 };
136
137
138
139 /***** Local prototypes  *****/
140 static unsigned long convert_sig_counter_value (const unsigned char *value,
141                                                 size_t valuelen);
142 static unsigned long get_sig_counter (app_t app);
143 static gpg_error_t do_auth (app_t app, const char *keyidstr,
144                             gpg_error_t (*pincb)(void*, const char *, char **),
145                             void *pincb_arg,
146                             const void *indata, size_t indatalen,
147                             unsigned char **outdata, size_t *outdatalen);
148
149
150
151
152 \f
153 /* Deconstructor. */
154 static void
155 do_deinit (app_t app)
156 {
157   if (app && app->app_local)
158     {
159       struct cache_s *c, *c2;
160       int i;
161
162       for (c = app->app_local->cache; c; c = c2)
163         {
164           c2 = c->next;
165           xfree (c);
166         }
167
168       for (i=0; i < DIM (app->app_local->pk); i++)
169         {
170           xfree (app->app_local->pk[i].key);
171           app->app_local->pk[i].read_done = 0;
172         }
173       xfree (app->app_local);
174       app->app_local = NULL;
175     }
176 }
177
178
179 /* Wrapper around iso7816_get_data which first tries to get the data
180    from the cache.  With GET_IMMEDIATE passed as true, the cache is
181    bypassed. */
182 static gpg_error_t
183 get_cached_data (app_t app, int tag, 
184                  unsigned char **result, size_t *resultlen,
185                  int get_immediate)
186 {
187   gpg_error_t err;
188   int i;
189   unsigned char *p;
190   size_t len;
191   struct cache_s *c;
192
193   *result = NULL;
194   *resultlen = 0;
195
196   if (!get_immediate)
197     {
198       for (c=app->app_local->cache; c; c = c->next)
199         if (c->tag == tag)
200           {
201             if(c->length)
202               {
203                 p = xtrymalloc (c->length);
204                 if (!p)
205                   return gpg_error (gpg_err_code_from_errno (errno));
206                 memcpy (p, c->data, c->length);
207                 *result = p;
208               }
209             
210             *resultlen = c->length;
211             
212             return 0;
213           }
214     }
215   
216   err = iso7816_get_data (app->slot, tag, &p, &len);
217   if (err)
218     return err;
219   *result = p;
220   *resultlen = len;
221
222   /* Check whether we should cache this object. */
223   if (get_immediate)
224     return 0;
225
226   for (i=0; data_objects[i].tag; i++)
227     if (data_objects[i].tag == tag)
228       {
229         if (data_objects[i].dont_cache)
230           return 0;
231         break;
232       }
233
234   /* Okay, cache it. */
235   for (c=app->app_local->cache; c; c = c->next)
236     assert (c->tag != tag);
237   
238   c = xtrymalloc (sizeof *c + len);
239   if (c)
240     {
241       memcpy (c->data, p, len);
242       c->length = len;
243       c->tag = tag;
244       c->next = app->app_local->cache;
245       app->app_local->cache = c;
246     }
247
248   return 0;
249 }
250
251 /* Remove DO at TAG from the cache. */
252 static void
253 flush_cache_item (app_t app, int tag)
254 {
255   struct cache_s *c, *cprev;
256   int i;
257
258   if (!app->app_local)
259     return;
260
261   for (c=app->app_local->cache, cprev=NULL; c ; cprev=c, c = c->next)
262     if (c->tag == tag)
263       {
264         if (cprev)
265           cprev->next = c->next;
266         else
267           app->app_local->cache = c->next;
268         xfree (c);
269
270         for (c=app->app_local->cache; c ; c = c->next)
271           {
272             assert (c->tag != tag); /* Oops: duplicated entry. */
273           }
274         return;
275       }
276
277   /* Try again if we have an outer tag. */
278   for (i=0; data_objects[i].tag; i++)
279     if (data_objects[i].tag == tag && data_objects[i].get_from
280         && data_objects[i].get_from != tag)
281       flush_cache_item (app, data_objects[i].get_from);
282 }
283
284 /* Flush all entries from the cache which might be out of sync after
285    an error. */
286 static void
287 flush_cache_after_error (app_t app)
288 {
289   int i;
290
291   for (i=0; data_objects[i].tag; i++)
292     if (data_objects[i].flush_on_error)
293       flush_cache_item (app, data_objects[i].tag);
294 }
295
296
297 /* Flush the entire cache. */
298 static void
299 flush_cache (app_t app)
300 {
301   if (app && app->app_local)
302     {
303       struct cache_s *c, *c2;
304
305       for (c = app->app_local->cache; c; c = c2)
306         {
307           c2 = c->next;
308           xfree (c);
309         }
310       app->app_local->cache = NULL;
311     }
312 }
313
314
315 /* Get the DO identified by TAG from the card in SLOT and return a
316    buffer with its content in RESULT and NBYTES.  The return value is
317    NULL if not found or a pointer which must be used to release the
318    buffer holding value. */
319 static void *
320 get_one_do (app_t app, int tag, unsigned char **result, size_t *nbytes,
321             int *r_rc)
322 {
323   int rc, i;
324   unsigned char *buffer;
325   size_t buflen;
326   unsigned char *value;
327   size_t valuelen;
328   int dummyrc;
329
330   if (!r_rc)
331     r_rc = &dummyrc;
332
333   *result = NULL;
334   *nbytes = 0;
335   *r_rc = 0;
336   for (i=0; data_objects[i].tag && data_objects[i].tag != tag; i++)
337     ;
338
339   if (app->card_version > 0x0100 && data_objects[i].get_immediate_in_v11)
340     {
341       rc = iso7816_get_data (app->slot, tag, &buffer, &buflen);
342       if (rc)
343         {
344           *r_rc = rc;
345           return NULL;
346         }
347       *result = buffer;
348       *nbytes = buflen;
349       return buffer;
350     }
351
352   value = NULL;
353   rc = -1;
354   if (data_objects[i].tag && data_objects[i].get_from)
355     {
356       rc = get_cached_data (app, data_objects[i].get_from,
357                             &buffer, &buflen,
358                             (data_objects[i].dont_cache 
359                              || data_objects[i].get_immediate_in_v11));
360       if (!rc)
361         {
362           const unsigned char *s;
363
364           s = find_tlv_unchecked (buffer, buflen, tag, &valuelen);
365           if (!s)
366             value = NULL; /* not found */
367           else if (valuelen > buflen - (s - buffer))
368             {
369               log_error ("warning: constructed DO too short\n");
370               value = NULL;
371               xfree (buffer); buffer = NULL;
372             }
373           else
374             value = buffer + (s - buffer);
375         }
376     }
377
378   if (!value) /* Not in a constructed DO, try simple. */
379     {
380       rc = get_cached_data (app, tag, &buffer, &buflen,
381                             (data_objects[i].dont_cache 
382                              || data_objects[i].get_immediate_in_v11));
383       if (!rc)
384         {
385           value = buffer;
386           valuelen = buflen;
387         }
388     }
389
390   if (!rc)
391     {
392       *nbytes = valuelen;
393       *result = value;
394       return buffer;
395     }
396   *r_rc = rc;
397   return NULL;
398 }
399
400
401 static void
402 dump_all_do (int slot)
403 {
404   int rc, i, j;
405   unsigned char *buffer;
406   size_t buflen;
407   
408   for (i=0; data_objects[i].tag; i++)
409     {
410       if (data_objects[i].get_from)
411         continue;
412
413       rc = iso7816_get_data (slot, data_objects[i].tag, &buffer, &buflen);
414       if (gpg_err_code (rc) == GPG_ERR_NO_OBJ)
415         ;
416       else if (rc) 
417         log_info ("DO `%s' not available: %s\n",
418                   data_objects[i].desc, gpg_strerror (rc));
419       else
420         {
421           if (data_objects[i].binary)
422             {
423               log_info ("DO `%s': ", data_objects[i].desc);
424               log_printhex ("", buffer, buflen);
425             }
426           else
427             log_info ("DO `%s': `%.*s'\n",
428                       data_objects[i].desc,
429                       (int)buflen, buffer); /* FIXME: sanitize */
430
431           if (data_objects[i].constructed)
432             {
433               for (j=0; data_objects[j].tag; j++)
434                 {
435                   const unsigned char *value;
436                   size_t valuelen;
437                   
438                   if (j==i || data_objects[i].tag != data_objects[j].get_from)
439                     continue;
440                   value = find_tlv_unchecked (buffer, buflen,
441                                               data_objects[j].tag, &valuelen);
442                   if (!value)
443                     ; /* not found */
444                   else if (valuelen > buflen - (value - buffer))
445                     log_error ("warning: constructed DO too short\n");
446                   else
447                     {
448                       if (data_objects[j].binary)
449                         {
450                           log_info ("DO `%s': ", data_objects[j].desc);
451                           log_printhex ("", value, valuelen);
452                         }
453                       else
454                         log_info ("DO `%s': `%.*s'\n",
455                                   data_objects[j].desc,
456                                   (int)valuelen, value); /* FIXME: sanitize */
457                     }
458                 }
459             }
460         }
461       xfree (buffer); buffer = NULL;
462     }
463 }
464
465
466 /* Count the number of bits, assuming the A represents an unsigned big
467    integer of length LEN bytes. */
468 static unsigned int
469 count_bits (const unsigned char *a, size_t len)
470 {
471   unsigned int n = len * 8;
472   int i;
473
474   for (; len && !*a; len--, a++, n -=8)
475     ;
476   if (len)
477     {
478       for (i=7; i && !(*a & (1<<i)); i--)
479         n--;
480     }
481   return n;
482 }
483
484 /* GnuPG makes special use of the login-data DO, this fucntion parses
485    the login data to store the flags for later use.  It may be called
486    at any time and should be called after changing the login-data DO.
487
488    Everything up to a LF is considered a mailbox or account name.  If
489    the first LF is followed by DC4 (0x14) control sequence are
490    expected up to the next LF.  Control sequences are separated by FS
491    (0x18) and consist of key=value pairs.  There is one key defined:
492
493     F=<flags>
494
495     Were FLAGS is a plain hexadecimal number representing flag values.
496     The lsb is here the rightmost bit.  Defined flags bits are:
497
498       Bit 0 = CHV1 and CHV2 are not syncronized
499       Bit 1 = CHV2 has been been set to the default PIN of "123456"
500               (this implies that bit 0 is also set).
501
502 */
503 static void
504 parse_login_data (app_t app)
505 {
506   unsigned char *buffer, *p;
507   size_t buflen, len;
508   void *relptr;
509
510   /* Set defaults.  */
511   app->app_local->flags.no_sync = 0;
512   app->app_local->flags.def_chv2 = 0;
513
514   /* Read the DO.  */
515   relptr = get_one_do (app, 0x005E, &buffer, &buflen, NULL);
516   if (!relptr)
517     return; /* Ooops. */
518   for (; buflen; buflen--, buffer++)
519     if (*buffer == '\n')
520       break;
521   if (buflen < 2 || buffer[1] != '\x14')
522     return; /* No control sequences.  */
523   buflen--;
524   buffer++;
525   do
526     {
527       buflen--;
528       buffer++;
529       if (buflen > 1 && *buffer == 'F' && buffer[1] == '=')
530         {
531           /* Flags control sequence found.  */
532           int lastdig = 0;
533
534           /* For now we are only interested in the last digit, so skip
535              any leading digits but bail out on invalid characters. */
536           for (p=buffer+2, len = buflen-2; len && hexdigitp (p); p++, len--)
537             lastdig = xtoi_1 (p);
538           if (len && !(*p == '\n' || *p == '\x18'))
539             goto next;  /* Invalid characters in field.  */
540           app->app_local->flags.no_sync = !!(lastdig & 1);
541           app->app_local->flags.def_chv2 = (lastdig & 3) == 3;
542         }
543     next:
544       for (; buflen && *buffer != '\x18'; buflen--, buffer++)
545         if (*buffer == '\n')
546           buflen = 1; 
547     }
548   while (buflen);
549
550   xfree (relptr);
551 }
552
553 /* Note, that FPR must be at least 20 bytes. */
554 static gpg_error_t 
555 store_fpr (int slot, int keynumber, u32 timestamp,
556            const unsigned char *m, size_t mlen,
557            const unsigned char *e, size_t elen, 
558            unsigned char *fpr, unsigned int card_version)
559 {
560   unsigned int n, nbits;
561   unsigned char *buffer, *p;
562   int rc;
563   
564   for (; mlen && !*m; mlen--, m++) /* strip leading zeroes */
565     ;
566   for (; elen && !*e; elen--, e++) /* strip leading zeroes */
567     ;
568
569   n = 6 + 2 + mlen + 2 + elen;
570   p = buffer = xtrymalloc (3 + n);
571   if (!buffer)
572     return gpg_error_from_syserror ();
573   
574   *p++ = 0x99;     /* ctb */
575   *p++ = n >> 8;   /* 2 byte length header */
576   *p++ = n;
577   *p++ = 4;        /* key packet version */
578   *p++ = timestamp >> 24;
579   *p++ = timestamp >> 16;
580   *p++ = timestamp >>  8;
581   *p++ = timestamp;
582   *p++ = 1; /* RSA */
583   nbits = count_bits (m, mlen);
584   *p++ = nbits >> 8;
585   *p++ = nbits;
586   memcpy (p, m, mlen); p += mlen;
587   nbits = count_bits (e, elen);
588   *p++ = nbits >> 8;
589   *p++ = nbits;
590   memcpy (p, e, elen); p += elen;
591     
592   gcry_md_hash_buffer (GCRY_MD_SHA1, fpr, buffer, n+3);
593
594   xfree (buffer);
595
596   rc = iso7816_put_data (slot, (card_version > 0x0007? 0xC7 : 0xC6)
597                                + keynumber, fpr, 20);
598   if (rc)
599     log_error (_("failed to store the fingerprint: %s\n"),gpg_strerror (rc));
600
601   if (!rc && card_version > 0x0100)
602     {
603       unsigned char buf[4];
604
605       buf[0] = timestamp >> 24;
606       buf[1] = timestamp >> 16;
607       buf[2] = timestamp >>  8;
608       buf[3] = timestamp;
609
610       rc = iso7816_put_data (slot, 0xCE + keynumber, buf, 4);
611       if (rc)
612         log_error (_("failed to store the creation date: %s\n"),
613                    gpg_strerror (rc));
614     }
615
616   return rc;
617 }
618
619        
620 static void
621 send_fpr_if_not_null (ctrl_t ctrl, const char *keyword,
622                       int number, const unsigned char *fpr)
623 {                      
624   int i;
625   char buf[41];
626   char numbuf[25];
627
628   for (i=0; i < 20 && !fpr[i]; i++)
629     ;
630   if (i==20)
631     return; /* All zero. */
632   for (i=0; i< 20; i++)
633     sprintf (buf+2*i, "%02X", fpr[i]);
634   if (number == -1)
635     *numbuf = 0; /* Don't print the key number */
636   else
637     sprintf (numbuf, "%d", number);
638   send_status_info (ctrl, keyword,
639                     numbuf, (size_t)strlen(numbuf),
640                     buf, (size_t)strlen (buf), NULL, 0);
641 }
642
643 static void
644 send_fprtime_if_not_null (ctrl_t ctrl, const char *keyword,
645                           int number, const unsigned char *stamp)
646 {                      
647   char numbuf1[50], numbuf2[50];
648   unsigned long value;
649
650   value = (stamp[0] << 24) | (stamp[1]<<16) | (stamp[2]<<8) | stamp[3];
651   if (!value)
652     return;
653   sprintf (numbuf1, "%d", number);
654   sprintf (numbuf2, "%lu", value);
655   send_status_info (ctrl, keyword,
656                     numbuf1, (size_t)strlen(numbuf1),
657                     numbuf2, (size_t)strlen(numbuf2), NULL, 0);
658 }
659
660 static void
661 send_key_data (ctrl_t ctrl, const char *name, 
662                const unsigned char *a, size_t alen)
663 {
664   char *p, *buf = xmalloc (alen*2+1);
665   
666   for (p=buf; alen; a++, alen--, p += 2)
667     sprintf (p, "%02X", *a);
668
669   send_status_info (ctrl, "KEY-DATA",
670                     name, (size_t)strlen(name), 
671                     buf, (size_t)strlen (buf),
672                     NULL, 0);
673   xfree (buf);
674 }
675
676 /* Implement the GETATTR command.  This is similar to the LEARN
677    command but returns just one value via the status interface. */
678 static gpg_error_t 
679 do_getattr (app_t app, ctrl_t ctrl, const char *name)
680 {
681   static struct {
682     const char *name;
683     int tag;
684     int special;
685   } table[] = {
686     { "DISP-NAME",    0x005B },
687     { "LOGIN-DATA",   0x005E },
688     { "DISP-LANG",    0x5F2D },
689     { "DISP-SEX",     0x5F35 },
690     { "PUBKEY-URL",   0x5F50 },
691     { "KEY-FPR",      0x00C5, 3 },
692     { "KEY-TIME",     0x00CD, 4 },
693     { "CA-FPR",       0x00C6, 3 },
694     { "CHV-STATUS",   0x00C4, 1 }, 
695     { "SIG-COUNTER",  0x0093, 2 },
696     { "SERIALNO",     0x004F, -1 },
697     { "AID",          0x004F },
698     { "EXTCAP",       0x0000, -2 },
699     { "PRIVATE-DO-1", 0x0101 },
700     { "PRIVATE-DO-2", 0x0102 },
701     { "PRIVATE-DO-3", 0x0103 },
702     { "PRIVATE-DO-4", 0x0104 },
703     { "$AUTHKEYID",   0x0000, -3 },
704     { "$DISPSERIALNO",0x0000, -4 },
705     { NULL, 0 }
706   };
707   int idx, i, rc;
708   void *relptr;
709   unsigned char *value;
710   size_t valuelen;
711
712   for (idx=0; table[idx].name && strcmp (table[idx].name, name); idx++)
713     ;
714   if (!table[idx].name)
715     return gpg_error (GPG_ERR_INV_NAME); 
716   
717   if (table[idx].special == -1)
718     {
719       /* The serial number is very special.  We could have used the
720          AID DO to retrieve it, but we have it already in the app
721          context and the stamp argument is required anyway which we
722          can't by other means. The AID DO is available anyway but not
723          hex formatted. */
724       char *serial;
725       time_t stamp;
726       char tmp[50];
727
728       if (!app_get_serial_and_stamp (app, &serial, &stamp))
729         {
730           sprintf (tmp, "%lu", (unsigned long)stamp);
731           send_status_info (ctrl, "SERIALNO",
732                             serial, strlen (serial),
733                             tmp, strlen (tmp),
734                             NULL, 0);
735           xfree (serial);
736         }
737       return 0;
738     }
739   if (table[idx].special == -2)
740     {
741       char tmp[50];
742
743       sprintf (tmp, "gc=%d ki=%d fc=%d pd=%d", 
744                app->app_local->extcap.get_challenge,
745                app->app_local->extcap.key_import,
746                app->app_local->extcap.change_force_chv,
747                app->app_local->extcap.private_dos);
748       send_status_info (ctrl, table[idx].name, tmp, strlen (tmp), NULL, 0);
749       return 0;
750     }
751   if (table[idx].special == -3)
752     {
753       char const tmp[] = "OPENPGP.3";
754       send_status_info (ctrl, table[idx].name, tmp, strlen (tmp), NULL, 0);
755       return 0;
756     }
757   if (table[idx].special == -4)
758     {
759       char *serial;
760       time_t stamp;
761     
762       if (!app_get_serial_and_stamp (app, &serial, &stamp))
763         {
764           if (strlen (serial) > 16+12)
765             {
766               send_status_info (ctrl, table[idx].name, serial+16, 12, NULL, 0);
767               xfree (serial);
768               return 0;
769             }
770           xfree (serial);
771         }
772       return gpg_error (GPG_ERR_INV_NAME); 
773     }
774
775   relptr = get_one_do (app, table[idx].tag, &value, &valuelen, &rc);
776   if (relptr)
777     {
778       if (table[idx].special == 1)
779         {
780           char numbuf[7*23];
781           
782           for (i=0,*numbuf=0; i < valuelen && i < 7; i++)
783             sprintf (numbuf+strlen (numbuf), " %d", value[i]); 
784           send_status_info (ctrl, table[idx].name,
785                             numbuf, strlen (numbuf), NULL, 0);
786         }
787       else if (table[idx].special == 2)
788         {
789           char numbuf[50];
790
791           sprintf (numbuf, "%lu", convert_sig_counter_value (value, valuelen));
792           send_status_info (ctrl, table[idx].name,
793                             numbuf, strlen (numbuf), NULL, 0);
794         }
795       else if (table[idx].special == 3)
796         {
797           if (valuelen >= 60)
798             for (i=0; i < 3; i++)
799               send_fpr_if_not_null (ctrl, table[idx].name, i+1, value+i*20);
800         }
801       else if (table[idx].special == 4)
802         {
803           if (valuelen >= 12)
804             for (i=0; i < 3; i++)
805               send_fprtime_if_not_null (ctrl, table[idx].name, i+1, value+i*4);
806         }
807       else
808         send_status_info (ctrl, table[idx].name, value, valuelen, NULL, 0);
809
810       xfree (relptr);
811     }
812   return rc;
813 }
814
815 /* Retrieve the fingerprint from the card inserted in SLOT and write
816    the according hex representation to FPR.  Caller must have provide
817    a buffer at FPR of least 41 bytes.  Returns 0 on success or an
818    error code. */
819 #if GNUPG_MAJOR_VERSION > 1
820 static gpg_error_t
821 retrieve_fpr_from_card (app_t app, int keyno, char *fpr)
822 {
823   gpg_error_t err = 0;
824   void *relptr;
825   unsigned char *value;
826   size_t valuelen;
827   int i;
828
829   assert (keyno >=0 && keyno <= 2);
830
831   relptr = get_one_do (app, 0x00C5, &value, &valuelen, NULL);
832   if (relptr && valuelen >= 60)
833     {
834       for (i = 0; i < 20; i++)
835         sprintf (fpr + (i * 2), "%02X", value[(keyno*20)+i]);
836     }
837   else
838     err = gpg_error (GPG_ERR_NOT_FOUND);
839   xfree (relptr);
840   return err;
841 }
842 #endif /*GNUPG_MAJOR_VERSION > 1*/
843
844
845 /* Retrieve the public key material for the RSA key, whose fingerprint
846    is FPR, from gpg output, which can be read through the stream FP.
847    The RSA modulus will be stored at the address of M and MLEN, the
848    public exponent at E and ELEN.  Returns zero on success, an error
849    code on failure.  Caller must release the allocated buffers at M
850    and E if the function returns success.  */
851 #if GNUPG_MAJOR_VERSION > 1
852 static gpg_error_t
853 retrieve_key_material (FILE *fp, const char *hexkeyid,
854                        const unsigned char **m, size_t *mlen,
855                        const unsigned char **e, size_t *elen)
856 {
857   gcry_error_t err = 0;
858   char *line = NULL;    /* read_line() buffer. */
859   size_t line_size = 0; /* Helper for for read_line. */
860   int found_key = 0;    /* Helper to find a matching key. */
861   unsigned char *m_new = NULL;
862   unsigned char *e_new = NULL;
863   size_t m_new_n = 0;
864   size_t e_new_n = 0;
865
866   /* Loop over all records until we have found the subkey
867      corresponsing to the fingerprint. Inm general the first record
868      should be the pub record, but we don't rely on that.  Given that
869      we only need to look at one key, it is sufficient to compare the
870      keyid so that we don't need to look at "fpr" records. */
871   for (;;)
872     {
873       char *p;
874       char *fields[6];
875       int nfields;
876       size_t max_length;
877       gcry_mpi_t mpi;
878       int i;
879
880       max_length = 4096;
881       i = read_line (fp, &line, &line_size, &max_length);
882       if (!i)
883         break; /* EOF. */
884       if (i < 0)
885         {
886           err = gpg_error_from_syserror ();
887           goto leave; /* Error. */
888         }
889       if (!max_length)
890         {
891           err = gpg_error (GPG_ERR_TRUNCATED);
892           goto leave;  /* Line truncated - we better stop processing.  */
893         }
894
895       /* Parse the line into fields. */
896       for (nfields=0, p=line; p && nfields < DIM (fields); nfields++)
897         {
898           fields[nfields] = p;
899           p = strchr (p, ':');
900           if (p)
901             *(p++) = 0;
902         }
903       if (!nfields)
904         continue; /* No fields at all - skip line.  */
905
906       if (!found_key)
907         {
908           if ( (!strcmp (fields[0], "sub") || !strcmp (fields[0], "pub") )
909                && nfields > 4 && !strcmp (fields[4], hexkeyid))
910             found_key = 1;
911           continue;
912         }
913       
914       if ( !strcmp (fields[0], "sub") || !strcmp (fields[0], "pub") )
915         break; /* Next key - stop.  */
916
917       if ( strcmp (fields[0], "pkd") )
918         continue; /* Not a key data record.  */
919       i = 0; /* Avoid erroneous compiler warning. */
920       if ( nfields < 4 || (i = atoi (fields[1])) < 0 || i > 1
921            || (!i && m_new) || (i && e_new))
922         {
923           err = gpg_error (GPG_ERR_GENERAL);
924           goto leave; /* Error: Invalid key data record or not an RSA key.  */
925         }
926       
927       err = gcry_mpi_scan (&mpi, GCRYMPI_FMT_HEX, fields[3], 0, NULL);
928       if (err)
929         mpi = NULL;
930       else if (!i)
931         err = gcry_mpi_aprint (GCRYMPI_FMT_STD, &m_new, &m_new_n, mpi);
932       else
933         err = gcry_mpi_aprint (GCRYMPI_FMT_STD, &e_new, &e_new_n, mpi);
934       gcry_mpi_release (mpi);
935       if (err)
936         goto leave;
937     }
938   
939   if (m_new && e_new)
940     {
941       *m = m_new;
942       *mlen = m_new_n;
943       m_new = NULL;
944       *e = e_new;
945       *elen = e_new_n;
946       e_new = NULL;
947     }
948   else
949     err = gpg_error (GPG_ERR_GENERAL);
950
951  leave:
952   xfree (m_new);
953   xfree (e_new);
954   xfree (line);
955   return err;
956 }
957 #endif /*GNUPG_MAJOR_VERSION > 1*/
958
959
960 /* Get the public key for KEYNO and store it as an S-expresion with
961    the APP handle.  On error that field gets cleared.  If we already
962    know about the public key we will just return.  Note that this does
963    not mean a key is available; this is soley indicated by the
964    presence of the app->app_local->pk[KEYNO-1].key field.
965
966    Note that GnuPG 1.x does not need this and it would be too time
967    consuming to send it just for the fun of it. However, given that we
968    use the same code in gpg 1.4, we can't use the gcry S-expresion
969    here but need to open encode it. */
970 #if GNUPG_MAJOR_VERSION > 1
971 static gpg_error_t
972 get_public_key (app_t app, int keyno)
973 {
974   gpg_error_t err = 0;
975   unsigned char *buffer;
976   const unsigned char *keydata, *m, *e;
977   size_t buflen, keydatalen, mlen, elen;
978   unsigned char *mbuf = NULL;
979   unsigned char *ebuf = NULL;
980   char *keybuf = NULL;
981   char *keybuf_p;
982
983   if (keyno < 1 || keyno > 3)
984     return gpg_error (GPG_ERR_INV_ID);
985   keyno--;
986
987   /* Already cached? */
988   if (app->app_local->pk[keyno].read_done)
989     return 0;
990
991   xfree (app->app_local->pk[keyno].key);
992   app->app_local->pk[keyno].key = NULL;
993   app->app_local->pk[keyno].keylen = 0;
994
995   m = e = NULL; /* (avoid cc warning) */
996
997   if (app->card_version > 0x0100)
998     {
999       /* We may simply read the public key out of these cards.  */
1000       err = iso7816_read_public_key 
1001         (app->slot, (const unsigned char*)(keyno == 0? "\xB6" :
1002                                            keyno == 1? "\xB8" : "\xA4"),
1003          2,  
1004          &buffer, &buflen);
1005       if (err)
1006         {
1007           log_error (_("reading public key failed: %s\n"), gpg_strerror (err));
1008           goto leave;
1009         }
1010
1011       keydata = find_tlv (buffer, buflen, 0x7F49, &keydatalen);
1012       if (!keydata)
1013         {
1014           err = gpg_error (GPG_ERR_CARD);
1015           log_error (_("response does not contain the public key data\n"));
1016           goto leave;
1017         }
1018  
1019       m = find_tlv (keydata, keydatalen, 0x0081, &mlen);
1020       if (!m)
1021         {
1022           err = gpg_error (GPG_ERR_CARD);
1023           log_error (_("response does not contain the RSA modulus\n"));
1024           goto leave;
1025         }
1026       
1027
1028       e = find_tlv (keydata, keydatalen, 0x0082, &elen);
1029       if (!e)
1030         {
1031           err = gpg_error (GPG_ERR_CARD);
1032           log_error (_("response does not contain the RSA public exponent\n"));
1033           goto leave;
1034         }
1035
1036       /* Prepend numbers with a 0 if needed.  */
1037       if (mlen && (*m & 0x80))
1038         {
1039           mbuf = xtrymalloc ( mlen + 1);
1040           if (!mbuf)
1041             {
1042               err = gpg_error_from_syserror ();
1043               goto leave;
1044             }
1045           *mbuf = 0;
1046           memcpy (mbuf+1, m, mlen);
1047           mlen++;
1048           m = mbuf;
1049         }
1050       if (elen && (*e & 0x80))
1051         {
1052           ebuf = xtrymalloc ( elen + 1);
1053           if (!ebuf)
1054             {
1055               err = gpg_error_from_syserror ();
1056               goto leave;
1057             }
1058           *ebuf = 0;
1059           memcpy (ebuf+1, e, elen);
1060           elen++;
1061           e = ebuf;
1062         }
1063
1064     }
1065   else
1066     {
1067       /* Due to a design problem in v1.0 cards we can't get the public
1068          key out of these cards without doing a verify on CHV3.
1069          Clearly that is not an option and thus we try to locate the
1070          key using an external helper.
1071
1072          The helper we use here is gpg itself, which should know about
1073          the key in any case.  */
1074
1075       char fpr[41];
1076       char *hexkeyid;
1077       char *command = NULL;
1078       FILE *fp;
1079       int ret;
1080
1081       buffer = NULL; /* We don't need buffer.  */
1082
1083       err = retrieve_fpr_from_card (app, keyno, fpr);
1084       if (err)
1085         {
1086           log_error ("error while retrieving fpr from card: %s\n",
1087                      gpg_strerror (err));
1088           goto leave;
1089         }
1090       hexkeyid = fpr + 24;
1091
1092       ret = asprintf (&command,
1093                       "gpg --list-keys --with-colons --with-key-data '%s'",
1094                       fpr);
1095       if (ret < 0)
1096         {
1097           err = gpg_error_from_syserror ();
1098           goto leave;
1099         }
1100
1101       fp = popen (command, "r");
1102       free (command);
1103       if (!fp)
1104         {
1105           err = gpg_error_from_syserror ();
1106           log_error ("running gpg failed: %s\n", gpg_strerror (err));
1107           goto leave;
1108         }
1109
1110       err = retrieve_key_material (fp, hexkeyid, &m, &mlen, &e, &elen);
1111       fclose (fp);
1112       if (err)
1113         {
1114           log_error ("error while retrieving key material through pipe: %s\n",
1115                      gpg_strerror (err));
1116           goto leave;
1117         }
1118     }
1119
1120   /* Allocate a buffer to construct the S-expression.  */
1121   /* FIXME: We should provide a generalized S-expression creation
1122      mechanism. */
1123   keybuf = xtrymalloc (50 + 2*35 + mlen + elen + 1);
1124   if (!keybuf)
1125     {
1126       err = gpg_error_from_syserror ();
1127       goto leave;
1128     }
1129   
1130   sprintf (keybuf, "(10:public-key(3:rsa(1:n%u:", (unsigned int) mlen);
1131   keybuf_p = keybuf + strlen (keybuf);
1132   memcpy (keybuf_p, m, mlen);
1133   keybuf_p += mlen;
1134   sprintf (keybuf_p, ")(1:e%u:", (unsigned int)elen);
1135   keybuf_p += strlen (keybuf_p);
1136   memcpy (keybuf_p, e, elen);
1137   keybuf_p += elen;
1138   strcpy (keybuf_p, ")))");
1139   keybuf_p += strlen (keybuf_p);
1140   
1141   app->app_local->pk[keyno].key = (unsigned char*)keybuf;
1142   app->app_local->pk[keyno].keylen = (keybuf_p - keybuf);
1143
1144  leave:
1145   /* Set a flag to indicate that we tried to read the key.  */
1146   app->app_local->pk[keyno].read_done = 1;
1147
1148   xfree (buffer);
1149   xfree (mbuf);
1150   xfree (ebuf);
1151   return 0;
1152 }
1153 #endif /* GNUPG_MAJOR_VERSION > 1 */
1154
1155
1156
1157 /* Send the KEYPAIRINFO back. KEYNO needs to be in the range [1,3].
1158    This is used by the LEARN command. */
1159 static gpg_error_t
1160 send_keypair_info (app_t app, ctrl_t ctrl, int keyno)
1161 {
1162   gpg_error_t err = 0;
1163   /* Note that GnuPG 1.x does not need this and it would be too time
1164      consuming to send it just for the fun of it. */
1165 #if GNUPG_MAJOR_VERSION > 1
1166   unsigned char grip[20];
1167   char gripstr[41];
1168   char idbuf[50];
1169   int i;
1170
1171   err = get_public_key (app, keyno);
1172   if (err)
1173     goto leave;
1174   
1175   assert (keyno >= 1 && keyno <= 3);
1176   if (!app->app_local->pk[keyno-1].key)
1177     goto leave; /* No such key - ignore. */
1178
1179   err = keygrip_from_canon_sexp (app->app_local->pk[keyno-1].key,
1180                                  app->app_local->pk[keyno-1].keylen,
1181                                  grip);
1182   if (err)
1183     goto leave;
1184   
1185   for (i=0; i < 20; i++)
1186     sprintf (gripstr+i*2, "%02X", grip[i]);
1187
1188   sprintf (idbuf, "OPENPGP.%d", keyno);
1189   send_status_info (ctrl, "KEYPAIRINFO", 
1190                     gripstr, 40, 
1191                     idbuf, strlen (idbuf), 
1192                     NULL, (size_t)0);
1193
1194  leave:
1195 #endif /* GNUPG_MAJOR_VERSION > 1 */
1196
1197   return err; 
1198 }
1199
1200
1201 /* Handle the LEARN command for OpenPGP.  */
1202 static gpg_error_t
1203 do_learn_status (app_t app, ctrl_t ctrl)
1204 {
1205   do_getattr (app, ctrl, "EXTCAP");
1206   do_getattr (app, ctrl, "DISP-NAME");
1207   do_getattr (app, ctrl, "DISP-LANG");
1208   do_getattr (app, ctrl, "DISP-SEX");
1209   do_getattr (app, ctrl, "PUBKEY-URL");
1210   do_getattr (app, ctrl, "LOGIN-DATA");
1211   do_getattr (app, ctrl, "KEY-FPR");
1212   if (app->card_version > 0x0100)
1213     do_getattr (app, ctrl, "KEY-TIME");
1214   do_getattr (app, ctrl, "CA-FPR");
1215   do_getattr (app, ctrl, "CHV-STATUS");
1216   do_getattr (app, ctrl, "SIG-COUNTER");
1217   if (app->app_local->extcap.private_dos)
1218     {
1219       do_getattr (app, ctrl, "PRIVATE-DO-1");
1220       do_getattr (app, ctrl, "PRIVATE-DO-2");
1221       if (app->did_chv2)
1222         do_getattr (app, ctrl, "PRIVATE-DO-3");
1223       if (app->did_chv3)
1224         do_getattr (app, ctrl, "PRIVATE-DO-4");
1225     }
1226   send_keypair_info (app, ctrl, 1);
1227   send_keypair_info (app, ctrl, 2);
1228   send_keypair_info (app, ctrl, 3);
1229   return 0;
1230 }
1231
1232
1233 /* Handle the READKEY command for OpenPGP.  On success a canonical
1234    encoded S-expression with the public key will get stored at PK and
1235    its length (for assertions) at PKLEN; the caller must release that
1236    buffer. On error PK and PKLEN are not changed and an error code is
1237    returned.  */
1238 static gpg_error_t
1239 do_readkey (app_t app, const char *keyid, unsigned char **pk, size_t *pklen)
1240 {
1241 #if GNUPG_MAJOR_VERSION > 1
1242   gpg_error_t err;
1243   int keyno;
1244   unsigned char *buf;
1245
1246   if (!strcmp (keyid, "OPENPGP.1"))
1247     keyno = 1;
1248   else if (!strcmp (keyid, "OPENPGP.2"))
1249     keyno = 2;
1250   else if (!strcmp (keyid, "OPENPGP.3"))
1251     keyno = 3;
1252   else
1253     return gpg_error (GPG_ERR_INV_ID);
1254
1255   err = get_public_key (app, keyno);
1256   if (err)
1257     return err;
1258
1259   buf = app->app_local->pk[keyno-1].key;
1260   if (!buf)
1261     return gpg_error (GPG_ERR_NO_PUBKEY);
1262   *pklen = app->app_local->pk[keyno-1].keylen;;
1263   *pk = xtrymalloc (*pklen);
1264   if (!*pk)
1265     {
1266       err = gpg_error_from_syserror ();
1267       *pklen = 0;
1268       return err;
1269     }
1270   memcpy (*pk, buf, *pklen);
1271   return 0;
1272 #else
1273   return gpg_error (GPG_ERR_NOT_IMPLEMENTED);
1274 #endif
1275 }
1276
1277
1278 /* Verify a CHV either using using the pinentry or if possibile by
1279    using a keypad.  PINCB and PINCB_ARG describe the usual callback
1280    for the pinentry.  CHVNO must be either 1 or 2. SIGCOUNT is only
1281    used with CHV1.  PINVALUE is the address of a pointer which will
1282    receive a newly allocated block with the actual PIN (this is useful
1283    in case that PIN shall be used for another verifiy operation).  The
1284    caller needs to free this value.  If the function returns with
1285    success and NULL is stored at PINVALUE, the caller should take this
1286    as an indication that the keypad has been used.
1287    */
1288 static gpg_error_t
1289 verify_a_chv (app_t app,
1290               gpg_error_t (*pincb)(void*, const char *, char **),
1291               void *pincb_arg,
1292               int chvno, unsigned long sigcount, char **pinvalue)
1293 {
1294   int rc = 0;
1295   char *prompt;
1296   iso7816_pininfo_t pininfo;
1297   int minlen = 6;
1298
1299   assert (chvno == 1 || chvno == 2);
1300
1301   *pinvalue = NULL;
1302
1303   memset (&pininfo, 0, sizeof pininfo);
1304   pininfo.mode = 1;
1305   pininfo.minlen = minlen;
1306   
1307   if (!opt.disable_keypad
1308       && !iso7816_check_keypad (app->slot, ISO7816_VERIFY, &pininfo) )
1309     {
1310       /* The reader supports the verify command through the keypad. */
1311
1312       if (chvno == 1)
1313         {
1314 #define PROMPTSTRING  _("||Please enter your PIN at the reader's keypad%%0A" \
1315                         "[sigs done: %lu]")
1316           size_t promptsize = strlen (PROMPTSTRING) + 50;
1317
1318           prompt = xmalloc (promptsize);
1319           if (!prompt)
1320             return gpg_error_from_syserror ();
1321           snprintf (prompt, promptsize-1, PROMPTSTRING, sigcount);
1322           rc = pincb (pincb_arg, prompt, NULL); 
1323           xfree (prompt);
1324 #undef PROMPTSTRING
1325         }
1326       else
1327         rc = pincb (pincb_arg,
1328                     _("||Please enter your PIN at the reader's keypad"),
1329                     NULL);
1330       if (rc)
1331         {
1332           log_info (_("PIN callback returned error: %s\n"),
1333                     gpg_strerror (rc));
1334           return rc;
1335         }
1336       rc = iso7816_verify_kp (app->slot, 0x80+chvno, "", 0, &pininfo); 
1337       /* Dismiss the prompt. */
1338       pincb (pincb_arg, NULL, NULL);
1339
1340       assert (!*pinvalue);
1341     }
1342   else
1343     {
1344       /* The reader has no keypad or we don't want to use it. */
1345
1346       if (chvno == 1)
1347         {
1348 #define PROMPTSTRING  _("||Please enter the PIN%%0A[sigs done: %lu]")
1349           size_t promptsize = strlen (PROMPTSTRING) + 50;
1350
1351           prompt = xmalloc (promptsize);
1352           if (!prompt)
1353             return gpg_error_from_syserror ();
1354           snprintf (prompt, promptsize-1, PROMPTSTRING, sigcount);
1355           rc = pincb (pincb_arg, prompt, pinvalue); 
1356           xfree (prompt);
1357 #undef PROMPTSTRING
1358         }
1359       else
1360         rc = pincb (pincb_arg, "PIN", pinvalue); 
1361
1362       if (rc)
1363         {
1364           log_info (_("PIN callback returned error: %s\n"),
1365                     gpg_strerror (rc));
1366           return rc;
1367         }
1368       
1369       if (strlen (*pinvalue) < minlen)
1370         {
1371           log_error (_("PIN for CHV%d is too short;"
1372                        " minimum length is %d\n"), chvno, minlen);
1373           xfree (*pinvalue);
1374           *pinvalue = NULL;
1375           return gpg_error (GPG_ERR_BAD_PIN);
1376         }
1377
1378       rc = iso7816_verify (app->slot, 0x80+chvno,
1379                            *pinvalue, strlen (*pinvalue));
1380     }
1381   
1382   if (rc)
1383     {
1384       log_error (_("verify CHV%d failed: %s\n"), chvno, gpg_strerror (rc));
1385       xfree (*pinvalue);
1386       *pinvalue = NULL;
1387       flush_cache_after_error (app);
1388     }
1389
1390   return rc;
1391 }
1392
1393
1394 /* Verify CHV2 if required.  Depending on the configuration of the
1395    card CHV1 will also be verified. */
1396 static gpg_error_t
1397 verify_chv2 (app_t app,
1398              gpg_error_t (*pincb)(void*, const char *, char **),
1399              void *pincb_arg)
1400 {
1401   int rc;
1402   char *pinvalue;
1403
1404   if (app->did_chv2) 
1405     return 0;  /* We already verified CHV2.  */
1406
1407   rc = verify_a_chv (app, pincb, pincb_arg, 2, 0, &pinvalue);
1408   if (rc)
1409     return rc;
1410
1411   app->did_chv2 = 1;
1412   
1413   if (!app->did_chv1 && !app->force_chv1 && pinvalue)
1414     {
1415       /* For convenience we verify CHV1 here too.  We do this only if
1416          the card is not configured to require a verification before
1417          each CHV1 controlled operation (force_chv1) and if we are not
1418          using the keypad (PINVALUE == NULL). */
1419       rc = iso7816_verify (app->slot, 0x81, pinvalue, strlen (pinvalue));
1420       if (gpg_err_code (rc) == GPG_ERR_BAD_PIN)
1421         rc = gpg_error (GPG_ERR_PIN_NOT_SYNCED);
1422       if (rc)
1423         {
1424           log_error (_("verify CHV%d failed: %s\n"), 1, gpg_strerror (rc));
1425           flush_cache_after_error (app);
1426         }
1427       else
1428         app->did_chv1 = 1;
1429     }
1430   xfree (pinvalue);
1431
1432   return rc;
1433 }
1434
1435
1436 /* Verify CHV3 if required. */
1437 static gpg_error_t
1438 verify_chv3 (app_t app,
1439              gpg_error_t (*pincb)(void*, const char *, char **),
1440              void *pincb_arg)
1441 {
1442   int rc = 0;
1443
1444 #if GNUPG_MAJOR_VERSION != 1
1445   if (!opt.allow_admin)
1446     {
1447       log_info (_("access to admin commands is not configured\n"));
1448       return gpg_error (GPG_ERR_EACCES);
1449     }
1450 #endif
1451       
1452   if (!app->did_chv3) 
1453     {
1454       void *relptr;
1455       unsigned char *value;
1456       size_t valuelen;
1457       iso7816_pininfo_t pininfo;
1458       int minlen = 8;
1459       int remaining;
1460
1461       memset (&pininfo, 0, sizeof pininfo);
1462       pininfo.mode = 1;
1463       pininfo.minlen = minlen;
1464
1465       relptr = get_one_do (app, 0x00C4, &value, &valuelen, NULL);
1466       if (!relptr || valuelen < 7)
1467         {
1468           log_error (_("error retrieving CHV status from card\n"));
1469           xfree (relptr);
1470           return gpg_error (GPG_ERR_CARD);
1471         }
1472       if (value[6] == 0)
1473         {
1474           log_info (_("card is permanently locked!\n"));
1475           xfree (relptr);
1476           return gpg_error (GPG_ERR_BAD_PIN);
1477         }
1478       remaining = value[6];
1479       xfree (relptr);
1480
1481       log_info(_("%d Admin PIN attempts remaining before card"
1482                  " is permanently locked\n"), remaining);
1483
1484       if (!opt.disable_keypad
1485           && !iso7816_check_keypad (app->slot, ISO7816_VERIFY, &pininfo) )
1486         {
1487           /* The reader supports the verify command through the keypad. */
1488           
1489           if (remaining < 3)
1490             {
1491 #define PROMPTSTRING  _("|A|Please enter the Admin PIN" \
1492                         " at the reader's keypad%%0A"   \
1493                         "[remaining attempts: %d]")
1494               size_t promptsize = strlen (PROMPTSTRING) + 50;
1495               char *prompt;
1496               
1497               prompt = xmalloc (promptsize);
1498               if (!prompt)
1499                 return gpg_error_from_syserror ();
1500               snprintf (prompt, promptsize-1, PROMPTSTRING, remaining);
1501               rc = pincb (pincb_arg, prompt, NULL); 
1502               xfree (prompt);
1503 #undef PROMPTSTRING
1504             }
1505           else
1506             rc = pincb (pincb_arg, _("|A|Please enter the Admin PIN"
1507                                      " at the reader's keypad"),   NULL);
1508
1509           if (rc)
1510             {
1511               log_info (_("PIN callback returned error: %s\n"),
1512                         gpg_strerror (rc));
1513               return rc;
1514             }
1515           rc = iso7816_verify_kp (app->slot, 0x83, "", 0, &pininfo); 
1516           /* Dismiss the prompt. */
1517           pincb (pincb_arg, NULL, NULL);
1518         }
1519       else
1520         {
1521           char *pinvalue;
1522
1523           /* TRANSLATORS: Do not translate the "|A|" prefix but keep
1524              it at the start of the string.  We need this elsewhere to
1525              get some infos on the string. */
1526           rc = pincb (pincb_arg, _("|A|Admin PIN"), &pinvalue); 
1527           if (rc)
1528             {
1529               log_info (_("PIN callback returned error: %s\n"),
1530                         gpg_strerror (rc));
1531               return rc;
1532             }
1533           
1534           if (strlen (pinvalue) < minlen)
1535             {
1536               log_error (_("PIN for CHV%d is too short;"
1537                            " minimum length is %d\n"), 3, minlen);
1538               xfree (pinvalue);
1539               return gpg_error (GPG_ERR_BAD_PIN);
1540             }
1541           
1542           rc = iso7816_verify (app->slot, 0x83, pinvalue, strlen (pinvalue));
1543           xfree (pinvalue);
1544         }
1545       
1546       if (rc)
1547         {
1548           log_error (_("verify CHV%d failed: %s\n"), 3, gpg_strerror (rc));
1549           flush_cache_after_error (app);
1550           return rc;
1551         }
1552     }
1553   return rc;
1554 }
1555
1556
1557 /* Handle the SETATTR operation. All arguments are already basically
1558    checked. */
1559 static gpg_error_t 
1560 do_setattr (app_t app, const char *name,
1561             gpg_error_t (*pincb)(void*, const char *, char **),
1562             void *pincb_arg,
1563             const unsigned char *value, size_t valuelen)
1564 {
1565   gpg_error_t rc;
1566   int idx;
1567   static struct {
1568     const char *name;
1569     int tag;
1570     int need_chv;
1571     int special;
1572   } table[] = {
1573     { "DISP-NAME",    0x005B, 3 },
1574     { "LOGIN-DATA",   0x005E, 3, 2 },
1575     { "DISP-LANG",    0x5F2D, 3 },
1576     { "DISP-SEX",     0x5F35, 3 },
1577     { "PUBKEY-URL",   0x5F50, 3 },
1578     { "CHV-STATUS-1", 0x00C4, 3, 1 },
1579     { "CA-FPR-1",     0x00CA, 3 },
1580     { "CA-FPR-2",     0x00CB, 3 },
1581     { "CA-FPR-3",     0x00CC, 3 },
1582     { "PRIVATE-DO-1", 0x0101, 2 },
1583     { "PRIVATE-DO-2", 0x0102, 3 },
1584     { "PRIVATE-DO-3", 0x0103, 2 },
1585     { "PRIVATE-DO-4", 0x0104, 3 },
1586     { NULL, 0 }
1587   };
1588
1589
1590   for (idx=0; table[idx].name && strcmp (table[idx].name, name); idx++)
1591     ;
1592   if (!table[idx].name)
1593     return gpg_error (GPG_ERR_INV_NAME); 
1594
1595   switch (table[idx].need_chv)
1596     {
1597     case 2:
1598       rc = verify_chv2 (app, pincb, pincb_arg);
1599       break;
1600     case 3:
1601       rc = verify_chv3 (app, pincb, pincb_arg);
1602       break;
1603     default:
1604       rc = 0;
1605     }
1606   if (rc)
1607     return rc;
1608
1609   /* Flush the cache before writing it, so that the next get operation
1610      will reread the data from the card and thus get synced in case of
1611      errors (e.g. data truncated by the card). */
1612   flush_cache_item (app, table[idx].tag);
1613   rc = iso7816_put_data (app->slot, table[idx].tag, value, valuelen);
1614   if (rc)
1615     log_error ("failed to set `%s': %s\n", table[idx].name, gpg_strerror (rc));
1616
1617   if (table[idx].special == 1)
1618     app->force_chv1 = (valuelen && *value == 0);
1619   else if (table[idx].special == 2)
1620     parse_login_data (app);
1621
1622   return rc;
1623 }
1624
1625
1626 /* Handle the PASSWD command. */
1627 static gpg_error_t 
1628 do_change_pin (app_t app, ctrl_t ctrl,  const char *chvnostr, int reset_mode,
1629                gpg_error_t (*pincb)(void*, const char *, char **),
1630                void *pincb_arg)
1631 {
1632   int rc = 0;
1633   int chvno = atoi (chvnostr);
1634   char *pinvalue;
1635
1636   if (reset_mode && chvno == 3)
1637     {
1638       rc = gpg_error (GPG_ERR_INV_ID);
1639       goto leave;
1640     }
1641   else if (reset_mode || chvno == 3)
1642     {
1643       /* we always require that the PIN is entered. */
1644       app->did_chv3 = 0;
1645       rc = verify_chv3 (app, pincb, pincb_arg);
1646       if (rc)
1647         goto leave;
1648     }
1649   else if (chvno == 1 || chvno == 2)
1650     {
1651       /* CHV1 and CVH2 should always have the same value, thus we
1652          enforce it here.  */
1653       int save_force = app->force_chv1;
1654
1655       app->force_chv1 = 0;
1656       app->did_chv1 = 0;
1657       app->did_chv2 = 0;
1658       rc = verify_chv2 (app, pincb, pincb_arg);
1659       app->force_chv1 = save_force;
1660       if (rc)
1661         goto leave;
1662     }
1663   else
1664     {
1665       rc = gpg_error (GPG_ERR_INV_ID);
1666       goto leave;
1667     }
1668
1669   if (chvno == 3)
1670     app->did_chv3 = 0;
1671   else
1672     app->did_chv1 = app->did_chv2 = 0;
1673
1674   /* TRANSLATORS: Do not translate the "|*|" prefixes but
1675      keep it at the start of the string.  We need this elsewhere
1676      to get some infos on the string. */
1677   rc = pincb (pincb_arg, chvno == 3? _("|AN|New Admin PIN") : _("|N|New PIN"), 
1678               &pinvalue); 
1679   if (rc)
1680     {
1681       log_error (_("error getting new PIN: %s\n"), gpg_strerror (rc));
1682       goto leave;
1683     }
1684
1685   if (reset_mode)
1686     {
1687       rc = iso7816_reset_retry_counter (app->slot, 0x81,
1688                                         pinvalue, strlen (pinvalue));
1689       if (!rc)
1690         rc = iso7816_reset_retry_counter (app->slot, 0x82,
1691                                           pinvalue, strlen (pinvalue));
1692     }
1693   else
1694     {
1695       if (chvno == 1 || chvno == 2)
1696         {
1697           rc = iso7816_change_reference_data (app->slot, 0x81, NULL, 0,
1698                                               pinvalue, strlen (pinvalue));
1699           if (!rc)
1700             rc = iso7816_change_reference_data (app->slot, 0x82, NULL, 0,
1701                                                 pinvalue, strlen (pinvalue));
1702         }
1703       else
1704         rc = iso7816_change_reference_data (app->slot, 0x80 + chvno, NULL, 0,
1705                                             pinvalue, strlen (pinvalue));
1706     }
1707   xfree (pinvalue);
1708   if (rc)
1709     flush_cache_after_error (app);
1710
1711  leave:
1712   return rc;
1713 }
1714
1715
1716 /* Check whether a key already exists.  KEYIDX is the index of the key
1717    (0..2).  If FORCE is TRUE a diagnositic will be printed but no
1718    error returned if the key already exists. */
1719 static gpg_error_t
1720 does_key_exist (app_t app, int keyidx, int force)
1721 {
1722   const unsigned char *fpr;
1723   unsigned char *buffer;
1724   size_t buflen, n;
1725   int i;
1726
1727   assert (keyidx >=0 && keyidx <= 2);
1728
1729   if (iso7816_get_data (app->slot, 0x006E, &buffer, &buflen))
1730     {
1731       log_error (_("error reading application data\n"));
1732       return gpg_error (GPG_ERR_GENERAL);
1733     }
1734   fpr = find_tlv (buffer, buflen, 0x00C5, &n);
1735   if (!fpr || n < 60)
1736     {
1737       log_error (_("error reading fingerprint DO\n"));
1738       xfree (buffer);
1739       return gpg_error (GPG_ERR_GENERAL);
1740     }
1741   fpr += 20*keyidx;
1742   for (i=0; i < 20 && !fpr[i]; i++)
1743     ;
1744   xfree (buffer);
1745   if (i!=20 && !force)
1746     {
1747       log_error (_("key already exists\n"));
1748       return gpg_error (GPG_ERR_EEXIST);
1749     }
1750   else if (i!=20)
1751     log_info (_("existing key will be replaced\n"));
1752   else
1753     log_info (_("generating new key\n"));
1754   return 0;
1755 }
1756
1757
1758
1759 /* Handle the WRITEKEY command for OpenPGP.  This function expects a
1760    canonical encoded S-expression with the secret key in KEYDATA and
1761    its length (for assertions) in KEYDATALEN.  KEYID needs to be the
1762    usual keyid which for OpenPGP is the string "OPENPGP.n" with
1763    n=1,2,3.  Bit 0 of FLAGS indicates whether an existing key shall
1764    get overwritten.  PINCB and PINCB_ARG are the usual arguments for
1765    the pinentry callback.  */
1766 static gpg_error_t
1767 do_writekey (app_t app, ctrl_t ctrl,
1768              const char *keyid, unsigned int flags,
1769              gpg_error_t (*pincb)(void*, const char *, char **),
1770              void *pincb_arg,
1771              const unsigned char *keydata, size_t keydatalen)
1772 {
1773   gpg_error_t err;
1774   int force = (flags & 1);
1775   int keyno;
1776   const unsigned char *buf, *tok;
1777   size_t buflen, toklen;
1778   int depth, last_depth1, last_depth2;
1779   const unsigned char *rsa_n = NULL;
1780   const unsigned char *rsa_e = NULL;
1781   const unsigned char *rsa_p = NULL;
1782   const unsigned char *rsa_q = NULL;
1783   size_t rsa_n_len, rsa_e_len, rsa_p_len, rsa_q_len;
1784   unsigned int nbits;
1785   unsigned char *template = NULL;
1786   unsigned char *tp;
1787   size_t template_len;
1788   unsigned char fprbuf[20];
1789   u32 created_at = 0;
1790
1791   if (!strcmp (keyid, "OPENPGP.1"))
1792     keyno = 0;
1793   else if (!strcmp (keyid, "OPENPGP.2"))
1794     keyno = 1;
1795   else if (!strcmp (keyid, "OPENPGP.3"))
1796     keyno = 2;
1797   else
1798     return gpg_error (GPG_ERR_INV_ID);
1799   
1800   err = does_key_exist (app, keyno, force);
1801   if (err)
1802     return err;
1803
1804
1805   /* 
1806      Parse the S-expression
1807    */
1808   buf = keydata;
1809   buflen = keydatalen;
1810   depth = 0;
1811   if ((err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen)))
1812     goto leave;
1813   if ((err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen)))
1814     goto leave;
1815   if (!tok || toklen != 11 || memcmp ("private-key", tok, toklen))
1816     {
1817       if (!tok)
1818         ;
1819       else if (toklen == 21 && !memcmp ("protected-private-key", tok, toklen))
1820         log_info ("protected-private-key passed to writekey\n");
1821       else if (toklen == 20 && !memcmp ("shadowed-private-key", tok, toklen))
1822         log_info ("shadowed-private-key passed to writekey\n");
1823       err = gpg_error (GPG_ERR_BAD_SECKEY);
1824       goto leave;
1825     }
1826   if ((err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen)))
1827     goto leave;
1828   if ((err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen)))
1829     goto leave;
1830   if (!tok || toklen != 3 || memcmp ("rsa", tok, toklen))
1831     {
1832       err = gpg_error (GPG_ERR_WRONG_PUBKEY_ALGO);
1833       goto leave;
1834     }
1835   last_depth1 = depth;
1836   while (!(err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen))
1837          && depth && depth >= last_depth1)
1838     {
1839       if (tok)
1840         {
1841           err = gpg_error (GPG_ERR_UNKNOWN_SEXP);
1842           goto leave;
1843         }
1844       if ((err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen)))
1845         goto leave;
1846       if (tok && toklen == 1)
1847         {
1848           const unsigned char **mpi;
1849           size_t *mpi_len;
1850
1851           switch (*tok)
1852             {
1853             case 'n': mpi = &rsa_n; mpi_len = &rsa_n_len; break; 
1854             case 'e': mpi = &rsa_e; mpi_len = &rsa_e_len; break; 
1855             case 'p': mpi = &rsa_p; mpi_len = &rsa_p_len; break; 
1856             case 'q': mpi = &rsa_q; mpi_len = &rsa_q_len;break; 
1857             default: mpi = NULL;  mpi_len = NULL; break;
1858             }
1859           if (mpi && *mpi)
1860             {
1861               err = gpg_error (GPG_ERR_DUP_VALUE);
1862               goto leave;
1863             }
1864           if ((err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen)))
1865             goto leave;
1866           if (tok && mpi)
1867             {
1868               /* Strip off leading zero bytes and save. */
1869               for (;toklen && !*tok; toklen--, tok++)
1870                 ;
1871               *mpi = tok;
1872               *mpi_len = toklen;
1873             }
1874         }
1875       /* Skip until end of list. */
1876       last_depth2 = depth;
1877       while (!(err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen))
1878              && depth && depth >= last_depth2)
1879         ;
1880       if (err)
1881         goto leave;
1882     }
1883   /* Parse other attributes. */
1884   last_depth1 = depth;
1885   while (!(err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen))
1886          && depth && depth >= last_depth1)
1887     {
1888       if (tok)
1889         {
1890           err = gpg_error (GPG_ERR_UNKNOWN_SEXP);
1891           goto leave;
1892         }
1893       if ((err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen)))
1894         goto leave;
1895       if (tok && toklen == 10 && !memcmp ("created-at", tok, toklen))
1896         {
1897           if ((err = parse_sexp (&buf,&buflen,&depth,&tok,&toklen)))
1898             goto leave;
1899           if (tok)
1900             {
1901               for (created_at=0; toklen && *tok && *tok >= '0' && *tok <= '9';
1902                    tok++, toklen--)
1903                 created_at = created_at*10 + (*tok - '0');
1904             }
1905         }
1906       /* Skip until end of list. */
1907       last_depth2 = depth;
1908       while (!(err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen))
1909              && depth && depth >= last_depth2)
1910         ;
1911       if (err)
1912         goto leave;
1913     }
1914
1915
1916   /* Check that we have all parameters and that they match the card
1917      description. */
1918   if (!created_at)
1919     {
1920       log_error (_("creation timestamp missing\n"));
1921       err = gpg_error (GPG_ERR_INV_VALUE);
1922       goto leave;
1923     }
1924   nbits = rsa_n? count_bits (rsa_n, rsa_n_len) : 0;
1925   if (nbits != 1024)
1926     {
1927       log_error (_("RSA modulus missing or not of size %d bits\n"), 1024);
1928       err = gpg_error (GPG_ERR_BAD_SECKEY);
1929       goto leave;
1930     }
1931   nbits = rsa_e? count_bits (rsa_e, rsa_e_len) : 0;
1932   if (nbits < 2 || nbits > 32)
1933     {
1934       log_error (_("RSA public exponent missing or larger than %d bits\n"),
1935                  32);
1936       err = gpg_error (GPG_ERR_BAD_SECKEY);
1937       goto leave;
1938     }
1939   nbits = rsa_p? count_bits (rsa_p, rsa_p_len) : 0;
1940   if (nbits != 512)
1941     {
1942       log_error (_("RSA prime %s missing or not of size %d bits\n"), "P", 512);
1943       err = gpg_error (GPG_ERR_BAD_SECKEY);
1944       goto leave;
1945     }
1946   nbits = rsa_q? count_bits (rsa_q, rsa_q_len) : 0;
1947   if (nbits != 512)
1948     {
1949       log_error (_("RSA prime %s missing or not of size %d bits\n"), "Q", 512);
1950       err = gpg_error (GPG_ERR_BAD_SECKEY);
1951       goto leave;
1952     }
1953   
1954
1955   /* Build the private key template as described in section 4.3.3.6 of
1956      the OpenPGP card specs:
1957          0xC0   <length> public exponent
1958          0xC1   <length> prime p 
1959          0xC2   <length> prime q 
1960   */
1961   assert (rsa_e_len <= 4);
1962   template_len = (1 + 1 + 4
1963                   + 1 + 1 + rsa_p_len
1964                   + 1 + 1 + rsa_q_len);
1965   template = tp = xtrymalloc_secure (template_len);
1966   if (!template)
1967     {
1968       err = gpg_error_from_syserror ();
1969       goto leave;
1970     }
1971   *tp++ = 0xC0;
1972   *tp++ = 4;
1973   memcpy (tp, rsa_e, rsa_e_len);
1974   if (rsa_e_len < 4)
1975     {
1976       /* Right justify E. */
1977       memmove (tp+4-rsa_e_len, tp, rsa_e_len);
1978       memset (tp, 0, 4-rsa_e_len);
1979     }                 
1980   tp += 4;
1981
1982   *tp++ = 0xC1;
1983   *tp++ = rsa_p_len;
1984   memcpy (tp, rsa_p, rsa_p_len);
1985   tp += rsa_p_len;
1986
1987   *tp++ = 0xC2;
1988   *tp++ = rsa_q_len;
1989   memcpy (tp, rsa_q, rsa_q_len);
1990   tp += rsa_q_len;
1991
1992   assert (tp - template == template_len);
1993
1994
1995   /* Obviously we need to remove the cached public key.  */
1996   xfree (app->app_local->pk[keyno].key);
1997   app->app_local->pk[keyno].key = NULL;
1998   app->app_local->pk[keyno].keylen = 0;
1999   app->app_local->pk[keyno].read_done = 0;
2000
2001   /* Prepare for storing the key.  */
2002   err = verify_chv3 (app, pincb, pincb_arg);
2003   if (err)
2004     goto leave;
2005
2006   /* Store the key. */
2007   err = iso7816_put_data (app->slot,
2008                          (app->card_version > 0x0007? 0xE0 : 0xE9) + keyno,
2009                          template, template_len);
2010   if (err)
2011     {
2012       log_error (_("failed to store the key: %s\n"), gpg_strerror (err));
2013       goto leave;
2014     }
2015  
2016   err = store_fpr (app->slot, keyno, created_at,
2017                   rsa_n, rsa_n_len, rsa_e, rsa_e_len,
2018                   fprbuf, app->card_version);
2019   if (err)
2020     goto leave;
2021
2022
2023  leave:
2024   xfree (template);
2025   return err;
2026 }
2027
2028
2029 /* Handle the GENKEY command. */
2030 static gpg_error_t 
2031 do_genkey (app_t app, ctrl_t ctrl,  const char *keynostr, unsigned int flags,
2032            time_t createtime,
2033            gpg_error_t (*pincb)(void*, const char *, char **),
2034            void *pincb_arg)
2035 {
2036   int rc;
2037   char numbuf[30];
2038   unsigned char fprbuf[20];
2039   const unsigned char *keydata, *m, *e;
2040   unsigned char *buffer = NULL;
2041   size_t buflen, keydatalen, mlen, elen;
2042   time_t created_at;
2043   int keyno = atoi (keynostr);
2044   int force = (flags & 1);
2045   time_t start_at;
2046
2047   if (keyno < 1 || keyno > 3)
2048     return gpg_error (GPG_ERR_INV_ID);
2049   keyno--;
2050
2051   /* We flush the cache to increase the traffic before a key
2052      generation.  This _might_ help a card to gather more entropy. */
2053   flush_cache (app);
2054
2055   /* Obviously we need to remove the cached public key.  */
2056   xfree (app->app_local->pk[keyno].key);
2057   app->app_local->pk[keyno].key = NULL;
2058   app->app_local->pk[keyno].keylen = 0;
2059   app->app_local->pk[keyno].read_done = 0;
2060
2061   /* Check whether a key already exists.  */
2062   rc = does_key_exist (app, keyno, force);
2063   if (rc)
2064     return rc;
2065
2066   /* Prepare for key generation by verifying the Admin PIN.  */
2067   rc = verify_chv3 (app, pincb, pincb_arg);
2068   if (rc)
2069     goto leave;
2070    
2071 #if 1
2072   log_info (_("please wait while key is being generated ...\n"));
2073   start_at = time (NULL);
2074   rc = iso7816_generate_keypair 
2075 #else
2076 # warning key generation temporary replaced by reading an existing key.
2077   rc = iso7816_read_public_key
2078 #endif
2079     (app->slot, (const unsigned char*)(keyno == 0? "\xB6" :
2080                                        keyno == 1? "\xB8" : "\xA4"),
2081      2,
2082      &buffer, &buflen);
2083   if (rc)
2084     {
2085       rc = gpg_error (GPG_ERR_CARD);
2086       log_error (_("generating key failed\n"));
2087       goto leave;
2088     }
2089   log_info (_("key generation completed (%d seconds)\n"),
2090             (int)(time (NULL) - start_at));
2091   keydata = find_tlv (buffer, buflen, 0x7F49, &keydatalen);
2092   if (!keydata)
2093     {
2094       rc = gpg_error (GPG_ERR_CARD);
2095       log_error (_("response does not contain the public key data\n"));
2096       goto leave;
2097     }
2098  
2099   m = find_tlv (keydata, keydatalen, 0x0081, &mlen);
2100   if (!m)
2101     {
2102       rc = gpg_error (GPG_ERR_CARD);
2103       log_error (_("response does not contain the RSA modulus\n"));
2104       goto leave;
2105     }
2106 /*    log_printhex ("RSA n:", m, mlen); */
2107   send_key_data (ctrl, "n", m, mlen);
2108
2109   e = find_tlv (keydata, keydatalen, 0x0082, &elen);
2110   if (!e)
2111     {
2112       rc = gpg_error (GPG_ERR_CARD);
2113       log_error (_("response does not contain the RSA public exponent\n"));
2114       goto leave;
2115     }
2116 /*    log_printhex ("RSA e:", e, elen); */
2117   send_key_data (ctrl, "e", e, elen);
2118
2119   created_at = createtime? createtime : gnupg_get_time ();
2120   sprintf (numbuf, "%lu", (unsigned long)created_at);
2121   send_status_info (ctrl, "KEY-CREATED-AT",
2122                     numbuf, (size_t)strlen(numbuf), NULL, 0);
2123
2124   rc = store_fpr (app->slot, keyno, (u32)created_at,
2125                   m, mlen, e, elen, fprbuf, app->card_version);
2126   if (rc)
2127     goto leave;
2128   send_fpr_if_not_null (ctrl, "KEY-FPR", -1, fprbuf);
2129
2130
2131  leave:
2132   xfree (buffer);
2133   return rc;
2134 }
2135
2136
2137 static unsigned long
2138 convert_sig_counter_value (const unsigned char *value, size_t valuelen)
2139 {
2140   unsigned long ul;
2141
2142   if (valuelen == 3 )
2143     ul = (value[0] << 16) | (value[1] << 8) | value[2];
2144   else
2145     {
2146       log_error (_("invalid structure of OpenPGP card (DO 0x93)\n"));
2147       ul = 0;
2148     }
2149   return ul;
2150 }
2151
2152 static unsigned long
2153 get_sig_counter (app_t app)
2154 {
2155   void *relptr;
2156   unsigned char *value;
2157   size_t valuelen;
2158   unsigned long ul;
2159
2160   relptr = get_one_do (app, 0x0093, &value, &valuelen, NULL);
2161   if (!relptr)
2162     return 0;
2163   ul = convert_sig_counter_value (value, valuelen);
2164   xfree (relptr);
2165   return ul;
2166 }
2167
2168 static gpg_error_t
2169 compare_fingerprint (app_t app, int keyno, unsigned char *sha1fpr)
2170 {
2171   const unsigned char *fpr;
2172   unsigned char *buffer;
2173   size_t buflen, n;
2174   int rc, i;
2175   
2176   assert (keyno >= 1 && keyno <= 3);
2177
2178   rc = get_cached_data (app, 0x006E, &buffer, &buflen, 0);
2179   if (rc)
2180     {
2181       log_error (_("error reading application data\n"));
2182       return gpg_error (GPG_ERR_GENERAL);
2183     }
2184   fpr = find_tlv (buffer, buflen, 0x00C5, &n);
2185   if (!fpr || n != 60)
2186     {
2187       xfree (buffer);
2188       log_error (_("error reading fingerprint DO\n"));
2189       return gpg_error (GPG_ERR_GENERAL);
2190     }
2191   fpr += (keyno-1)*20;
2192   for (i=0; i < 20; i++)
2193     if (sha1fpr[i] != fpr[i])
2194       {
2195         xfree (buffer);
2196         log_info (_("fingerprint on card does not match requested one\n"));
2197         return gpg_error (GPG_ERR_WRONG_SECKEY);
2198       }
2199   xfree (buffer);
2200   return 0;
2201 }
2202
2203
2204   /* If a fingerprint has been specified check it against the one on
2205      the card.  This is allows for a meaningful error message in case
2206      the key on the card has been replaced but the shadow information
2207      known to gpg was not updated.  If there is no fingerprint we
2208      assume that this is okay. */
2209 static gpg_error_t
2210 check_against_given_fingerprint (app_t app, const char *fpr, int keyno)
2211 {
2212   unsigned char tmp[20];
2213   const char *s;
2214   int n;
2215
2216   for (s=fpr, n=0; hexdigitp (s); s++, n++)
2217     ;
2218   if (n != 40)
2219     return gpg_error (GPG_ERR_INV_ID);
2220   else if (!*s)
2221     ; /* okay */
2222   else
2223     return gpg_error (GPG_ERR_INV_ID);
2224
2225   for (s=fpr, n=0; n < 20; s += 2, n++)
2226         tmp[n] = xtoi_2 (s);
2227   return compare_fingerprint (app, keyno, tmp);
2228 }
2229
2230
2231
2232 /* Compute a digital signature on INDATA which is expected to be the
2233    raw message digest. For this application the KEYIDSTR consists of
2234    the serialnumber and the fingerprint delimited by a slash.
2235
2236    Note that this function may return the error code
2237    GPG_ERR_WRONG_CARD to indicate that the card currently present does
2238    not match the one required for the requested action (e.g. the
2239    serial number does not match). 
2240    
2241    As a special feature a KEYIDSTR of "OPENPGP.3" redirects the
2242    operation to the auth command.
2243 */
2244 static gpg_error_t 
2245 do_sign (app_t app, const char *keyidstr, int hashalgo,
2246          gpg_error_t (*pincb)(void*, const char *, char **),
2247          void *pincb_arg,
2248          const void *indata, size_t indatalen,
2249          unsigned char **outdata, size_t *outdatalen )
2250 {
2251   static unsigned char sha1_prefix[15] = /* Object ID is 1.3.14.3.2.26 */
2252   { 0x30, 0x21, 0x30, 0x09, 0x06, 0x05, 0x2b, 0x0e, 0x03,
2253     0x02, 0x1a, 0x05, 0x00, 0x04, 0x14 };
2254   static unsigned char rmd160_prefix[15] = /* Object ID is 1.3.36.3.2.1 */
2255   { 0x30, 0x21, 0x30, 0x09, 0x06, 0x05, 0x2b, 0x24, 0x03,
2256     0x02, 0x01, 0x05, 0x00, 0x04, 0x14 };
2257   int rc;
2258   unsigned char data[35];
2259   unsigned char tmp_sn[20]; /* actually 16 but we use it also for the fpr. */
2260   const char *s;
2261   int n;
2262   const char *fpr = NULL;
2263   unsigned long sigcount;
2264   int use_auth = 0;
2265
2266   if (!keyidstr || !*keyidstr)
2267     return gpg_error (GPG_ERR_INV_VALUE);
2268   if (indatalen == 20)
2269     ;
2270   else if (indatalen == (15 + 20) && hashalgo == GCRY_MD_SHA1
2271            && !memcmp (indata, sha1_prefix, 15))
2272     {
2273       indata = (const char*)indata + 15;
2274       indatalen -= 15;
2275     }
2276   else if (indatalen == (15 + 20) && hashalgo == GCRY_MD_RMD160
2277            && !memcmp (indata, rmd160_prefix, 15))
2278     {
2279       indata = (const char*)indata + 15;
2280       indatalen -= 15;
2281     }
2282   else
2283     {
2284       log_error (_("card does not support digest algorithm %s\n"),
2285                  gcry_md_algo_name (hashalgo));
2286       return gpg_error (GPG_ERR_INV_VALUE);
2287     }
2288
2289   /* Check whether an OpenPGP card of any version has been requested. */
2290   if (!strcmp (keyidstr, "OPENPGP.1"))
2291     ;
2292   else if (!strcmp (keyidstr, "OPENPGP.3"))
2293     use_auth = 1;
2294   else if (strlen (keyidstr) < 32 || strncmp (keyidstr, "D27600012401", 12))
2295     return gpg_error (GPG_ERR_INV_ID);
2296   else
2297     {
2298       for (s=keyidstr, n=0; hexdigitp (s); s++, n++)
2299         ;
2300       if (n != 32)
2301         return gpg_error (GPG_ERR_INV_ID);
2302       else if (!*s)
2303         ; /* no fingerprint given: we allow this for now. */
2304       else if (*s == '/')
2305         fpr = s + 1; 
2306       else
2307         return gpg_error (GPG_ERR_INV_ID);
2308
2309       for (s=keyidstr, n=0; n < 16; s += 2, n++)
2310         tmp_sn[n] = xtoi_2 (s);
2311
2312       if (app->serialnolen != 16)
2313         return gpg_error (GPG_ERR_INV_CARD);
2314       if (memcmp (app->serialno, tmp_sn, 16))
2315         return gpg_error (GPG_ERR_WRONG_CARD);
2316     }
2317
2318   /* If a fingerprint has been specified check it against the one on
2319      the card.  This is allows for a meaningful error message in case
2320      the key on the card has been replaced but the shadow information
2321      known to gpg was not updated.  If there is no fingerprint, gpg
2322      will detect a bogus signature anyway due to the
2323      verify-after-signing feature. */
2324   rc = fpr? check_against_given_fingerprint (app, fpr, 1) : 0;
2325   if (rc)
2326     return rc;
2327
2328   if (hashalgo == GCRY_MD_SHA1)
2329     memcpy (data, sha1_prefix, 15);
2330   else if (hashalgo == GCRY_MD_RMD160)
2331     memcpy (data, rmd160_prefix, 15);
2332   else 
2333     return gpg_error (GPG_ERR_UNSUPPORTED_ALGORITHM);
2334   memcpy (data+15, indata, indatalen);
2335
2336   if (use_auth)
2337     {
2338       /* This is a hack to redirect to the internal authenticate command.  */
2339       return do_auth (app, "OPENPGP.3", pincb, pincb_arg,
2340                       data, 35,
2341                       outdata, outdatalen);
2342     }
2343
2344   sigcount = get_sig_counter (app);
2345   log_info (_("signatures created so far: %lu\n"), sigcount);
2346
2347   if (!app->did_chv1 || app->force_chv1 ) 
2348     {
2349       char *pinvalue;
2350
2351       rc = verify_a_chv (app, pincb, pincb_arg, 1, sigcount, &pinvalue);
2352       if (rc)
2353         return rc;
2354
2355       app->did_chv1 = 1;
2356
2357       if (!app->did_chv2 && pinvalue)
2358         {
2359           /* We should also verify CHV2.  Note, that we can't do that
2360              if the keypad has been used. */
2361           rc = iso7816_verify (app->slot, 0x82, pinvalue, strlen (pinvalue));
2362           if (gpg_err_code (rc) == GPG_ERR_BAD_PIN)
2363             rc = gpg_error (GPG_ERR_PIN_NOT_SYNCED);
2364           if (rc)
2365             {
2366               log_error (_("verify CHV%d failed: %s\n"), 2, gpg_strerror (rc));
2367               xfree (pinvalue);
2368               flush_cache_after_error (app);
2369               return rc;
2370             }
2371           app->did_chv2 = 1;
2372         }
2373       xfree (pinvalue);
2374     }
2375
2376   rc = iso7816_compute_ds (app->slot, data, 35, outdata, outdatalen);
2377   return rc;
2378 }
2379
2380 /* Compute a digital signature using the INTERNAL AUTHENTICATE command
2381    on INDATA which is expected to be the raw message digest. For this
2382    application the KEYIDSTR consists of the serialnumber and the
2383    fingerprint delimited by a slash.  Optionally the id OPENPGP.3 may
2384    be given.
2385
2386    Note that this function may return the error code
2387    GPG_ERR_WRONG_CARD to indicate that the card currently present does
2388    not match the one required for the requested action (e.g. the
2389    serial number does not match). */
2390 static gpg_error_t 
2391 do_auth (app_t app, const char *keyidstr,
2392          gpg_error_t (*pincb)(void*, const char *, char **),
2393          void *pincb_arg,
2394          const void *indata, size_t indatalen,
2395          unsigned char **outdata, size_t *outdatalen )
2396 {
2397   int rc;
2398   unsigned char tmp_sn[20]; /* actually 16 but we use it also for the fpr. */
2399   const char *s;
2400   int n;
2401   const char *fpr = NULL;
2402
2403   if (!keyidstr || !*keyidstr)
2404     return gpg_error (GPG_ERR_INV_VALUE);
2405   if (indatalen > 50) /* For a 1024 bit key. */
2406     return gpg_error (GPG_ERR_INV_VALUE);
2407
2408   /* Check whether an OpenPGP card of any version has been requested. */
2409   if (!strcmp (keyidstr, "OPENPGP.3"))
2410     ;
2411   else if (strlen (keyidstr) < 32 || strncmp (keyidstr, "D27600012401", 12))
2412     return gpg_error (GPG_ERR_INV_ID);
2413   else
2414     {
2415       for (s=keyidstr, n=0; hexdigitp (s); s++, n++)
2416         ;
2417       if (n != 32)
2418         return gpg_error (GPG_ERR_INV_ID);
2419       else if (!*s)
2420         ; /* no fingerprint given: we allow this for now. */
2421       else if (*s == '/')
2422         fpr = s + 1; 
2423       else
2424         return gpg_error (GPG_ERR_INV_ID);
2425
2426       for (s=keyidstr, n=0; n < 16; s += 2, n++)
2427         tmp_sn[n] = xtoi_2 (s);
2428       
2429       if (app->serialnolen != 16)
2430         return gpg_error (GPG_ERR_INV_CARD);
2431       if (memcmp (app->serialno, tmp_sn, 16))
2432         return gpg_error (GPG_ERR_WRONG_CARD);
2433     }
2434
2435   /* If a fingerprint has been specified check it against the one on
2436      the card.  This is allows for a meaningful error message in case
2437      the key on the card has been replaced but the shadow information
2438      known to gpg was not updated.  If there is no fingerprint, gpg
2439      will detect a bogus signature anyway due to the
2440      verify-after-signing feature. */
2441   rc = fpr? check_against_given_fingerprint (app, fpr, 3) : 0;
2442   if (rc)
2443     return rc;
2444
2445   rc = verify_chv2 (app, pincb, pincb_arg);
2446   if (!rc)
2447     rc = iso7816_internal_authenticate (app->slot, indata, indatalen,
2448                                         outdata, outdatalen);
2449   return rc;
2450 }
2451
2452
2453 static gpg_error_t 
2454 do_decipher (app_t app, const char *keyidstr,
2455              gpg_error_t (*pincb)(void*, const char *, char **),
2456              void *pincb_arg,
2457              const void *indata, size_t indatalen,
2458              unsigned char **outdata, size_t *outdatalen )
2459 {
2460   int rc;
2461   unsigned char tmp_sn[20]; /* actually 16 but we use it also for the fpr. */
2462   const char *s;
2463   int n;
2464   const char *fpr = NULL;
2465
2466   if (!keyidstr || !*keyidstr || !indatalen)
2467     return gpg_error (GPG_ERR_INV_VALUE);
2468
2469   /* Check whether an OpenPGP card of any version has been requested. */
2470   if (!strcmp (keyidstr, "OPENPGP.2"))
2471     ;
2472   else if (strlen (keyidstr) < 32 || strncmp (keyidstr, "D27600012401", 12))
2473     return gpg_error (GPG_ERR_INV_ID);
2474   else
2475     {
2476       for (s=keyidstr, n=0; hexdigitp (s); s++, n++)
2477         ;
2478       if (n != 32)
2479         return gpg_error (GPG_ERR_INV_ID);
2480       else if (!*s)
2481         ; /* no fingerprint given: we allow this for now. */
2482       else if (*s == '/')
2483         fpr = s + 1; 
2484       else
2485         return gpg_error (GPG_ERR_INV_ID);
2486       
2487       for (s=keyidstr, n=0; n < 16; s += 2, n++)
2488         tmp_sn[n] = xtoi_2 (s);
2489       
2490       if (app->serialnolen != 16)
2491         return gpg_error (GPG_ERR_INV_CARD);
2492       if (memcmp (app->serialno, tmp_sn, 16))
2493         return gpg_error (GPG_ERR_WRONG_CARD);
2494     }
2495
2496   /* If a fingerprint has been specified check it against the one on
2497      the card.  This is allows for a meaningful error message in case
2498      the key on the card has been replaced but the shadow information
2499      known to gpg was not updated.  If there is no fingerprint, the
2500      decryption will won't produce the right plaintext anyway. */
2501   rc = fpr? check_against_given_fingerprint (app, fpr, 2) : 0;
2502   if (rc)
2503     return rc;
2504
2505   rc = verify_chv2 (app, pincb, pincb_arg);
2506   if (!rc)
2507     {
2508       size_t fixuplen;
2509
2510       /* We might encounter a couple of leading zeroes in the
2511          cryptogram.  Due to internal use of MPIs thease leading
2512          zeroes are stripped.  However the OpenPGP card expects
2513          exactly 128 bytes for the cryptogram (for a 1k key).  Thus we
2514          need to fix it up.  We do this for up to 16 leading zero
2515          bytes; a cryptogram with more than this is with a very high
2516          probability anyway broken.  */
2517       if (indatalen >= (128-16) && indatalen < 128)      /* 1024 bit key.  */
2518         fixuplen = 128 - indatalen;
2519       else if (indatalen >= (256-16) && indatalen < 256) /* 2048 bit key.  */
2520         fixuplen = 256 - indatalen;
2521       else if (indatalen >= (192-16) && indatalen < 192) /* 1536 bit key.  */
2522         fixuplen = 192 - indatalen;
2523       else
2524         fixuplen = 0;
2525       if (fixuplen)
2526         {
2527           unsigned char *fixbuf;
2528
2529           /* While we have to prepend stuff anyway, we can also
2530              include the padding byte here so that iso1816_decipher
2531              does not need to do yet another data mangling.  */
2532           fixuplen++;
2533           fixbuf = xtrymalloc (fixuplen + indatalen);
2534           if (!fixbuf)
2535             rc = gpg_error_from_syserror ();
2536           else
2537             {
2538               memset (fixbuf, 0, fixuplen);
2539               memcpy (fixbuf+fixuplen, indata, indatalen);
2540               rc = iso7816_decipher (app->slot, fixbuf, fixuplen+indatalen, -1,
2541                                      outdata, outdatalen);
2542               xfree (fixbuf);
2543             }
2544
2545         }
2546       else
2547         rc = iso7816_decipher (app->slot, indata, indatalen, 0,
2548                                outdata, outdatalen);
2549     }
2550   return rc;
2551 }
2552
2553
2554 /* Perform a simple verify operation for CHV1 and CHV2, so that
2555    further operations won't ask for CHV2 and it is possible to do a
2556    cheap check on the PIN: If there is something wrong with the PIN
2557    entry system, only the regular CHV will get blocked and not the
2558    dangerous CHV3.  KEYIDSTR is the usual card's serial number; an
2559    optional fingerprint part will be ignored.
2560
2561    There is a special mode if the keyidstr is "<serialno>[CHV3]" with
2562    the "[CHV3]" being a literal string:  The Admin Pin is checked if
2563    and only if the retry counter is still at 3. */
2564 static gpg_error_t 
2565 do_check_pin (app_t app, const char *keyidstr,
2566               gpg_error_t (*pincb)(void*, const char *, char **),
2567               void *pincb_arg)
2568 {
2569   unsigned char tmp_sn[20]; 
2570   const char *s;
2571   int n;
2572   int admin_pin = 0;
2573
2574   if (!keyidstr || !*keyidstr)
2575     return gpg_error (GPG_ERR_INV_VALUE);
2576
2577   /* Check whether an OpenPGP card of any version has been requested. */
2578   if (strlen (keyidstr) < 32 || strncmp (keyidstr, "D27600012401", 12))
2579     return gpg_error (GPG_ERR_INV_ID);
2580   
2581   for (s=keyidstr, n=0; hexdigitp (s); s++, n++)
2582     ;
2583   if (n != 32)
2584     return gpg_error (GPG_ERR_INV_ID);
2585   else if (!*s)
2586     ; /* No fingerprint given: we allow this for now. */
2587   else if (*s == '/')
2588     ; /* We ignore a fingerprint. */
2589   else if (!strcmp (s, "[CHV3]") )
2590     admin_pin = 1;
2591   else
2592     return gpg_error (GPG_ERR_INV_ID);
2593
2594   for (s=keyidstr, n=0; n < 16; s += 2, n++)
2595     tmp_sn[n] = xtoi_2 (s);
2596
2597   if (app->serialnolen != 16)
2598     return gpg_error (GPG_ERR_INV_CARD);
2599   if (memcmp (app->serialno, tmp_sn, 16))
2600     return gpg_error (GPG_ERR_WRONG_CARD);
2601
2602   /* Yes, there is a race conditions: The user might pull the card
2603      right here and we won't notice that.  However this is not a
2604      problem and the check above is merely for a graceful failure
2605      between operations. */
2606
2607   if (admin_pin)
2608     {
2609       void *relptr;
2610       unsigned char *value;
2611       size_t valuelen;
2612       int count;
2613       
2614       relptr = get_one_do (app, 0x00C4, &value, &valuelen, NULL);
2615       if (!relptr || valuelen < 7)
2616         {
2617           log_error (_("error retrieving CHV status from card\n"));
2618           xfree (relptr);
2619           return gpg_error (GPG_ERR_CARD);
2620         }
2621       count = value[6];
2622       xfree (relptr);
2623
2624       if (!count)
2625         {
2626           log_info (_("card is permanently locked!\n"));
2627           return gpg_error (GPG_ERR_BAD_PIN);
2628         }
2629       else if (value[6] < 3)
2630         {
2631           log_info (_("verification of Admin PIN is currently prohibited "
2632                       "through this command\n"));
2633           return gpg_error (GPG_ERR_GENERAL);
2634         }
2635
2636       app->did_chv3 = 0; /* Force verification.  */
2637       return verify_chv3 (app, pincb, pincb_arg);
2638     }
2639   else
2640     return verify_chv2 (app, pincb, pincb_arg);
2641 }
2642
2643
2644
2645
2646 /* Select the OpenPGP application on the card in SLOT.  This function
2647    must be used before any other OpenPGP application functions. */
2648 gpg_error_t
2649 app_select_openpgp (app_t app)
2650 {
2651   static char const aid[] = { 0xD2, 0x76, 0x00, 0x01, 0x24, 0x01 };
2652   int slot = app->slot;
2653   int rc;
2654   unsigned char *buffer;
2655   size_t buflen;
2656   void *relptr;
2657   
2658   /* Note that the card can't cope with P2=0xCO, thus we need to pass a
2659      special flag value. */
2660   rc = iso7816_select_application (slot, aid, sizeof aid, 0x0001);
2661   if (!rc)
2662     {
2663       unsigned int manufacturer;
2664
2665       app->apptype = "OPENPGP";
2666
2667       app->did_chv1 = 0;
2668       app->did_chv2 = 0;
2669       app->did_chv3 = 0;
2670       app->app_local = NULL;
2671
2672       /* The OpenPGP card returns the serial number as part of the
2673          AID; because we prefer to use OpenPGP serial numbers, we
2674          replace a possibly already set one from a EF.GDO with this
2675          one.  Note, that for current OpenPGP cards, no EF.GDO exists
2676          and thus it won't matter at all. */
2677       rc = iso7816_get_data (slot, 0x004F, &buffer, &buflen);
2678       if (rc)
2679         goto leave;
2680       if (opt.verbose)
2681         {
2682           log_info ("AID: ");
2683           log_printhex ("", buffer, buflen);
2684         }
2685
2686       app->card_version = buffer[6] << 8;
2687       app->card_version |= buffer[7];
2688       manufacturer = (buffer[8]<<8 | buffer[9]);
2689
2690       xfree (app->serialno);
2691       app->serialno = buffer;
2692       app->serialnolen = buflen;
2693       buffer = NULL;
2694       app->app_local = xtrycalloc (1, sizeof *app->app_local);
2695       if (!app->app_local)
2696         {
2697           rc = gpg_error (gpg_err_code_from_errno (errno));
2698           goto leave;
2699         }
2700
2701       relptr = get_one_do (app, 0x00C4, &buffer, &buflen, NULL);
2702       if (!relptr)
2703         {
2704           log_error (_("can't access %s - invalid OpenPGP card?\n"),
2705                      "CHV Status Bytes");
2706           goto leave;
2707         }
2708       app->force_chv1 = (buflen && *buffer == 0);
2709       xfree (relptr);
2710
2711       relptr = get_one_do (app, 0x00C0, &buffer, &buflen, NULL);
2712       if (!relptr)
2713         {
2714           log_error (_("can't access %s - invalid OpenPGP card?\n"),
2715                      "Extended Capability Flags" );
2716           goto leave;
2717         }
2718       if (buflen)
2719         {
2720           app->app_local->extcap.get_challenge    = !!(*buffer & 0x40);
2721           app->app_local->extcap.key_import       = !!(*buffer & 0x20);
2722           app->app_local->extcap.change_force_chv = !!(*buffer & 0x10);
2723           app->app_local->extcap.private_dos      = !!(*buffer & 0x08);
2724         }
2725       xfree (relptr);
2726       
2727       /* Some of the first cards accidently don't set the
2728          CHANGE_FORCE_CHV bit but allow it anyway. */
2729       if (app->card_version <= 0x0100 && manufacturer == 1)
2730         app->app_local->extcap.change_force_chv = 1;
2731
2732       parse_login_data (app);
2733
2734       if (opt.verbose > 1)
2735         dump_all_do (slot);
2736
2737       app->fnc.deinit = do_deinit;
2738       app->fnc.learn_status = do_learn_status;
2739       app->fnc.readkey = do_readkey;
2740       app->fnc.getattr = do_getattr;
2741       app->fnc.setattr = do_setattr;
2742       app->fnc.writekey = do_writekey;
2743       app->fnc.genkey = do_genkey;
2744       app->fnc.sign = do_sign;
2745       app->fnc.auth = do_auth;
2746       app->fnc.decipher = do_decipher;
2747       app->fnc.change_pin = do_change_pin;
2748       app->fnc.check_pin = do_check_pin;
2749    }
2750
2751 leave:
2752   if (rc)
2753     do_deinit (app);
2754   return rc;
2755 }
2756
2757
2758