Made --fixed-list-mode obsolete.
[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 function 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   if (chvno == 2 && app->app_local->flags.def_chv2)
1304     {
1305       /* Special case for def_chv2 mechanism. */
1306       if (opt.verbose)
1307         log_info (_("using default PIN as %s\n"), "CHV2");
1308       rc = iso7816_verify (app->slot, 0x82, "123456", 6);
1309       if (rc)
1310         {
1311           /* Verification of CHV2 with the default PIN failed,
1312              although the card pretends to have the default PIN set as
1313              CHV2.  We better disable the def_chv2 flag now. */
1314           log_info (_("failed to use default PIN as %s: %s"
1315                       " - disabling further default use\n"),
1316                     "CHV2", gpg_strerror (rc));
1317           app->app_local->flags.def_chv2 = 0;
1318         }
1319       return rc;
1320     }
1321
1322   memset (&pininfo, 0, sizeof pininfo);
1323   pininfo.mode = 1;
1324   pininfo.minlen = minlen;
1325   
1326   if (!opt.disable_keypad
1327       && !iso7816_check_keypad (app->slot, ISO7816_VERIFY, &pininfo) )
1328     {
1329       /* The reader supports the verify command through the keypad. */
1330
1331       if (chvno == 1)
1332         {
1333 #define PROMPTSTRING  _("||Please enter your PIN at the reader's keypad%%0A" \
1334                         "[sigs done: %lu]")
1335           size_t promptsize = strlen (PROMPTSTRING) + 50;
1336
1337           prompt = xmalloc (promptsize);
1338           if (!prompt)
1339             return gpg_error_from_syserror ();
1340           snprintf (prompt, promptsize-1, PROMPTSTRING, sigcount);
1341           rc = pincb (pincb_arg, prompt, NULL); 
1342           xfree (prompt);
1343 #undef PROMPTSTRING
1344         }
1345       else
1346         rc = pincb (pincb_arg,
1347                     _("||Please enter your PIN at the reader's keypad"),
1348                     NULL);
1349       if (rc)
1350         {
1351           log_info (_("PIN callback returned error: %s\n"),
1352                     gpg_strerror (rc));
1353           return rc;
1354         }
1355       rc = iso7816_verify_kp (app->slot, 0x80+chvno, "", 0, &pininfo); 
1356       /* Dismiss the prompt. */
1357       pincb (pincb_arg, NULL, NULL);
1358
1359       assert (!*pinvalue);
1360     }
1361   else
1362     {
1363       /* The reader has no keypad or we don't want to use it. */
1364
1365       if (chvno == 1)
1366         {
1367 #define PROMPTSTRING  _("||Please enter the PIN%%0A[sigs done: %lu]")
1368           size_t promptsize = strlen (PROMPTSTRING) + 50;
1369
1370           prompt = xmalloc (promptsize);
1371           if (!prompt)
1372             return gpg_error_from_syserror ();
1373           snprintf (prompt, promptsize-1, PROMPTSTRING, sigcount);
1374           rc = pincb (pincb_arg, prompt, pinvalue); 
1375           xfree (prompt);
1376 #undef PROMPTSTRING
1377         }
1378       else
1379         rc = pincb (pincb_arg, "PIN", pinvalue); 
1380
1381       if (rc)
1382         {
1383           log_info (_("PIN callback returned error: %s\n"),
1384                     gpg_strerror (rc));
1385           return rc;
1386         }
1387       
1388       if (strlen (*pinvalue) < minlen)
1389         {
1390           log_error (_("PIN for CHV%d is too short;"
1391                        " minimum length is %d\n"), chvno, minlen);
1392           xfree (*pinvalue);
1393           *pinvalue = NULL;
1394           return gpg_error (GPG_ERR_BAD_PIN);
1395         }
1396
1397       rc = iso7816_verify (app->slot, 0x80+chvno,
1398                            *pinvalue, strlen (*pinvalue));
1399     }
1400   
1401   if (rc)
1402     {
1403       log_error (_("verify CHV%d failed: %s\n"), chvno, gpg_strerror (rc));
1404       xfree (*pinvalue);
1405       *pinvalue = NULL;
1406       flush_cache_after_error (app);
1407     }
1408
1409   return rc;
1410 }
1411
1412
1413 /* Verify CHV2 if required.  Depending on the configuration of the
1414    card CHV1 will also be verified. */
1415 static gpg_error_t
1416 verify_chv2 (app_t app,
1417              gpg_error_t (*pincb)(void*, const char *, char **),
1418              void *pincb_arg)
1419 {
1420   int rc;
1421   char *pinvalue;
1422
1423   if (app->did_chv2) 
1424     return 0;  /* We already verified CHV2.  */
1425
1426   rc = verify_a_chv (app, pincb, pincb_arg, 2, 0, &pinvalue);
1427   if (rc)
1428     return rc;
1429
1430   app->did_chv2 = 1;
1431   
1432   if (!app->did_chv1 && !app->force_chv1 && pinvalue)
1433     {
1434       /* For convenience we verify CHV1 here too.  We do this only if
1435          the card is not configured to require a verification before
1436          each CHV1 controlled operation (force_chv1) and if we are not
1437          using the keypad (PINVALUE == NULL). */
1438       rc = iso7816_verify (app->slot, 0x81, pinvalue, strlen (pinvalue));
1439       if (gpg_err_code (rc) == GPG_ERR_BAD_PIN)
1440         rc = gpg_error (GPG_ERR_PIN_NOT_SYNCED);
1441       if (rc)
1442         {
1443           log_error (_("verify CHV%d failed: %s\n"), 1, gpg_strerror (rc));
1444           flush_cache_after_error (app);
1445         }
1446       else
1447         app->did_chv1 = 1;
1448     }
1449   xfree (pinvalue);
1450
1451   return rc;
1452 }
1453
1454
1455 /* Verify CHV3 if required. */
1456 static gpg_error_t
1457 verify_chv3 (app_t app,
1458              gpg_error_t (*pincb)(void*, const char *, char **),
1459              void *pincb_arg)
1460 {
1461   int rc = 0;
1462
1463 #if GNUPG_MAJOR_VERSION != 1
1464   if (!opt.allow_admin)
1465     {
1466       log_info (_("access to admin commands is not configured\n"));
1467       return gpg_error (GPG_ERR_EACCES);
1468     }
1469 #endif
1470       
1471   if (!app->did_chv3) 
1472     {
1473       void *relptr;
1474       unsigned char *value;
1475       size_t valuelen;
1476       iso7816_pininfo_t pininfo;
1477       int minlen = 8;
1478       int remaining;
1479
1480       memset (&pininfo, 0, sizeof pininfo);
1481       pininfo.mode = 1;
1482       pininfo.minlen = minlen;
1483
1484       relptr = get_one_do (app, 0x00C4, &value, &valuelen, NULL);
1485       if (!relptr || valuelen < 7)
1486         {
1487           log_error (_("error retrieving CHV status from card\n"));
1488           xfree (relptr);
1489           return gpg_error (GPG_ERR_CARD);
1490         }
1491       if (value[6] == 0)
1492         {
1493           log_info (_("card is permanently locked!\n"));
1494           xfree (relptr);
1495           return gpg_error (GPG_ERR_BAD_PIN);
1496         }
1497       remaining = value[6];
1498       xfree (relptr);
1499
1500       log_info(_("%d Admin PIN attempts remaining before card"
1501                  " is permanently locked\n"), remaining);
1502
1503       if (!opt.disable_keypad
1504           && !iso7816_check_keypad (app->slot, ISO7816_VERIFY, &pininfo) )
1505         {
1506           /* The reader supports the verify command through the keypad. */
1507           
1508           if (remaining < 3)
1509             {
1510 #define PROMPTSTRING  _("|A|Please enter the Admin PIN" \
1511                         " at the reader's keypad%%0A"   \
1512                         "[remaining attempts: %d]")
1513               size_t promptsize = strlen (PROMPTSTRING) + 50;
1514               char *prompt;
1515               
1516               prompt = xmalloc (promptsize);
1517               if (!prompt)
1518                 return gpg_error_from_syserror ();
1519               snprintf (prompt, promptsize-1, PROMPTSTRING, remaining);
1520               rc = pincb (pincb_arg, prompt, NULL); 
1521               xfree (prompt);
1522 #undef PROMPTSTRING
1523             }
1524           else
1525             rc = pincb (pincb_arg, _("|A|Please enter the Admin PIN"
1526                                      " at the reader's keypad"),   NULL);
1527
1528           if (rc)
1529             {
1530               log_info (_("PIN callback returned error: %s\n"),
1531                         gpg_strerror (rc));
1532               return rc;
1533             }
1534           rc = iso7816_verify_kp (app->slot, 0x83, "", 0, &pininfo); 
1535           /* Dismiss the prompt. */
1536           pincb (pincb_arg, NULL, NULL);
1537         }
1538       else
1539         {
1540           char *pinvalue;
1541
1542           /* TRANSLATORS: Do not translate the "|A|" prefix but keep
1543              it at the start of the string.  We need this elsewhere to
1544              get some infos on the string. */
1545           rc = pincb (pincb_arg, _("|A|Admin PIN"), &pinvalue); 
1546           if (rc)
1547             {
1548               log_info (_("PIN callback returned error: %s\n"),
1549                         gpg_strerror (rc));
1550               return rc;
1551             }
1552           
1553           if (strlen (pinvalue) < minlen)
1554             {
1555               log_error (_("PIN for CHV%d is too short;"
1556                            " minimum length is %d\n"), 3, minlen);
1557               xfree (pinvalue);
1558               return gpg_error (GPG_ERR_BAD_PIN);
1559             }
1560           
1561           rc = iso7816_verify (app->slot, 0x83, pinvalue, strlen (pinvalue));
1562           xfree (pinvalue);
1563         }
1564       
1565       if (rc)
1566         {
1567           log_error (_("verify CHV%d failed: %s\n"), 3, gpg_strerror (rc));
1568           flush_cache_after_error (app);
1569           return rc;
1570         }
1571     }
1572   return rc;
1573 }
1574
1575
1576 /* Handle the SETATTR operation. All arguments are already basically
1577    checked. */
1578 static gpg_error_t 
1579 do_setattr (app_t app, const char *name,
1580             gpg_error_t (*pincb)(void*, const char *, char **),
1581             void *pincb_arg,
1582             const unsigned char *value, size_t valuelen)
1583 {
1584   gpg_error_t rc;
1585   int idx;
1586   static struct {
1587     const char *name;
1588     int tag;
1589     int need_chv;
1590     int special;
1591   } table[] = {
1592     { "DISP-NAME",    0x005B, 3 },
1593     { "LOGIN-DATA",   0x005E, 3, 2 },
1594     { "DISP-LANG",    0x5F2D, 3 },
1595     { "DISP-SEX",     0x5F35, 3 },
1596     { "PUBKEY-URL",   0x5F50, 3 },
1597     { "CHV-STATUS-1", 0x00C4, 3, 1 },
1598     { "CA-FPR-1",     0x00CA, 3 },
1599     { "CA-FPR-2",     0x00CB, 3 },
1600     { "CA-FPR-3",     0x00CC, 3 },
1601     { "PRIVATE-DO-1", 0x0101, 2 },
1602     { "PRIVATE-DO-2", 0x0102, 3 },
1603     { "PRIVATE-DO-3", 0x0103, 2 },
1604     { "PRIVATE-DO-4", 0x0104, 3 },
1605     { NULL, 0 }
1606   };
1607
1608
1609   for (idx=0; table[idx].name && strcmp (table[idx].name, name); idx++)
1610     ;
1611   if (!table[idx].name)
1612     return gpg_error (GPG_ERR_INV_NAME); 
1613
1614   switch (table[idx].need_chv)
1615     {
1616     case 2:
1617       rc = verify_chv2 (app, pincb, pincb_arg);
1618       break;
1619     case 3:
1620       rc = verify_chv3 (app, pincb, pincb_arg);
1621       break;
1622     default:
1623       rc = 0;
1624     }
1625   if (rc)
1626     return rc;
1627
1628   /* Flush the cache before writing it, so that the next get operation
1629      will reread the data from the card and thus get synced in case of
1630      errors (e.g. data truncated by the card). */
1631   flush_cache_item (app, table[idx].tag);
1632   rc = iso7816_put_data (app->slot, table[idx].tag, value, valuelen);
1633   if (rc)
1634     log_error ("failed to set `%s': %s\n", table[idx].name, gpg_strerror (rc));
1635
1636   if (table[idx].special == 1)
1637     app->force_chv1 = (valuelen && *value == 0);
1638   else if (table[idx].special == 2)
1639     parse_login_data (app);
1640
1641   return rc;
1642 }
1643
1644
1645 /* Handle the PASSWD command. */
1646 static gpg_error_t 
1647 do_change_pin (app_t app, ctrl_t ctrl,  const char *chvnostr, int reset_mode,
1648                gpg_error_t (*pincb)(void*, const char *, char **),
1649                void *pincb_arg)
1650 {
1651   int rc = 0;
1652   int chvno = atoi (chvnostr);
1653   char *pinvalue;
1654
1655   if (reset_mode && chvno == 3)
1656     {
1657       rc = gpg_error (GPG_ERR_INV_ID);
1658       goto leave;
1659     }
1660   else if (reset_mode || chvno == 3)
1661     {
1662       /* we always require that the PIN is entered. */
1663       app->did_chv3 = 0;
1664       rc = verify_chv3 (app, pincb, pincb_arg);
1665       if (rc)
1666         goto leave;
1667     }
1668   else if (chvno == 1 || chvno == 2)
1669     {
1670       /* CHV1 and CVH2 should always have the same value, thus we
1671          enforce it here.  */
1672       int save_force = app->force_chv1;
1673
1674       app->force_chv1 = 0;
1675       app->did_chv1 = 0;
1676       app->did_chv2 = 0;
1677       rc = verify_chv2 (app, pincb, pincb_arg);
1678       app->force_chv1 = save_force;
1679       if (rc)
1680         goto leave;
1681     }
1682   else
1683     {
1684       rc = gpg_error (GPG_ERR_INV_ID);
1685       goto leave;
1686     }
1687
1688   if (chvno == 3)
1689     app->did_chv3 = 0;
1690   else
1691     app->did_chv1 = app->did_chv2 = 0;
1692
1693   /* TRANSLATORS: Do not translate the "|*|" prefixes but
1694      keep it at the start of the string.  We need this elsewhere
1695      to get some infos on the string. */
1696   rc = pincb (pincb_arg, chvno == 3? _("|AN|New Admin PIN") : _("|N|New PIN"), 
1697               &pinvalue); 
1698   if (rc)
1699     {
1700       log_error (_("error getting new PIN: %s\n"), gpg_strerror (rc));
1701       goto leave;
1702     }
1703
1704   if (reset_mode)
1705     {
1706       rc = iso7816_reset_retry_counter (app->slot, 0x81,
1707                                         pinvalue, strlen (pinvalue));
1708       if (!rc)
1709         rc = iso7816_reset_retry_counter (app->slot, 0x82,
1710                                           pinvalue, strlen (pinvalue));
1711     }
1712   else
1713     {
1714       if (chvno == 1 || chvno == 2)
1715         {
1716           rc = iso7816_change_reference_data (app->slot, 0x81, NULL, 0,
1717                                               pinvalue, strlen (pinvalue));
1718           if (!rc)
1719             rc = iso7816_change_reference_data (app->slot, 0x82, NULL, 0,
1720                                                 pinvalue, strlen (pinvalue));
1721         }
1722       else
1723         rc = iso7816_change_reference_data (app->slot, 0x80 + chvno, NULL, 0,
1724                                             pinvalue, strlen (pinvalue));
1725     }
1726   xfree (pinvalue);
1727   if (rc)
1728     flush_cache_after_error (app);
1729
1730  leave:
1731   return rc;
1732 }
1733
1734
1735 /* Check whether a key already exists.  KEYIDX is the index of the key
1736    (0..2).  If FORCE is TRUE a diagnositic will be printed but no
1737    error returned if the key already exists. */
1738 static gpg_error_t
1739 does_key_exist (app_t app, int keyidx, int force)
1740 {
1741   const unsigned char *fpr;
1742   unsigned char *buffer;
1743   size_t buflen, n;
1744   int i;
1745
1746   assert (keyidx >=0 && keyidx <= 2);
1747
1748   if (iso7816_get_data (app->slot, 0x006E, &buffer, &buflen))
1749     {
1750       log_error (_("error reading application data\n"));
1751       return gpg_error (GPG_ERR_GENERAL);
1752     }
1753   fpr = find_tlv (buffer, buflen, 0x00C5, &n);
1754   if (!fpr || n < 60)
1755     {
1756       log_error (_("error reading fingerprint DO\n"));
1757       xfree (buffer);
1758       return gpg_error (GPG_ERR_GENERAL);
1759     }
1760   fpr += 20*keyidx;
1761   for (i=0; i < 20 && !fpr[i]; i++)
1762     ;
1763   xfree (buffer);
1764   if (i!=20 && !force)
1765     {
1766       log_error (_("key already exists\n"));
1767       return gpg_error (GPG_ERR_EEXIST);
1768     }
1769   else if (i!=20)
1770     log_info (_("existing key will be replaced\n"));
1771   else
1772     log_info (_("generating new key\n"));
1773   return 0;
1774 }
1775
1776
1777
1778 /* Handle the WRITEKEY command for OpenPGP.  This function expects a
1779    canonical encoded S-expression with the secret key in KEYDATA and
1780    its length (for assertions) in KEYDATALEN.  KEYID needs to be the
1781    usual keyid which for OpenPGP is the string "OPENPGP.n" with
1782    n=1,2,3.  Bit 0 of FLAGS indicates whether an existing key shall
1783    get overwritten.  PINCB and PINCB_ARG are the usual arguments for
1784    the pinentry callback.  */
1785 static gpg_error_t
1786 do_writekey (app_t app, ctrl_t ctrl,
1787              const char *keyid, unsigned int flags,
1788              gpg_error_t (*pincb)(void*, const char *, char **),
1789              void *pincb_arg,
1790              const unsigned char *keydata, size_t keydatalen)
1791 {
1792   gpg_error_t err;
1793   int force = (flags & 1);
1794   int keyno;
1795   const unsigned char *buf, *tok;
1796   size_t buflen, toklen;
1797   int depth, last_depth1, last_depth2;
1798   const unsigned char *rsa_n = NULL;
1799   const unsigned char *rsa_e = NULL;
1800   const unsigned char *rsa_p = NULL;
1801   const unsigned char *rsa_q = NULL;
1802   size_t rsa_n_len, rsa_e_len, rsa_p_len, rsa_q_len;
1803   unsigned int nbits;
1804   unsigned char *template = NULL;
1805   unsigned char *tp;
1806   size_t template_len;
1807   unsigned char fprbuf[20];
1808   u32 created_at = 0;
1809
1810   if (!strcmp (keyid, "OPENPGP.1"))
1811     keyno = 0;
1812   else if (!strcmp (keyid, "OPENPGP.2"))
1813     keyno = 1;
1814   else if (!strcmp (keyid, "OPENPGP.3"))
1815     keyno = 2;
1816   else
1817     return gpg_error (GPG_ERR_INV_ID);
1818   
1819   err = does_key_exist (app, keyno, force);
1820   if (err)
1821     return err;
1822
1823
1824   /* 
1825      Parse the S-expression
1826    */
1827   buf = keydata;
1828   buflen = keydatalen;
1829   depth = 0;
1830   if ((err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen)))
1831     goto leave;
1832   if ((err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen)))
1833     goto leave;
1834   if (!tok || toklen != 11 || memcmp ("private-key", tok, toklen))
1835     {
1836       if (!tok)
1837         ;
1838       else if (toklen == 21 && !memcmp ("protected-private-key", tok, toklen))
1839         log_info ("protected-private-key passed to writekey\n");
1840       else if (toklen == 20 && !memcmp ("shadowed-private-key", tok, toklen))
1841         log_info ("shadowed-private-key passed to writekey\n");
1842       err = gpg_error (GPG_ERR_BAD_SECKEY);
1843       goto leave;
1844     }
1845   if ((err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen)))
1846     goto leave;
1847   if ((err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen)))
1848     goto leave;
1849   if (!tok || toklen != 3 || memcmp ("rsa", tok, toklen))
1850     {
1851       err = gpg_error (GPG_ERR_WRONG_PUBKEY_ALGO);
1852       goto leave;
1853     }
1854   last_depth1 = depth;
1855   while (!(err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen))
1856          && depth && depth >= last_depth1)
1857     {
1858       if (tok)
1859         {
1860           err = gpg_error (GPG_ERR_UNKNOWN_SEXP);
1861           goto leave;
1862         }
1863       if ((err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen)))
1864         goto leave;
1865       if (tok && toklen == 1)
1866         {
1867           const unsigned char **mpi;
1868           size_t *mpi_len;
1869
1870           switch (*tok)
1871             {
1872             case 'n': mpi = &rsa_n; mpi_len = &rsa_n_len; break; 
1873             case 'e': mpi = &rsa_e; mpi_len = &rsa_e_len; break; 
1874             case 'p': mpi = &rsa_p; mpi_len = &rsa_p_len; break; 
1875             case 'q': mpi = &rsa_q; mpi_len = &rsa_q_len;break; 
1876             default: mpi = NULL;  mpi_len = NULL; break;
1877             }
1878           if (mpi && *mpi)
1879             {
1880               err = gpg_error (GPG_ERR_DUP_VALUE);
1881               goto leave;
1882             }
1883           if ((err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen)))
1884             goto leave;
1885           if (tok && mpi)
1886             {
1887               /* Strip off leading zero bytes and save. */
1888               for (;toklen && !*tok; toklen--, tok++)
1889                 ;
1890               *mpi = tok;
1891               *mpi_len = toklen;
1892             }
1893         }
1894       /* Skip until end of list. */
1895       last_depth2 = depth;
1896       while (!(err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen))
1897              && depth && depth >= last_depth2)
1898         ;
1899       if (err)
1900         goto leave;
1901     }
1902   /* Parse other attributes. */
1903   last_depth1 = depth;
1904   while (!(err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen))
1905          && depth && depth >= last_depth1)
1906     {
1907       if (tok)
1908         {
1909           err = gpg_error (GPG_ERR_UNKNOWN_SEXP);
1910           goto leave;
1911         }
1912       if ((err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen)))
1913         goto leave;
1914       if (tok && toklen == 10 && !memcmp ("created-at", tok, toklen))
1915         {
1916           if ((err = parse_sexp (&buf,&buflen,&depth,&tok,&toklen)))
1917             goto leave;
1918           if (tok)
1919             {
1920               for (created_at=0; toklen && *tok && *tok >= '0' && *tok <= '9';
1921                    tok++, toklen--)
1922                 created_at = created_at*10 + (*tok - '0');
1923             }
1924         }
1925       /* Skip until end of list. */
1926       last_depth2 = depth;
1927       while (!(err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen))
1928              && depth && depth >= last_depth2)
1929         ;
1930       if (err)
1931         goto leave;
1932     }
1933
1934
1935   /* Check that we have all parameters and that they match the card
1936      description. */
1937   if (!created_at)
1938     {
1939       log_error (_("creation timestamp missing\n"));
1940       err = gpg_error (GPG_ERR_INV_VALUE);
1941       goto leave;
1942     }
1943   nbits = rsa_n? count_bits (rsa_n, rsa_n_len) : 0;
1944   if (nbits != 1024)
1945     {
1946       log_error (_("RSA modulus missing or not of size %d bits\n"), 1024);
1947       err = gpg_error (GPG_ERR_BAD_SECKEY);
1948       goto leave;
1949     }
1950   nbits = rsa_e? count_bits (rsa_e, rsa_e_len) : 0;
1951   if (nbits < 2 || nbits > 32)
1952     {
1953       log_error (_("RSA public exponent missing or larger than %d bits\n"),
1954                  32);
1955       err = gpg_error (GPG_ERR_BAD_SECKEY);
1956       goto leave;
1957     }
1958   nbits = rsa_p? count_bits (rsa_p, rsa_p_len) : 0;
1959   if (nbits != 512)
1960     {
1961       log_error (_("RSA prime %s missing or not of size %d bits\n"), "P", 512);
1962       err = gpg_error (GPG_ERR_BAD_SECKEY);
1963       goto leave;
1964     }
1965   nbits = rsa_q? count_bits (rsa_q, rsa_q_len) : 0;
1966   if (nbits != 512)
1967     {
1968       log_error (_("RSA prime %s missing or not of size %d bits\n"), "Q", 512);
1969       err = gpg_error (GPG_ERR_BAD_SECKEY);
1970       goto leave;
1971     }
1972   
1973
1974   /* Build the private key template as described in section 4.3.3.6 of
1975      the OpenPGP card specs:
1976          0xC0   <length> public exponent
1977          0xC1   <length> prime p 
1978          0xC2   <length> prime q 
1979   */
1980   assert (rsa_e_len <= 4);
1981   template_len = (1 + 1 + 4
1982                   + 1 + 1 + rsa_p_len
1983                   + 1 + 1 + rsa_q_len);
1984   template = tp = xtrymalloc_secure (template_len);
1985   if (!template)
1986     {
1987       err = gpg_error_from_syserror ();
1988       goto leave;
1989     }
1990   *tp++ = 0xC0;
1991   *tp++ = 4;
1992   memcpy (tp, rsa_e, rsa_e_len);
1993   if (rsa_e_len < 4)
1994     {
1995       /* Right justify E. */
1996       memmove (tp+4-rsa_e_len, tp, rsa_e_len);
1997       memset (tp, 0, 4-rsa_e_len);
1998     }                 
1999   tp += 4;
2000
2001   *tp++ = 0xC1;
2002   *tp++ = rsa_p_len;
2003   memcpy (tp, rsa_p, rsa_p_len);
2004   tp += rsa_p_len;
2005
2006   *tp++ = 0xC2;
2007   *tp++ = rsa_q_len;
2008   memcpy (tp, rsa_q, rsa_q_len);
2009   tp += rsa_q_len;
2010
2011   assert (tp - template == template_len);
2012
2013
2014   /* Obviously we need to remove the cached public key.  */
2015   xfree (app->app_local->pk[keyno].key);
2016   app->app_local->pk[keyno].key = NULL;
2017   app->app_local->pk[keyno].keylen = 0;
2018   app->app_local->pk[keyno].read_done = 0;
2019
2020   /* Prepare for storing the key.  */
2021   err = verify_chv3 (app, pincb, pincb_arg);
2022   if (err)
2023     goto leave;
2024
2025   /* Store the key. */
2026   err = iso7816_put_data (app->slot,
2027                          (app->card_version > 0x0007? 0xE0 : 0xE9) + keyno,
2028                          template, template_len);
2029   if (err)
2030     {
2031       log_error (_("failed to store the key: %s\n"), gpg_strerror (err));
2032       goto leave;
2033     }
2034  
2035   err = store_fpr (app->slot, keyno, created_at,
2036                   rsa_n, rsa_n_len, rsa_e, rsa_e_len,
2037                   fprbuf, app->card_version);
2038   if (err)
2039     goto leave;
2040
2041
2042  leave:
2043   xfree (template);
2044   return err;
2045 }
2046
2047
2048 /* Handle the GENKEY command. */
2049 static gpg_error_t 
2050 do_genkey (app_t app, ctrl_t ctrl,  const char *keynostr, unsigned int flags,
2051            time_t createtime,
2052            gpg_error_t (*pincb)(void*, const char *, char **),
2053            void *pincb_arg)
2054 {
2055   int rc;
2056   char numbuf[30];
2057   unsigned char fprbuf[20];
2058   const unsigned char *keydata, *m, *e;
2059   unsigned char *buffer = NULL;
2060   size_t buflen, keydatalen, mlen, elen;
2061   time_t created_at;
2062   int keyno = atoi (keynostr);
2063   int force = (flags & 1);
2064   time_t start_at;
2065
2066   if (keyno < 1 || keyno > 3)
2067     return gpg_error (GPG_ERR_INV_ID);
2068   keyno--;
2069
2070   /* We flush the cache to increase the traffic before a key
2071      generation.  This _might_ help a card to gather more entropy. */
2072   flush_cache (app);
2073
2074   /* Obviously we need to remove the cached public key.  */
2075   xfree (app->app_local->pk[keyno].key);
2076   app->app_local->pk[keyno].key = NULL;
2077   app->app_local->pk[keyno].keylen = 0;
2078   app->app_local->pk[keyno].read_done = 0;
2079
2080   /* Check whether a key already exists.  */
2081   rc = does_key_exist (app, keyno, force);
2082   if (rc)
2083     return rc;
2084
2085   /* Prepare for key generation by verifying the Admin PIN.  */
2086   rc = verify_chv3 (app, pincb, pincb_arg);
2087   if (rc)
2088     goto leave;
2089    
2090 #if 1
2091   log_info (_("please wait while key is being generated ...\n"));
2092   start_at = time (NULL);
2093   rc = iso7816_generate_keypair 
2094 #else
2095 # warning key generation temporary replaced by reading an existing key.
2096   rc = iso7816_read_public_key
2097 #endif
2098     (app->slot, (const unsigned char*)(keyno == 0? "\xB6" :
2099                                        keyno == 1? "\xB8" : "\xA4"),
2100      2,
2101      &buffer, &buflen);
2102   if (rc)
2103     {
2104       rc = gpg_error (GPG_ERR_CARD);
2105       log_error (_("generating key failed\n"));
2106       goto leave;
2107     }
2108   log_info (_("key generation completed (%d seconds)\n"),
2109             (int)(time (NULL) - start_at));
2110   keydata = find_tlv (buffer, buflen, 0x7F49, &keydatalen);
2111   if (!keydata)
2112     {
2113       rc = gpg_error (GPG_ERR_CARD);
2114       log_error (_("response does not contain the public key data\n"));
2115       goto leave;
2116     }
2117  
2118   m = find_tlv (keydata, keydatalen, 0x0081, &mlen);
2119   if (!m)
2120     {
2121       rc = gpg_error (GPG_ERR_CARD);
2122       log_error (_("response does not contain the RSA modulus\n"));
2123       goto leave;
2124     }
2125 /*    log_printhex ("RSA n:", m, mlen); */
2126   send_key_data (ctrl, "n", m, mlen);
2127
2128   e = find_tlv (keydata, keydatalen, 0x0082, &elen);
2129   if (!e)
2130     {
2131       rc = gpg_error (GPG_ERR_CARD);
2132       log_error (_("response does not contain the RSA public exponent\n"));
2133       goto leave;
2134     }
2135 /*    log_printhex ("RSA e:", e, elen); */
2136   send_key_data (ctrl, "e", e, elen);
2137
2138   created_at = createtime? createtime : gnupg_get_time ();
2139   sprintf (numbuf, "%lu", (unsigned long)created_at);
2140   send_status_info (ctrl, "KEY-CREATED-AT",
2141                     numbuf, (size_t)strlen(numbuf), NULL, 0);
2142
2143   rc = store_fpr (app->slot, keyno, (u32)created_at,
2144                   m, mlen, e, elen, fprbuf, app->card_version);
2145   if (rc)
2146     goto leave;
2147   send_fpr_if_not_null (ctrl, "KEY-FPR", -1, fprbuf);
2148
2149
2150  leave:
2151   xfree (buffer);
2152   return rc;
2153 }
2154
2155
2156 static unsigned long
2157 convert_sig_counter_value (const unsigned char *value, size_t valuelen)
2158 {
2159   unsigned long ul;
2160
2161   if (valuelen == 3 )
2162     ul = (value[0] << 16) | (value[1] << 8) | value[2];
2163   else
2164     {
2165       log_error (_("invalid structure of OpenPGP card (DO 0x93)\n"));
2166       ul = 0;
2167     }
2168   return ul;
2169 }
2170
2171 static unsigned long
2172 get_sig_counter (app_t app)
2173 {
2174   void *relptr;
2175   unsigned char *value;
2176   size_t valuelen;
2177   unsigned long ul;
2178
2179   relptr = get_one_do (app, 0x0093, &value, &valuelen, NULL);
2180   if (!relptr)
2181     return 0;
2182   ul = convert_sig_counter_value (value, valuelen);
2183   xfree (relptr);
2184   return ul;
2185 }
2186
2187 static gpg_error_t
2188 compare_fingerprint (app_t app, int keyno, unsigned char *sha1fpr)
2189 {
2190   const unsigned char *fpr;
2191   unsigned char *buffer;
2192   size_t buflen, n;
2193   int rc, i;
2194   
2195   assert (keyno >= 1 && keyno <= 3);
2196
2197   rc = get_cached_data (app, 0x006E, &buffer, &buflen, 0);
2198   if (rc)
2199     {
2200       log_error (_("error reading application data\n"));
2201       return gpg_error (GPG_ERR_GENERAL);
2202     }
2203   fpr = find_tlv (buffer, buflen, 0x00C5, &n);
2204   if (!fpr || n != 60)
2205     {
2206       xfree (buffer);
2207       log_error (_("error reading fingerprint DO\n"));
2208       return gpg_error (GPG_ERR_GENERAL);
2209     }
2210   fpr += (keyno-1)*20;
2211   for (i=0; i < 20; i++)
2212     if (sha1fpr[i] != fpr[i])
2213       {
2214         xfree (buffer);
2215         log_info (_("fingerprint on card does not match requested one\n"));
2216         return gpg_error (GPG_ERR_WRONG_SECKEY);
2217       }
2218   xfree (buffer);
2219   return 0;
2220 }
2221
2222
2223   /* If a fingerprint has been specified check it against the one on
2224      the card.  This is allows for a meaningful error message in case
2225      the key on the card has been replaced but the shadow information
2226      known to gpg was not updated.  If there is no fingerprint we
2227      assume that this is okay. */
2228 static gpg_error_t
2229 check_against_given_fingerprint (app_t app, const char *fpr, int keyno)
2230 {
2231   unsigned char tmp[20];
2232   const char *s;
2233   int n;
2234
2235   for (s=fpr, n=0; hexdigitp (s); s++, n++)
2236     ;
2237   if (n != 40)
2238     return gpg_error (GPG_ERR_INV_ID);
2239   else if (!*s)
2240     ; /* okay */
2241   else
2242     return gpg_error (GPG_ERR_INV_ID);
2243
2244   for (s=fpr, n=0; n < 20; s += 2, n++)
2245         tmp[n] = xtoi_2 (s);
2246   return compare_fingerprint (app, keyno, tmp);
2247 }
2248
2249
2250
2251 /* Compute a digital signature on INDATA which is expected to be the
2252    raw message digest. For this application the KEYIDSTR consists of
2253    the serialnumber and the fingerprint delimited by a slash.
2254
2255    Note that this function may return the error code
2256    GPG_ERR_WRONG_CARD to indicate that the card currently present does
2257    not match the one required for the requested action (e.g. the
2258    serial number does not match). 
2259    
2260    As a special feature a KEYIDSTR of "OPENPGP.3" redirects the
2261    operation to the auth command.
2262 */
2263 static gpg_error_t 
2264 do_sign (app_t app, const char *keyidstr, int hashalgo,
2265          gpg_error_t (*pincb)(void*, const char *, char **),
2266          void *pincb_arg,
2267          const void *indata, size_t indatalen,
2268          unsigned char **outdata, size_t *outdatalen )
2269 {
2270   static unsigned char sha1_prefix[15] = /* Object ID is 1.3.14.3.2.26 */
2271   { 0x30, 0x21, 0x30, 0x09, 0x06, 0x05, 0x2b, 0x0e, 0x03,
2272     0x02, 0x1a, 0x05, 0x00, 0x04, 0x14 };
2273   static unsigned char rmd160_prefix[15] = /* Object ID is 1.3.36.3.2.1 */
2274   { 0x30, 0x21, 0x30, 0x09, 0x06, 0x05, 0x2b, 0x24, 0x03,
2275     0x02, 0x01, 0x05, 0x00, 0x04, 0x14 };
2276   int rc;
2277   unsigned char data[35];
2278   unsigned char tmp_sn[20]; /* actually 16 but we use it also for the fpr. */
2279   const char *s;
2280   int n;
2281   const char *fpr = NULL;
2282   unsigned long sigcount;
2283   int use_auth = 0;
2284
2285   if (!keyidstr || !*keyidstr)
2286     return gpg_error (GPG_ERR_INV_VALUE);
2287   if (indatalen == 20)
2288     ;
2289   else if (indatalen == (15 + 20) && hashalgo == GCRY_MD_SHA1
2290            && !memcmp (indata, sha1_prefix, 15))
2291     {
2292       indata = (const char*)indata + 15;
2293       indatalen -= 15;
2294     }
2295   else if (indatalen == (15 + 20) && hashalgo == GCRY_MD_RMD160
2296            && !memcmp (indata, rmd160_prefix, 15))
2297     {
2298       indata = (const char*)indata + 15;
2299       indatalen -= 15;
2300     }
2301   else
2302     {
2303       log_error (_("card does not support digest algorithm %s\n"),
2304                  gcry_md_algo_name (hashalgo));
2305       return gpg_error (GPG_ERR_INV_VALUE);
2306     }
2307
2308   /* Check whether an OpenPGP card of any version has been requested. */
2309   if (!strcmp (keyidstr, "OPENPGP.1"))
2310     ;
2311   else if (!strcmp (keyidstr, "OPENPGP.3"))
2312     use_auth = 1;
2313   else if (strlen (keyidstr) < 32 || strncmp (keyidstr, "D27600012401", 12))
2314     return gpg_error (GPG_ERR_INV_ID);
2315   else
2316     {
2317       for (s=keyidstr, n=0; hexdigitp (s); s++, n++)
2318         ;
2319       if (n != 32)
2320         return gpg_error (GPG_ERR_INV_ID);
2321       else if (!*s)
2322         ; /* no fingerprint given: we allow this for now. */
2323       else if (*s == '/')
2324         fpr = s + 1; 
2325       else
2326         return gpg_error (GPG_ERR_INV_ID);
2327
2328       for (s=keyidstr, n=0; n < 16; s += 2, n++)
2329         tmp_sn[n] = xtoi_2 (s);
2330
2331       if (app->serialnolen != 16)
2332         return gpg_error (GPG_ERR_INV_CARD);
2333       if (memcmp (app->serialno, tmp_sn, 16))
2334         return gpg_error (GPG_ERR_WRONG_CARD);
2335     }
2336
2337   /* If a fingerprint has been specified check it against the one on
2338      the card.  This is allows for a meaningful error message in case
2339      the key on the card has been replaced but the shadow information
2340      known to gpg was not updated.  If there is no fingerprint, gpg
2341      will detect a bogus signature anyway due to the
2342      verify-after-signing feature. */
2343   rc = fpr? check_against_given_fingerprint (app, fpr, 1) : 0;
2344   if (rc)
2345     return rc;
2346
2347   if (hashalgo == GCRY_MD_SHA1)
2348     memcpy (data, sha1_prefix, 15);
2349   else if (hashalgo == GCRY_MD_RMD160)
2350     memcpy (data, rmd160_prefix, 15);
2351   else 
2352     return gpg_error (GPG_ERR_UNSUPPORTED_ALGORITHM);
2353   memcpy (data+15, indata, indatalen);
2354
2355   if (use_auth)
2356     {
2357       /* This is a hack to redirect to the internal authenticate command.  */
2358       return do_auth (app, "OPENPGP.3", pincb, pincb_arg,
2359                       data, 35,
2360                       outdata, outdatalen);
2361     }
2362
2363   sigcount = get_sig_counter (app);
2364   log_info (_("signatures created so far: %lu\n"), sigcount);
2365
2366   if (!app->did_chv1 || app->force_chv1 ) 
2367     {
2368       char *pinvalue;
2369
2370       rc = verify_a_chv (app, pincb, pincb_arg, 1, sigcount, &pinvalue);
2371       if (rc)
2372         return rc;
2373
2374       app->did_chv1 = 1;
2375
2376       if (!app->did_chv2 && pinvalue)
2377         {
2378           /* We should also verify CHV2.  Note, that we can't do that
2379              if the keypad has been used. */
2380           rc = iso7816_verify (app->slot, 0x82, pinvalue, strlen (pinvalue));
2381           if (gpg_err_code (rc) == GPG_ERR_BAD_PIN)
2382             rc = gpg_error (GPG_ERR_PIN_NOT_SYNCED);
2383           if (rc)
2384             {
2385               log_error (_("verify CHV%d failed: %s\n"), 2, gpg_strerror (rc));
2386               xfree (pinvalue);
2387               flush_cache_after_error (app);
2388               return rc;
2389             }
2390           app->did_chv2 = 1;
2391         }
2392       xfree (pinvalue);
2393     }
2394
2395   rc = iso7816_compute_ds (app->slot, data, 35, outdata, outdatalen);
2396   return rc;
2397 }
2398
2399 /* Compute a digital signature using the INTERNAL AUTHENTICATE command
2400    on INDATA which is expected to be the raw message digest. For this
2401    application the KEYIDSTR consists of the serialnumber and the
2402    fingerprint delimited by a slash.  Optionally the id OPENPGP.3 may
2403    be given.
2404
2405    Note that this function may return the error code
2406    GPG_ERR_WRONG_CARD to indicate that the card currently present does
2407    not match the one required for the requested action (e.g. the
2408    serial number does not match). */
2409 static gpg_error_t 
2410 do_auth (app_t app, const char *keyidstr,
2411          gpg_error_t (*pincb)(void*, const char *, char **),
2412          void *pincb_arg,
2413          const void *indata, size_t indatalen,
2414          unsigned char **outdata, size_t *outdatalen )
2415 {
2416   int rc;
2417   unsigned char tmp_sn[20]; /* actually 16 but we use it also for the fpr. */
2418   const char *s;
2419   int n;
2420   const char *fpr = NULL;
2421
2422   if (!keyidstr || !*keyidstr)
2423     return gpg_error (GPG_ERR_INV_VALUE);
2424   if (indatalen > 50) /* For a 1024 bit key. */
2425     return gpg_error (GPG_ERR_INV_VALUE);
2426
2427   /* Check whether an OpenPGP card of any version has been requested. */
2428   if (!strcmp (keyidstr, "OPENPGP.3"))
2429     ;
2430   else if (strlen (keyidstr) < 32 || strncmp (keyidstr, "D27600012401", 12))
2431     return gpg_error (GPG_ERR_INV_ID);
2432   else
2433     {
2434       for (s=keyidstr, n=0; hexdigitp (s); s++, n++)
2435         ;
2436       if (n != 32)
2437         return gpg_error (GPG_ERR_INV_ID);
2438       else if (!*s)
2439         ; /* no fingerprint given: we allow this for now. */
2440       else if (*s == '/')
2441         fpr = s + 1; 
2442       else
2443         return gpg_error (GPG_ERR_INV_ID);
2444
2445       for (s=keyidstr, n=0; n < 16; s += 2, n++)
2446         tmp_sn[n] = xtoi_2 (s);
2447       
2448       if (app->serialnolen != 16)
2449         return gpg_error (GPG_ERR_INV_CARD);
2450       if (memcmp (app->serialno, tmp_sn, 16))
2451         return gpg_error (GPG_ERR_WRONG_CARD);
2452     }
2453
2454   /* If a fingerprint has been specified check it against the one on
2455      the card.  This is allows for a meaningful error message in case
2456      the key on the card has been replaced but the shadow information
2457      known to gpg was not updated.  If there is no fingerprint, gpg
2458      will detect a bogus signature anyway due to the
2459      verify-after-signing feature. */
2460   rc = fpr? check_against_given_fingerprint (app, fpr, 3) : 0;
2461   if (rc)
2462     return rc;
2463
2464   rc = verify_chv2 (app, pincb, pincb_arg);
2465   if (!rc)
2466     rc = iso7816_internal_authenticate (app->slot, indata, indatalen,
2467                                         outdata, outdatalen);
2468   return rc;
2469 }
2470
2471
2472 static gpg_error_t 
2473 do_decipher (app_t app, const char *keyidstr,
2474              gpg_error_t (*pincb)(void*, const char *, char **),
2475              void *pincb_arg,
2476              const void *indata, size_t indatalen,
2477              unsigned char **outdata, size_t *outdatalen )
2478 {
2479   int rc;
2480   unsigned char tmp_sn[20]; /* actually 16 but we use it also for the fpr. */
2481   const char *s;
2482   int n;
2483   const char *fpr = NULL;
2484
2485   if (!keyidstr || !*keyidstr || !indatalen)
2486     return gpg_error (GPG_ERR_INV_VALUE);
2487
2488   /* Check whether an OpenPGP card of any version has been requested. */
2489   if (!strcmp (keyidstr, "OPENPGP.2"))
2490     ;
2491   else if (strlen (keyidstr) < 32 || strncmp (keyidstr, "D27600012401", 12))
2492     return gpg_error (GPG_ERR_INV_ID);
2493   else
2494     {
2495       for (s=keyidstr, n=0; hexdigitp (s); s++, n++)
2496         ;
2497       if (n != 32)
2498         return gpg_error (GPG_ERR_INV_ID);
2499       else if (!*s)
2500         ; /* no fingerprint given: we allow this for now. */
2501       else if (*s == '/')
2502         fpr = s + 1; 
2503       else
2504         return gpg_error (GPG_ERR_INV_ID);
2505       
2506       for (s=keyidstr, n=0; n < 16; s += 2, n++)
2507         tmp_sn[n] = xtoi_2 (s);
2508       
2509       if (app->serialnolen != 16)
2510         return gpg_error (GPG_ERR_INV_CARD);
2511       if (memcmp (app->serialno, tmp_sn, 16))
2512         return gpg_error (GPG_ERR_WRONG_CARD);
2513     }
2514
2515   /* If a fingerprint has been specified check it against the one on
2516      the card.  This is allows for a meaningful error message in case
2517      the key on the card has been replaced but the shadow information
2518      known to gpg was not updated.  If there is no fingerprint, the
2519      decryption will won't produce the right plaintext anyway. */
2520   rc = fpr? check_against_given_fingerprint (app, fpr, 2) : 0;
2521   if (rc)
2522     return rc;
2523
2524   rc = verify_chv2 (app, pincb, pincb_arg);
2525   if (!rc)
2526     {
2527       size_t fixuplen;
2528
2529       /* We might encounter a couple of leading zeroes in the
2530          cryptogram.  Due to internal use of MPIs thease leading
2531          zeroes are stripped.  However the OpenPGP card expects
2532          exactly 128 bytes for the cryptogram (for a 1k key).  Thus we
2533          need to fix it up.  We do this for up to 16 leading zero
2534          bytes; a cryptogram with more than this is with a very high
2535          probability anyway broken.  */
2536       if (indatalen >= (128-16) && indatalen < 128)      /* 1024 bit key.  */
2537         fixuplen = 128 - indatalen;
2538       else if (indatalen >= (256-16) && indatalen < 256) /* 2048 bit key.  */
2539         fixuplen = 256 - indatalen;
2540       else if (indatalen >= (192-16) && indatalen < 192) /* 1536 bit key.  */
2541         fixuplen = 192 - indatalen;
2542       else
2543         fixuplen = 0;
2544       if (fixuplen)
2545         {
2546           unsigned char *fixbuf;
2547
2548           /* While we have to prepend stuff anyway, we can also
2549              include the padding byte here so that iso1816_decipher
2550              does not need to do yet another data mangling.  */
2551           fixuplen++;
2552           fixbuf = xtrymalloc (fixuplen + indatalen);
2553           if (!fixbuf)
2554             rc = gpg_error_from_syserror ();
2555           else
2556             {
2557               memset (fixbuf, 0, fixuplen);
2558               memcpy (fixbuf+fixuplen, indata, indatalen);
2559               rc = iso7816_decipher (app->slot, fixbuf, fixuplen+indatalen, -1,
2560                                      outdata, outdatalen);
2561               xfree (fixbuf);
2562             }
2563
2564         }
2565       else
2566         rc = iso7816_decipher (app->slot, indata, indatalen, 0,
2567                                outdata, outdatalen);
2568     }
2569   return rc;
2570 }
2571
2572
2573 /* Perform a simple verify operation for CHV1 and CHV2, so that
2574    further operations won't ask for CHV2 and it is possible to do a
2575    cheap check on the PIN: If there is something wrong with the PIN
2576    entry system, only the regular CHV will get blocked and not the
2577    dangerous CHV3.  KEYIDSTR is the usual card's serial number; an
2578    optional fingerprint part will be ignored.
2579
2580    There is a special mode if the keyidstr is "<serialno>[CHV3]" with
2581    the "[CHV3]" being a literal string:  The Admin Pin is checked if
2582    and only if the retry counter is still at 3. */
2583 static gpg_error_t 
2584 do_check_pin (app_t app, const char *keyidstr,
2585               gpg_error_t (*pincb)(void*, const char *, char **),
2586               void *pincb_arg)
2587 {
2588   unsigned char tmp_sn[20]; 
2589   const char *s;
2590   int n;
2591   int admin_pin = 0;
2592
2593   if (!keyidstr || !*keyidstr)
2594     return gpg_error (GPG_ERR_INV_VALUE);
2595
2596   /* Check whether an OpenPGP card of any version has been requested. */
2597   if (strlen (keyidstr) < 32 || strncmp (keyidstr, "D27600012401", 12))
2598     return gpg_error (GPG_ERR_INV_ID);
2599   
2600   for (s=keyidstr, n=0; hexdigitp (s); s++, n++)
2601     ;
2602   if (n != 32)
2603     return gpg_error (GPG_ERR_INV_ID);
2604   else if (!*s)
2605     ; /* No fingerprint given: we allow this for now. */
2606   else if (*s == '/')
2607     ; /* We ignore a fingerprint. */
2608   else if (!strcmp (s, "[CHV3]") )
2609     admin_pin = 1;
2610   else
2611     return gpg_error (GPG_ERR_INV_ID);
2612
2613   for (s=keyidstr, n=0; n < 16; s += 2, n++)
2614     tmp_sn[n] = xtoi_2 (s);
2615
2616   if (app->serialnolen != 16)
2617     return gpg_error (GPG_ERR_INV_CARD);
2618   if (memcmp (app->serialno, tmp_sn, 16))
2619     return gpg_error (GPG_ERR_WRONG_CARD);
2620
2621   /* Yes, there is a race conditions: The user might pull the card
2622      right here and we won't notice that.  However this is not a
2623      problem and the check above is merely for a graceful failure
2624      between operations. */
2625
2626   if (admin_pin)
2627     {
2628       void *relptr;
2629       unsigned char *value;
2630       size_t valuelen;
2631       int count;
2632       
2633       relptr = get_one_do (app, 0x00C4, &value, &valuelen, NULL);
2634       if (!relptr || valuelen < 7)
2635         {
2636           log_error (_("error retrieving CHV status from card\n"));
2637           xfree (relptr);
2638           return gpg_error (GPG_ERR_CARD);
2639         }
2640       count = value[6];
2641       xfree (relptr);
2642
2643       if (!count)
2644         {
2645           log_info (_("card is permanently locked!\n"));
2646           return gpg_error (GPG_ERR_BAD_PIN);
2647         }
2648       else if (value[6] < 3)
2649         {
2650           log_info (_("verification of Admin PIN is currently prohibited "
2651                       "through this command\n"));
2652           return gpg_error (GPG_ERR_GENERAL);
2653         }
2654
2655       app->did_chv3 = 0; /* Force verification.  */
2656       return verify_chv3 (app, pincb, pincb_arg);
2657     }
2658   else
2659     return verify_chv2 (app, pincb, pincb_arg);
2660 }
2661
2662
2663
2664
2665 /* Select the OpenPGP application on the card in SLOT.  This function
2666    must be used before any other OpenPGP application functions. */
2667 gpg_error_t
2668 app_select_openpgp (app_t app)
2669 {
2670   static char const aid[] = { 0xD2, 0x76, 0x00, 0x01, 0x24, 0x01 };
2671   int slot = app->slot;
2672   int rc;
2673   unsigned char *buffer;
2674   size_t buflen;
2675   void *relptr;
2676   
2677   /* Note that the card can't cope with P2=0xCO, thus we need to pass a
2678      special flag value. */
2679   rc = iso7816_select_application (slot, aid, sizeof aid, 0x0001);
2680   if (!rc)
2681     {
2682       unsigned int manufacturer;
2683
2684       app->apptype = "OPENPGP";
2685
2686       app->did_chv1 = 0;
2687       app->did_chv2 = 0;
2688       app->did_chv3 = 0;
2689       app->app_local = NULL;
2690
2691       /* The OpenPGP card returns the serial number as part of the
2692          AID; because we prefer to use OpenPGP serial numbers, we
2693          replace a possibly already set one from a EF.GDO with this
2694          one.  Note, that for current OpenPGP cards, no EF.GDO exists
2695          and thus it won't matter at all. */
2696       rc = iso7816_get_data (slot, 0x004F, &buffer, &buflen);
2697       if (rc)
2698         goto leave;
2699       if (opt.verbose)
2700         {
2701           log_info ("AID: ");
2702           log_printhex ("", buffer, buflen);
2703         }
2704
2705       app->card_version = buffer[6] << 8;
2706       app->card_version |= buffer[7];
2707       manufacturer = (buffer[8]<<8 | buffer[9]);
2708
2709       xfree (app->serialno);
2710       app->serialno = buffer;
2711       app->serialnolen = buflen;
2712       buffer = NULL;
2713       app->app_local = xtrycalloc (1, sizeof *app->app_local);
2714       if (!app->app_local)
2715         {
2716           rc = gpg_error (gpg_err_code_from_errno (errno));
2717           goto leave;
2718         }
2719
2720       relptr = get_one_do (app, 0x00C4, &buffer, &buflen, NULL);
2721       if (!relptr)
2722         {
2723           log_error (_("can't access %s - invalid OpenPGP card?\n"),
2724                      "CHV Status Bytes");
2725           goto leave;
2726         }
2727       app->force_chv1 = (buflen && *buffer == 0);
2728       xfree (relptr);
2729
2730       relptr = get_one_do (app, 0x00C0, &buffer, &buflen, NULL);
2731       if (!relptr)
2732         {
2733           log_error (_("can't access %s - invalid OpenPGP card?\n"),
2734                      "Extended Capability Flags" );
2735           goto leave;
2736         }
2737       if (buflen)
2738         {
2739           app->app_local->extcap.get_challenge    = !!(*buffer & 0x40);
2740           app->app_local->extcap.key_import       = !!(*buffer & 0x20);
2741           app->app_local->extcap.change_force_chv = !!(*buffer & 0x10);
2742           app->app_local->extcap.private_dos      = !!(*buffer & 0x08);
2743         }
2744       xfree (relptr);
2745       
2746       /* Some of the first cards accidently don't set the
2747          CHANGE_FORCE_CHV bit but allow it anyway. */
2748       if (app->card_version <= 0x0100 && manufacturer == 1)
2749         app->app_local->extcap.change_force_chv = 1;
2750
2751       parse_login_data (app);
2752
2753       if (opt.verbose > 1)
2754         dump_all_do (slot);
2755
2756       app->fnc.deinit = do_deinit;
2757       app->fnc.learn_status = do_learn_status;
2758       app->fnc.readkey = do_readkey;
2759       app->fnc.getattr = do_getattr;
2760       app->fnc.setattr = do_setattr;
2761       app->fnc.writekey = do_writekey;
2762       app->fnc.genkey = do_genkey;
2763       app->fnc.sign = do_sign;
2764       app->fnc.auth = do_auth;
2765       app->fnc.decipher = do_decipher;
2766       app->fnc.change_pin = do_change_pin;
2767       app->fnc.check_pin = do_check_pin;
2768    }
2769
2770 leave:
2771   if (rc)
2772     do_deinit (app);
2773   return rc;
2774 }
2775
2776
2777