b6e6a3565c5787cb14aa70c493ccb5e3ff57563f
[gnupg.git] / scd / app-openpgp.c
1 /* app-openpgp.c - The OpenPGP card application.
2  * Copyright (C) 2003, 2004, 2005, 2007, 2008,
3  *               2009 Free Software Foundation, Inc.
4  *
5  * This file is part of GnuPG.
6  *
7  * GnuPG is free software; you can redistribute it and/or modify
8  * it under the terms of the GNU General Public License as published by
9  * the Free Software Foundation; either version 3 of the License, or
10  * (at your option) any later version.
11  *
12  * GnuPG is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15  * GNU General Public License for more details.
16  *
17  * You should have received a copy of the GNU General Public License
18  * along with this program; if not, see <http://www.gnu.org/licenses/>.
19  *
20  * $Id$
21  */
22
23 /* Some notes:
24
25    CHV means Card Holder Verification and is nothing else than a PIN
26    or password.  That term seems to have been used originally with GSM
27    cards.  Version v2 of the specs changes the term to the clearer
28    term PW for password.  We use the terms here interchangeable
29    because we do not want to change existing strings i18n wise.
30
31    Version 2 of the specs also drops the separate PW2 which was
32    required in v1 due to ISO requirements.  It is now possible to have
33    one physical PW but two reference to it so that they can be
34    individually be verified (e.g. to implement a forced verification
35    for one key).  Thus you will noticed the use of PW2 with the verify
36    command but not with change_reference_data because the latter
37    operates directly on the physical PW.
38
39    The Reset Code (RC) as implemented by v2 cards uses the same error
40    counter as the PW2 of v1 cards.  By default no RC is set and thus
41    that error counter is set to 0.  After setting the RC the error
42    counter will be initialized to 3.
43
44  */
45
46 #include <config.h>
47 #include <errno.h>
48 #include <stdio.h>
49 #include <stdlib.h>
50 #include <string.h>
51 #include <assert.h>
52 #include <time.h>
53
54 #if GNUPG_MAJOR_VERSION == 1
55 /* This is used with GnuPG version < 1.9.  The code has been source
56    copied from the current GnuPG >= 1.9  and is maintained over
57    there. */
58 #include "options.h"
59 #include "errors.h"
60 #include "memory.h"
61 #include "util.h"
62 #include "cardglue.h"
63 #else /* GNUPG_MAJOR_VERSION != 1 */
64 #include "scdaemon.h"
65 #endif /* GNUPG_MAJOR_VERSION != 1 */
66
67 #include "i18n.h"
68 #include "iso7816.h"
69 #include "app-common.h"
70 #include "tlv.h"
71
72
73 /* A table describing the DOs of the card.  */
74 static struct {
75   int tag;
76   int constructed;
77   int get_from;  /* Constructed DO with this DO or 0 for direct access. */
78   int binary;
79   int dont_cache;
80   int flush_on_error;
81   int get_immediate_in_v11; /* Enable a hack to bypass the cache of
82                                this data object if it is used in 1.1
83                                and later versions of the card.  This
84                                does not work with composite DO and is
85                                currently only useful for the CHV
86                                status bytes. */
87   char *desc;
88 } data_objects[] = {
89   { 0x005E, 0,    0, 1, 0, 0, 0, "Login Data" },
90   { 0x5F50, 0,    0, 0, 0, 0, 0, "URL" },
91   { 0x5F52, 0,    0, 1, 0, 0, 0, "Historical Bytes" },
92   { 0x0065, 1,    0, 1, 0, 0, 0, "Cardholder Related Data"},
93   { 0x005B, 0, 0x65, 0, 0, 0, 0, "Name" },
94   { 0x5F2D, 0, 0x65, 0, 0, 0, 0, "Language preferences" },
95   { 0x5F35, 0, 0x65, 0, 0, 0, 0, "Sex" },
96   { 0x006E, 1,    0, 1, 0, 0, 0, "Application Related Data" },
97   { 0x004F, 0, 0x6E, 1, 0, 0, 0, "AID" },
98   { 0x0073, 1,    0, 1, 0, 0, 0, "Discretionary Data Objects" },
99   { 0x0047, 0, 0x6E, 1, 1, 0, 0, "Card Capabilities" },
100   { 0x00C0, 0, 0x6E, 1, 1, 0, 0, "Extended Card Capabilities" },
101   { 0x00C1, 0, 0x6E, 1, 1, 0, 0, "Algorithm Attributes Signature" },
102   { 0x00C2, 0, 0x6E, 1, 1, 0, 0, "Algorithm Attributes Decryption" },
103   { 0x00C3, 0, 0x6E, 1, 1, 0, 0, "Algorithm Attributes Authentication" },
104   { 0x00C4, 0, 0x6E, 1, 0, 1, 1, "CHV Status Bytes" },
105   { 0x00C5, 0, 0x6E, 1, 0, 0, 0, "Fingerprints" },
106   { 0x00C6, 0, 0x6E, 1, 0, 0, 0, "CA Fingerprints" },
107   { 0x00CD, 0, 0x6E, 1, 0, 0, 0, "Generation time" },
108   { 0x007A, 1,    0, 1, 0, 0, 0, "Security Support Template" },
109   { 0x0093, 0, 0x7A, 1, 1, 0, 0, "Digital Signature Counter" },
110   { 0x0101, 0,    0, 0, 0, 0, 0, "Private DO 1"},
111   { 0x0102, 0,    0, 0, 0, 0, 0, "Private DO 2"},
112   { 0x0103, 0,    0, 0, 0, 0, 0, "Private DO 3"},
113   { 0x0104, 0,    0, 0, 0, 0, 0, "Private DO 4"},
114   { 0x7F21, 1,    0, 1, 0, 0, 0, "Cardholder certificate"},
115   { 0 }
116 };
117
118
119 /* The format of RSA private keys.  */
120 typedef enum
121   { 
122     RSA_UNKNOWN_FMT,
123     RSA_STD,
124     RSA_STD_N,
125     RSA_CRT,
126     RSA_CRT_N
127   } 
128 rsa_key_format_t;
129
130
131 /* One cache item for DOs.  */
132 struct cache_s {
133   struct cache_s *next;
134   int tag;
135   size_t length;
136   unsigned char data[1];
137 };
138
139
140 /* Object with application (i.e. OpenPGP card) specific data.  */
141 struct app_local_s {
142   /* A linked list with cached DOs.  */
143   struct cache_s *cache;
144   
145   /* Keep track of the public keys.  */
146   struct
147   {
148     int read_done;   /* True if we have at least tried to read them.  */
149     unsigned char *key; /* This is a malloced buffer with a canonical
150                            encoded S-expression encoding a public
151                            key. Might be NULL if key is not
152                            available.  */
153     size_t keylen;      /* The length of the above S-expression.  This
154                            is usullay only required for cross checks
155                            because the length of an S-expression is
156                            implicitly available.  */
157   } pk[3];
158
159   unsigned char status_indicator; /* The card status indicator.  */
160
161   /* Keep track of the ISO card capabilities.  */
162   struct
163   {
164     unsigned int cmd_chaining:1;  /* Command chaining is supported.  */
165     unsigned int ext_lc_le:1;     /* Extended Lc and Le are supported.  */
166   } cardcap;
167
168   /* Keep track of extended card capabilities.  */
169   struct 
170   {
171     unsigned int is_v2:1;              /* This is a v2.0 compatible card.  */
172     unsigned int get_challenge:1;
173     unsigned int key_import:1;
174     unsigned int change_force_chv:1;
175     unsigned int private_dos:1;
176     unsigned int algo_attr_change:1;   /* Algorithm attributes changeable.  */
177     unsigned int sm_supported:1;       /* Secure Messaging is supported.  */
178     unsigned int sm_aes128:1;          /* Use AES-128 for SM.  */
179     unsigned int max_certlen_3:16;
180     unsigned int max_get_challenge:16; /* Maximum size for get_challenge.  */
181     unsigned int max_cmd_data:16;      /* Maximum data size for a command.  */
182     unsigned int max_rsp_data:16;      /* Maximum size of a response.  */
183   } extcap;
184
185   /* Flags used to control the application.  */
186   struct
187   {
188     unsigned int no_sync:1;   /* Do not sync CHV1 and CHV2 */
189     unsigned int def_chv2:1;  /* Use 123456 for CHV2.  */
190   } flags;
191
192   struct
193   {
194     unsigned int n_bits;     /* Size of the modulus in bits.  The rest
195                                 of this strucuire is only valid if
196                                 this is not 0.  */
197     unsigned int e_bits;     /* Size of the public exponent in bits.  */
198     rsa_key_format_t format;  
199   } keyattr[3];
200
201 };
202
203
204
205 /***** Local prototypes  *****/
206 static unsigned long convert_sig_counter_value (const unsigned char *value,
207                                                 size_t valuelen);
208 static unsigned long get_sig_counter (app_t app);
209 static gpg_error_t do_auth (app_t app, const char *keyidstr,
210                             gpg_error_t (*pincb)(void*, const char *, char **),
211                             void *pincb_arg,
212                             const void *indata, size_t indatalen,
213                             unsigned char **outdata, size_t *outdatalen);
214
215
216
217
218 \f
219 /* Deconstructor. */
220 static void
221 do_deinit (app_t app)
222 {
223   if (app && app->app_local)
224     {
225       struct cache_s *c, *c2;
226       int i;
227
228       for (c = app->app_local->cache; c; c = c2)
229         {
230           c2 = c->next;
231           xfree (c);
232         }
233
234       for (i=0; i < DIM (app->app_local->pk); i++)
235         {
236           xfree (app->app_local->pk[i].key);
237           app->app_local->pk[i].read_done = 0;
238         }
239       xfree (app->app_local);
240       app->app_local = NULL;
241     }
242 }
243
244
245 /* Wrapper around iso7816_get_data which first tries to get the data
246    from the cache.  With GET_IMMEDIATE passed as true, the cache is
247    bypassed. */
248 static gpg_error_t
249 get_cached_data (app_t app, int tag, 
250                  unsigned char **result, size_t *resultlen,
251                  int get_immediate)
252 {
253   gpg_error_t err;
254   int i;
255   unsigned char *p;
256   size_t len;
257   struct cache_s *c;
258
259   *result = NULL;
260   *resultlen = 0;
261
262   if (!get_immediate)
263     {
264       for (c=app->app_local->cache; c; c = c->next)
265         if (c->tag == tag)
266           {
267             if(c->length)
268               {
269                 p = xtrymalloc (c->length);
270                 if (!p)
271                   return gpg_error (gpg_err_code_from_errno (errno));
272                 memcpy (p, c->data, c->length);
273                 *result = p;
274               }
275             
276             *resultlen = c->length;
277             
278             return 0;
279           }
280     }
281   
282   err = iso7816_get_data (app->slot, tag, &p, &len);
283   if (err)
284     return err;
285   *result = p;
286   *resultlen = len;
287
288   /* Check whether we should cache this object. */
289   if (get_immediate)
290     return 0;
291
292   for (i=0; data_objects[i].tag; i++)
293     if (data_objects[i].tag == tag)
294       {
295         if (data_objects[i].dont_cache)
296           return 0;
297         break;
298       }
299
300   /* Okay, cache it. */
301   for (c=app->app_local->cache; c; c = c->next)
302     assert (c->tag != tag);
303   
304   c = xtrymalloc (sizeof *c + len);
305   if (c)
306     {
307       memcpy (c->data, p, len);
308       c->length = len;
309       c->tag = tag;
310       c->next = app->app_local->cache;
311       app->app_local->cache = c;
312     }
313
314   return 0;
315 }
316
317 /* Remove DO at TAG from the cache. */
318 static void
319 flush_cache_item (app_t app, int tag)
320 {
321   struct cache_s *c, *cprev;
322   int i;
323
324   if (!app->app_local)
325     return;
326
327   for (c=app->app_local->cache, cprev=NULL; c ; cprev=c, c = c->next)
328     if (c->tag == tag)
329       {
330         if (cprev)
331           cprev->next = c->next;
332         else
333           app->app_local->cache = c->next;
334         xfree (c);
335
336         for (c=app->app_local->cache; c ; c = c->next)
337           {
338             assert (c->tag != tag); /* Oops: duplicated entry. */
339           }
340         return;
341       }
342
343   /* Try again if we have an outer tag. */
344   for (i=0; data_objects[i].tag; i++)
345     if (data_objects[i].tag == tag && data_objects[i].get_from
346         && data_objects[i].get_from != tag)
347       flush_cache_item (app, data_objects[i].get_from);
348 }
349
350 /* Flush all entries from the cache which might be out of sync after
351    an error. */
352 static void
353 flush_cache_after_error (app_t app)
354 {
355   int i;
356
357   for (i=0; data_objects[i].tag; i++)
358     if (data_objects[i].flush_on_error)
359       flush_cache_item (app, data_objects[i].tag);
360 }
361
362
363 /* Flush the entire cache. */
364 static void
365 flush_cache (app_t app)
366 {
367   if (app && app->app_local)
368     {
369       struct cache_s *c, *c2;
370
371       for (c = app->app_local->cache; c; c = c2)
372         {
373           c2 = c->next;
374           xfree (c);
375         }
376       app->app_local->cache = NULL;
377     }
378 }
379
380
381 /* Get the DO identified by TAG from the card in SLOT and return a
382    buffer with its content in RESULT and NBYTES.  The return value is
383    NULL if not found or a pointer which must be used to release the
384    buffer holding value. */
385 static void *
386 get_one_do (app_t app, int tag, unsigned char **result, size_t *nbytes,
387             int *r_rc)
388 {
389   int rc, i;
390   unsigned char *buffer;
391   size_t buflen;
392   unsigned char *value;
393   size_t valuelen;
394   int dummyrc;
395
396   if (!r_rc)
397     r_rc = &dummyrc;
398
399   *result = NULL;
400   *nbytes = 0;
401   *r_rc = 0;
402   for (i=0; data_objects[i].tag && data_objects[i].tag != tag; i++)
403     ;
404
405   if (app->card_version > 0x0100 && data_objects[i].get_immediate_in_v11)
406     {
407       rc = iso7816_get_data (app->slot, tag, &buffer, &buflen);
408       if (rc)
409         {
410           *r_rc = rc;
411           return NULL;
412         }
413       *result = buffer;
414       *nbytes = buflen;
415       return buffer;
416     }
417
418   value = NULL;
419   rc = -1;
420   if (data_objects[i].tag && data_objects[i].get_from)
421     {
422       rc = get_cached_data (app, data_objects[i].get_from,
423                             &buffer, &buflen,
424                             (data_objects[i].dont_cache 
425                              || data_objects[i].get_immediate_in_v11));
426       if (!rc)
427         {
428           const unsigned char *s;
429
430           s = find_tlv_unchecked (buffer, buflen, tag, &valuelen);
431           if (!s)
432             value = NULL; /* not found */
433           else if (valuelen > buflen - (s - buffer))
434             {
435               log_error ("warning: constructed DO too short\n");
436               value = NULL;
437               xfree (buffer); buffer = NULL;
438             }
439           else
440             value = buffer + (s - buffer);
441         }
442     }
443
444   if (!value) /* Not in a constructed DO, try simple. */
445     {
446       rc = get_cached_data (app, tag, &buffer, &buflen,
447                             (data_objects[i].dont_cache 
448                              || data_objects[i].get_immediate_in_v11));
449       if (!rc)
450         {
451           value = buffer;
452           valuelen = buflen;
453         }
454     }
455
456   if (!rc)
457     {
458       *nbytes = valuelen;
459       *result = value;
460       return buffer;
461     }
462   *r_rc = rc;
463   return NULL;
464 }
465
466
467 static void
468 dump_all_do (int slot)
469 {
470   int rc, i, j;
471   unsigned char *buffer;
472   size_t buflen;
473   
474   for (i=0; data_objects[i].tag; i++)
475     {
476       if (data_objects[i].get_from)
477         continue;
478
479       rc = iso7816_get_data (slot, data_objects[i].tag, &buffer, &buflen);
480       if (gpg_err_code (rc) == GPG_ERR_NO_OBJ)
481         ;
482       else if (rc) 
483         log_info ("DO `%s' not available: %s\n",
484                   data_objects[i].desc, gpg_strerror (rc));
485       else
486         {
487           if (data_objects[i].binary)
488             {
489               log_info ("DO `%s': ", data_objects[i].desc);
490               log_printhex ("", buffer, buflen);
491             }
492           else
493             log_info ("DO `%s': `%.*s'\n",
494                       data_objects[i].desc,
495                       (int)buflen, buffer); /* FIXME: sanitize */
496
497           if (data_objects[i].constructed)
498             {
499               for (j=0; data_objects[j].tag; j++)
500                 {
501                   const unsigned char *value;
502                   size_t valuelen;
503                   
504                   if (j==i || data_objects[i].tag != data_objects[j].get_from)
505                     continue;
506                   value = find_tlv_unchecked (buffer, buflen,
507                                               data_objects[j].tag, &valuelen);
508                   if (!value)
509                     ; /* not found */
510                   else if (valuelen > buflen - (value - buffer))
511                     log_error ("warning: constructed DO too short\n");
512                   else
513                     {
514                       if (data_objects[j].binary)
515                         {
516                           log_info ("DO `%s': ", data_objects[j].desc);
517                           if (valuelen > 200)
518                             log_info ("[%u]\n", (unsigned int)valuelen);
519                           else
520                             log_printhex ("", value, valuelen);
521                         }
522                       else
523                         log_info ("DO `%s': `%.*s'\n",
524                                   data_objects[j].desc,
525                                   (int)valuelen, value); /* FIXME: sanitize */
526                     }
527                 }
528             }
529         }
530       xfree (buffer); buffer = NULL;
531     }
532 }
533
534
535 /* Count the number of bits, assuming the A represents an unsigned big
536    integer of length LEN bytes. */
537 static unsigned int
538 count_bits (const unsigned char *a, size_t len)
539 {
540   unsigned int n = len * 8;
541   int i;
542
543   for (; len && !*a; len--, a++, n -=8)
544     ;
545   if (len)
546     {
547       for (i=7; i && !(*a & (1<<i)); i--)
548         n--;
549     }
550   return n;
551 }
552
553 /* GnuPG makes special use of the login-data DO, this function parses
554    the login data to store the flags for later use.  It may be called
555    at any time and should be called after changing the login-data DO.
556
557    Everything up to a LF is considered a mailbox or account name.  If
558    the first LF is followed by DC4 (0x14) control sequence are
559    expected up to the next LF.  Control sequences are separated by FS
560    (0x18) and consist of key=value pairs.  There is one key defined:
561
562     F=<flags>
563
564     Were FLAGS is a plain hexadecimal number representing flag values.
565     The lsb is here the rightmost bit.  Defined flags bits are:
566
567       Bit 0 = CHV1 and CHV2 are not syncronized
568       Bit 1 = CHV2 has been been set to the default PIN of "123456"
569               (this implies that bit 0 is also set).
570
571 */
572 static void
573 parse_login_data (app_t app)
574 {
575   unsigned char *buffer, *p;
576   size_t buflen, len;
577   void *relptr;
578
579   /* Set defaults.  */
580   app->app_local->flags.no_sync = 0;
581   app->app_local->flags.def_chv2 = 0;
582
583   /* Read the DO.  */
584   relptr = get_one_do (app, 0x005E, &buffer, &buflen, NULL);
585   if (!relptr)
586     return; /* Ooops. */
587   for (; buflen; buflen--, buffer++)
588     if (*buffer == '\n')
589       break;
590   if (buflen < 2 || buffer[1] != '\x14')
591     return; /* No control sequences.  */
592   buflen--;
593   buffer++;
594   do
595     {
596       buflen--;
597       buffer++;
598       if (buflen > 1 && *buffer == 'F' && buffer[1] == '=')
599         {
600           /* Flags control sequence found.  */
601           int lastdig = 0;
602
603           /* For now we are only interested in the last digit, so skip
604              any leading digits but bail out on invalid characters. */
605           for (p=buffer+2, len = buflen-2; len && hexdigitp (p); p++, len--)
606             lastdig = xtoi_1 (p);
607           if (len && !(*p == '\n' || *p == '\x18'))
608             goto next;  /* Invalid characters in field.  */
609           app->app_local->flags.no_sync = !!(lastdig & 1);
610           app->app_local->flags.def_chv2 = (lastdig & 3) == 3;
611         }
612     next:
613       for (; buflen && *buffer != '\x18'; buflen--, buffer++)
614         if (*buffer == '\n')
615           buflen = 1; 
616     }
617   while (buflen);
618
619   xfree (relptr);
620 }
621
622 /* Note, that FPR must be at least 20 bytes. */
623 static gpg_error_t 
624 store_fpr (int slot, int keynumber, u32 timestamp,
625            const unsigned char *m, size_t mlen,
626            const unsigned char *e, size_t elen, 
627            unsigned char *fpr, unsigned int card_version)
628 {
629   unsigned int n, nbits;
630   unsigned char *buffer, *p;
631   int rc;
632   
633   for (; mlen && !*m; mlen--, m++) /* strip leading zeroes */
634     ;
635   for (; elen && !*e; elen--, e++) /* strip leading zeroes */
636     ;
637
638   n = 6 + 2 + mlen + 2 + elen;
639   p = buffer = xtrymalloc (3 + n);
640   if (!buffer)
641     return gpg_error_from_syserror ();
642   
643   *p++ = 0x99;     /* ctb */
644   *p++ = n >> 8;   /* 2 byte length header */
645   *p++ = n;
646   *p++ = 4;        /* key packet version */
647   *p++ = timestamp >> 24;
648   *p++ = timestamp >> 16;
649   *p++ = timestamp >>  8;
650   *p++ = timestamp;
651   *p++ = 1; /* RSA */
652   nbits = count_bits (m, mlen);
653   *p++ = nbits >> 8;
654   *p++ = nbits;
655   memcpy (p, m, mlen); p += mlen;
656   nbits = count_bits (e, elen);
657   *p++ = nbits >> 8;
658   *p++ = nbits;
659   memcpy (p, e, elen); p += elen;
660     
661   gcry_md_hash_buffer (GCRY_MD_SHA1, fpr, buffer, n+3);
662
663   xfree (buffer);
664
665   rc = iso7816_put_data (slot, 0, 
666                          (card_version > 0x0007? 0xC7 : 0xC6)
667                          + keynumber, fpr, 20);
668   if (rc)
669     log_error (_("failed to store the fingerprint: %s\n"),gpg_strerror (rc));
670
671   if (!rc && card_version > 0x0100)
672     {
673       unsigned char buf[4];
674
675       buf[0] = timestamp >> 24;
676       buf[1] = timestamp >> 16;
677       buf[2] = timestamp >>  8;
678       buf[3] = timestamp;
679
680       rc = iso7816_put_data (slot, 0, 0xCE + keynumber, buf, 4);
681       if (rc)
682         log_error (_("failed to store the creation date: %s\n"),
683                    gpg_strerror (rc));
684     }
685
686   return rc;
687 }
688
689        
690 static void
691 send_fpr_if_not_null (ctrl_t ctrl, const char *keyword,
692                       int number, const unsigned char *fpr)
693 {                      
694   int i;
695   char buf[41];
696   char numbuf[25];
697
698   for (i=0; i < 20 && !fpr[i]; i++)
699     ;
700   if (i==20)
701     return; /* All zero. */
702   bin2hex (fpr, 20, buf);
703   if (number == -1)
704     *numbuf = 0; /* Don't print the key number */
705   else
706     sprintf (numbuf, "%d", number);
707   send_status_info (ctrl, keyword,
708                     numbuf, (size_t)strlen(numbuf),
709                     buf, (size_t)strlen (buf), NULL, 0);
710 }
711
712 static void
713 send_fprtime_if_not_null (ctrl_t ctrl, const char *keyword,
714                           int number, const unsigned char *stamp)
715 {                      
716   char numbuf1[50], numbuf2[50];
717   unsigned long value;
718
719   value = (stamp[0] << 24) | (stamp[1]<<16) | (stamp[2]<<8) | stamp[3];
720   if (!value)
721     return;
722   sprintf (numbuf1, "%d", number);
723   sprintf (numbuf2, "%lu", value);
724   send_status_info (ctrl, keyword,
725                     numbuf1, (size_t)strlen(numbuf1),
726                     numbuf2, (size_t)strlen(numbuf2), NULL, 0);
727 }
728
729 static void
730 send_key_data (ctrl_t ctrl, const char *name, 
731                const unsigned char *a, size_t alen)
732 {
733   char *buf;
734   
735   buf = bin2hex (a, alen, NULL);
736   if (!buf)
737     {
738       log_error ("memory allocation error in send_key_data\n");
739       return;
740     }
741
742   send_status_info (ctrl, "KEY-DATA",
743                     name, (size_t)strlen(name), 
744                     buf, (size_t)strlen (buf),
745                     NULL, 0);
746   xfree (buf);
747 }
748
749 /* Implement the GETATTR command.  This is similar to the LEARN
750    command but returns just one value via the status interface. */
751 static gpg_error_t 
752 do_getattr (app_t app, ctrl_t ctrl, const char *name)
753 {
754   static struct {
755     const char *name;
756     int tag;
757     int special;
758   } table[] = {
759     { "DISP-NAME",    0x005B },
760     { "LOGIN-DATA",   0x005E },
761     { "DISP-LANG",    0x5F2D },
762     { "DISP-SEX",     0x5F35 },
763     { "PUBKEY-URL",   0x5F50 },
764     { "KEY-FPR",      0x00C5, 3 },
765     { "KEY-TIME",     0x00CD, 4 },
766     { "CA-FPR",       0x00C6, 3 },
767     { "CHV-STATUS",   0x00C4, 1 }, 
768     { "SIG-COUNTER",  0x0093, 2 },
769     { "SERIALNO",     0x004F, -1 },
770     { "AID",          0x004F },
771     { "EXTCAP",       0x0000, -2 },
772     { "PRIVATE-DO-1", 0x0101 },
773     { "PRIVATE-DO-2", 0x0102 },
774     { "PRIVATE-DO-3", 0x0103 },
775     { "PRIVATE-DO-4", 0x0104 },
776     { "$AUTHKEYID",   0x0000, -3 },
777     { "$DISPSERIALNO",0x0000, -4 },
778     { NULL, 0 }
779   };
780   int idx, i, rc;
781   void *relptr;
782   unsigned char *value;
783   size_t valuelen;
784
785   for (idx=0; table[idx].name && strcmp (table[idx].name, name); idx++)
786     ;
787   if (!table[idx].name)
788     return gpg_error (GPG_ERR_INV_NAME); 
789   
790   if (table[idx].special == -1)
791     {
792       /* The serial number is very special.  We could have used the
793          AID DO to retrieve it, but we have it already in the app
794          context and the stamp argument is required anyway which we
795          can't by other means. The AID DO is available anyway but not
796          hex formatted. */
797       char *serial;
798       time_t stamp;
799       char tmp[50];
800
801       if (!app_get_serial_and_stamp (app, &serial, &stamp))
802         {
803           sprintf (tmp, "%lu", (unsigned long)stamp);
804           send_status_info (ctrl, "SERIALNO",
805                             serial, strlen (serial),
806                             tmp, strlen (tmp),
807                             NULL, 0);
808           xfree (serial);
809         }
810       return 0;
811     }
812   if (table[idx].special == -2)
813     {
814       char tmp[50];
815
816       sprintf (tmp, "gc=%d ki=%d fc=%d pd=%d mcl3=%u", 
817                app->app_local->extcap.get_challenge,
818                app->app_local->extcap.key_import,
819                app->app_local->extcap.change_force_chv,
820                app->app_local->extcap.private_dos,
821                app->app_local->extcap.max_certlen_3);
822       send_status_info (ctrl, table[idx].name, tmp, strlen (tmp), NULL, 0);
823       return 0;
824     }
825   if (table[idx].special == -3)
826     {
827       char const tmp[] = "OPENPGP.3";
828       send_status_info (ctrl, table[idx].name, tmp, strlen (tmp), NULL, 0);
829       return 0;
830     }
831   if (table[idx].special == -4)
832     {
833       char *serial;
834       time_t stamp;
835     
836       if (!app_get_serial_and_stamp (app, &serial, &stamp))
837         {
838           if (strlen (serial) > 16+12)
839             {
840               send_status_info (ctrl, table[idx].name, serial+16, 12, NULL, 0);
841               xfree (serial);
842               return 0;
843             }
844           xfree (serial);
845         }
846       return gpg_error (GPG_ERR_INV_NAME); 
847     }
848
849   relptr = get_one_do (app, table[idx].tag, &value, &valuelen, &rc);
850   if (relptr)
851     {
852       if (table[idx].special == 1)
853         {
854           char numbuf[7*23];
855           
856           for (i=0,*numbuf=0; i < valuelen && i < 7; i++)
857             sprintf (numbuf+strlen (numbuf), " %d", value[i]); 
858           send_status_info (ctrl, table[idx].name,
859                             numbuf, strlen (numbuf), NULL, 0);
860         }
861       else if (table[idx].special == 2)
862         {
863           char numbuf[50];
864
865           sprintf (numbuf, "%lu", convert_sig_counter_value (value, valuelen));
866           send_status_info (ctrl, table[idx].name,
867                             numbuf, strlen (numbuf), NULL, 0);
868         }
869       else if (table[idx].special == 3)
870         {
871           if (valuelen >= 60)
872             for (i=0; i < 3; i++)
873               send_fpr_if_not_null (ctrl, table[idx].name, i+1, value+i*20);
874         }
875       else if (table[idx].special == 4)
876         {
877           if (valuelen >= 12)
878             for (i=0; i < 3; i++)
879               send_fprtime_if_not_null (ctrl, table[idx].name, i+1, value+i*4);
880         }
881       else
882         send_status_info (ctrl, table[idx].name, value, valuelen, NULL, 0);
883
884       xfree (relptr);
885     }
886   return rc;
887 }
888
889 /* Retrieve the fingerprint from the card inserted in SLOT and write
890    the according hex representation to FPR.  Caller must have provide
891    a buffer at FPR of least 41 bytes.  Returns 0 on success or an
892    error code. */
893 #if GNUPG_MAJOR_VERSION > 1
894 static gpg_error_t
895 retrieve_fpr_from_card (app_t app, int keyno, char *fpr)
896 {
897   gpg_error_t err = 0;
898   void *relptr;
899   unsigned char *value;
900   size_t valuelen;
901
902   assert (keyno >=0 && keyno <= 2);
903
904   relptr = get_one_do (app, 0x00C5, &value, &valuelen, NULL);
905   if (relptr && valuelen >= 60)
906     bin2hex (value+keyno*20, 20, fpr);
907   else
908     err = gpg_error (GPG_ERR_NOT_FOUND);
909   xfree (relptr);
910   return err;
911 }
912 #endif /*GNUPG_MAJOR_VERSION > 1*/
913
914
915 /* Retrieve the public key material for the RSA key, whose fingerprint
916    is FPR, from gpg output, which can be read through the stream FP.
917    The RSA modulus will be stored at the address of M and MLEN, the
918    public exponent at E and ELEN.  Returns zero on success, an error
919    code on failure.  Caller must release the allocated buffers at M
920    and E if the function returns success.  */
921 #if GNUPG_MAJOR_VERSION > 1
922 static gpg_error_t
923 retrieve_key_material (FILE *fp, const char *hexkeyid,
924                        const unsigned char **m, size_t *mlen,
925                        const unsigned char **e, size_t *elen)
926 {
927   gcry_error_t err = 0;
928   char *line = NULL;    /* read_line() buffer. */
929   size_t line_size = 0; /* Helper for for read_line. */
930   int found_key = 0;    /* Helper to find a matching key. */
931   unsigned char *m_new = NULL;
932   unsigned char *e_new = NULL;
933   size_t m_new_n = 0;
934   size_t e_new_n = 0;
935
936   /* Loop over all records until we have found the subkey
937      corresponding to the fingerprint. Inm general the first record
938      should be the pub record, but we don't rely on that.  Given that
939      we only need to look at one key, it is sufficient to compare the
940      keyid so that we don't need to look at "fpr" records. */
941   for (;;)
942     {
943       char *p;
944       char *fields[6];
945       int nfields;
946       size_t max_length;
947       gcry_mpi_t mpi;
948       int i;
949
950       max_length = 4096;
951       i = read_line (fp, &line, &line_size, &max_length);
952       if (!i)
953         break; /* EOF. */
954       if (i < 0)
955         {
956           err = gpg_error_from_syserror ();
957           goto leave; /* Error. */
958         }
959       if (!max_length)
960         {
961           err = gpg_error (GPG_ERR_TRUNCATED);
962           goto leave;  /* Line truncated - we better stop processing.  */
963         }
964
965       /* Parse the line into fields. */
966       for (nfields=0, p=line; p && nfields < DIM (fields); nfields++)
967         {
968           fields[nfields] = p;
969           p = strchr (p, ':');
970           if (p)
971             *(p++) = 0;
972         }
973       if (!nfields)
974         continue; /* No fields at all - skip line.  */
975
976       if (!found_key)
977         {
978           if ( (!strcmp (fields[0], "sub") || !strcmp (fields[0], "pub") )
979                && nfields > 4 && !strcmp (fields[4], hexkeyid))
980             found_key = 1;
981           continue;
982         }
983       
984       if ( !strcmp (fields[0], "sub") || !strcmp (fields[0], "pub") )
985         break; /* Next key - stop.  */
986
987       if ( strcmp (fields[0], "pkd") )
988         continue; /* Not a key data record.  */
989       i = 0; /* Avoid erroneous compiler warning. */
990       if ( nfields < 4 || (i = atoi (fields[1])) < 0 || i > 1
991            || (!i && m_new) || (i && e_new))
992         {
993           err = gpg_error (GPG_ERR_GENERAL);
994           goto leave; /* Error: Invalid key data record or not an RSA key.  */
995         }
996       
997       err = gcry_mpi_scan (&mpi, GCRYMPI_FMT_HEX, fields[3], 0, NULL);
998       if (err)
999         mpi = NULL;
1000       else if (!i)
1001         err = gcry_mpi_aprint (GCRYMPI_FMT_STD, &m_new, &m_new_n, mpi);
1002       else
1003         err = gcry_mpi_aprint (GCRYMPI_FMT_STD, &e_new, &e_new_n, mpi);
1004       gcry_mpi_release (mpi);
1005       if (err)
1006         goto leave;
1007     }
1008   
1009   if (m_new && e_new)
1010     {
1011       *m = m_new;
1012       *mlen = m_new_n;
1013       m_new = NULL;
1014       *e = e_new;
1015       *elen = e_new_n;
1016       e_new = NULL;
1017     }
1018   else
1019     err = gpg_error (GPG_ERR_GENERAL);
1020
1021  leave:
1022   xfree (m_new);
1023   xfree (e_new);
1024   xfree (line);
1025   return err;
1026 }
1027 #endif /*GNUPG_MAJOR_VERSION > 1*/
1028
1029
1030 /* Get the public key for KEYNO and store it as an S-expresion with
1031    the APP handle.  On error that field gets cleared.  If we already
1032    know about the public key we will just return.  Note that this does
1033    not mean a key is available; this is soley indicated by the
1034    presence of the app->app_local->pk[KEYNO-1].key field.
1035
1036    Note that GnuPG 1.x does not need this and it would be too time
1037    consuming to send it just for the fun of it. However, given that we
1038    use the same code in gpg 1.4, we can't use the gcry S-expresion
1039    here but need to open encode it. */
1040 #if GNUPG_MAJOR_VERSION > 1
1041 static gpg_error_t
1042 get_public_key (app_t app, int keyno)
1043 {
1044   gpg_error_t err = 0;
1045   unsigned char *buffer;
1046   const unsigned char *keydata, *m, *e;
1047   size_t buflen, keydatalen, mlen, elen;
1048   unsigned char *mbuf = NULL;
1049   unsigned char *ebuf = NULL;
1050   char *keybuf = NULL;
1051   char *keybuf_p;
1052
1053   if (keyno < 1 || keyno > 3)
1054     return gpg_error (GPG_ERR_INV_ID);
1055   keyno--;
1056
1057   /* Already cached? */
1058   if (app->app_local->pk[keyno].read_done)
1059     return 0;
1060
1061   xfree (app->app_local->pk[keyno].key);
1062   app->app_local->pk[keyno].key = NULL;
1063   app->app_local->pk[keyno].keylen = 0;
1064
1065   m = e = NULL; /* (avoid cc warning) */
1066
1067   if (app->card_version > 0x0100)
1068     {
1069       /* We may simply read the public key out of these cards.  */
1070       err = iso7816_read_public_key 
1071         (app->slot, (const unsigned char*)(keyno == 0? "\xB6" :
1072                                            keyno == 1? "\xB8" : "\xA4"),
1073          2,  
1074          &buffer, &buflen);
1075       if (err)
1076         {
1077           log_error (_("reading public key failed: %s\n"), gpg_strerror (err));
1078           goto leave;
1079         }
1080
1081       keydata = find_tlv (buffer, buflen, 0x7F49, &keydatalen);
1082       if (!keydata)
1083         {
1084           err = gpg_error (GPG_ERR_CARD);
1085           log_error (_("response does not contain the public key data\n"));
1086           goto leave;
1087         }
1088  
1089       m = find_tlv (keydata, keydatalen, 0x0081, &mlen);
1090       if (!m)
1091         {
1092           err = gpg_error (GPG_ERR_CARD);
1093           log_error (_("response does not contain the RSA modulus\n"));
1094           goto leave;
1095         }
1096       
1097
1098       e = find_tlv (keydata, keydatalen, 0x0082, &elen);
1099       if (!e)
1100         {
1101           err = gpg_error (GPG_ERR_CARD);
1102           log_error (_("response does not contain the RSA public exponent\n"));
1103           goto leave;
1104         }
1105
1106       /* Prepend numbers with a 0 if needed.  */
1107       if (mlen && (*m & 0x80))
1108         {
1109           mbuf = xtrymalloc ( mlen + 1);
1110           if (!mbuf)
1111             {
1112               err = gpg_error_from_syserror ();
1113               goto leave;
1114             }
1115           *mbuf = 0;
1116           memcpy (mbuf+1, m, mlen);
1117           mlen++;
1118           m = mbuf;
1119         }
1120       if (elen && (*e & 0x80))
1121         {
1122           ebuf = xtrymalloc ( elen + 1);
1123           if (!ebuf)
1124             {
1125               err = gpg_error_from_syserror ();
1126               goto leave;
1127             }
1128           *ebuf = 0;
1129           memcpy (ebuf+1, e, elen);
1130           elen++;
1131           e = ebuf;
1132         }
1133
1134     }
1135   else
1136     {
1137       /* Due to a design problem in v1.0 cards we can't get the public
1138          key out of these cards without doing a verify on CHV3.
1139          Clearly that is not an option and thus we try to locate the
1140          key using an external helper.
1141
1142          The helper we use here is gpg itself, which should know about
1143          the key in any case.  */
1144
1145       char fpr[41];
1146       char *hexkeyid;
1147       char *command = NULL;
1148       FILE *fp;
1149       int ret;
1150
1151       buffer = NULL; /* We don't need buffer.  */
1152
1153       err = retrieve_fpr_from_card (app, keyno, fpr);
1154       if (err)
1155         {
1156           log_error ("error while retrieving fpr from card: %s\n",
1157                      gpg_strerror (err));
1158           goto leave;
1159         }
1160       hexkeyid = fpr + 24;
1161
1162       ret = estream_asprintf (&command,
1163                               "gpg --list-keys --with-colons --with-key-data '%s'",
1164                               fpr);
1165       if (ret < 0)
1166         {
1167           err = gpg_error_from_syserror ();
1168           goto leave;
1169         }
1170
1171       fp = popen (command, "r");
1172       xfree (command);
1173       if (!fp)
1174         {
1175           err = gpg_error_from_syserror ();
1176           log_error ("running gpg failed: %s\n", gpg_strerror (err));
1177           goto leave;
1178         }
1179
1180       err = retrieve_key_material (fp, hexkeyid, &m, &mlen, &e, &elen);
1181       fclose (fp);
1182       if (err)
1183         {
1184           log_error ("error while retrieving key material through pipe: %s\n",
1185                      gpg_strerror (err));
1186           goto leave;
1187         }
1188     }
1189
1190   /* Allocate a buffer to construct the S-expression.  */
1191   /* FIXME: We should provide a generalized S-expression creation
1192      mechanism. */
1193   keybuf = xtrymalloc (50 + 2*35 + mlen + elen + 1);
1194   if (!keybuf)
1195     {
1196       err = gpg_error_from_syserror ();
1197       goto leave;
1198     }
1199   
1200   sprintf (keybuf, "(10:public-key(3:rsa(1:n%u:", (unsigned int) mlen);
1201   keybuf_p = keybuf + strlen (keybuf);
1202   memcpy (keybuf_p, m, mlen);
1203   keybuf_p += mlen;
1204   sprintf (keybuf_p, ")(1:e%u:", (unsigned int)elen);
1205   keybuf_p += strlen (keybuf_p);
1206   memcpy (keybuf_p, e, elen);
1207   keybuf_p += elen;
1208   strcpy (keybuf_p, ")))");
1209   keybuf_p += strlen (keybuf_p);
1210   
1211   app->app_local->pk[keyno].key = (unsigned char*)keybuf;
1212   app->app_local->pk[keyno].keylen = (keybuf_p - keybuf);
1213
1214  leave:
1215   /* Set a flag to indicate that we tried to read the key.  */
1216   app->app_local->pk[keyno].read_done = 1;
1217
1218   xfree (buffer);
1219   xfree (mbuf);
1220   xfree (ebuf);
1221   return 0;
1222 }
1223 #endif /* GNUPG_MAJOR_VERSION > 1 */
1224
1225
1226
1227 /* Send the KEYPAIRINFO back. KEYNO needs to be in the range [1,3].
1228    This is used by the LEARN command. */
1229 static gpg_error_t
1230 send_keypair_info (app_t app, ctrl_t ctrl, int keyno)
1231 {
1232   gpg_error_t err = 0;
1233   /* Note that GnuPG 1.x does not need this and it would be too time
1234      consuming to send it just for the fun of it. */
1235 #if GNUPG_MAJOR_VERSION > 1
1236   unsigned char grip[20];
1237   char gripstr[41];
1238   char idbuf[50];
1239
1240   err = get_public_key (app, keyno);
1241   if (err)
1242     goto leave;
1243   
1244   assert (keyno >= 1 && keyno <= 3);
1245   if (!app->app_local->pk[keyno-1].key)
1246     goto leave; /* No such key - ignore. */
1247
1248   err = keygrip_from_canon_sexp (app->app_local->pk[keyno-1].key,
1249                                  app->app_local->pk[keyno-1].keylen,
1250                                  grip);
1251   if (err)
1252     goto leave;
1253   
1254   bin2hex (grip, 20, gripstr);
1255
1256   sprintf (idbuf, "OPENPGP.%d", keyno);
1257   send_status_info (ctrl, "KEYPAIRINFO", 
1258                     gripstr, 40, 
1259                     idbuf, strlen (idbuf), 
1260                     NULL, (size_t)0);
1261
1262  leave:
1263 #endif /* GNUPG_MAJOR_VERSION > 1 */
1264
1265   return err; 
1266 }
1267
1268
1269 /* Handle the LEARN command for OpenPGP.  */
1270 static gpg_error_t
1271 do_learn_status (app_t app, ctrl_t ctrl)
1272 {
1273   do_getattr (app, ctrl, "EXTCAP");
1274   do_getattr (app, ctrl, "DISP-NAME");
1275   do_getattr (app, ctrl, "DISP-LANG");
1276   do_getattr (app, ctrl, "DISP-SEX");
1277   do_getattr (app, ctrl, "PUBKEY-URL");
1278   do_getattr (app, ctrl, "LOGIN-DATA");
1279   do_getattr (app, ctrl, "KEY-FPR");
1280   if (app->card_version > 0x0100)
1281     do_getattr (app, ctrl, "KEY-TIME");
1282   do_getattr (app, ctrl, "CA-FPR");
1283   do_getattr (app, ctrl, "CHV-STATUS");
1284   do_getattr (app, ctrl, "SIG-COUNTER");
1285   if (app->app_local->extcap.private_dos)
1286     {
1287       do_getattr (app, ctrl, "PRIVATE-DO-1");
1288       do_getattr (app, ctrl, "PRIVATE-DO-2");
1289       if (app->did_chv2)
1290         do_getattr (app, ctrl, "PRIVATE-DO-3");
1291       if (app->did_chv3)
1292         do_getattr (app, ctrl, "PRIVATE-DO-4");
1293     }
1294   send_keypair_info (app, ctrl, 1);
1295   send_keypair_info (app, ctrl, 2);
1296   send_keypair_info (app, ctrl, 3);
1297   /* Note: We do not send the Cardholder Certificate, because that is
1298      relativly long and for OpenPGP applications not really needed.  */
1299   return 0;
1300 }
1301
1302
1303 /* Handle the READKEY command for OpenPGP.  On success a canonical
1304    encoded S-expression with the public key will get stored at PK and
1305    its length (for assertions) at PKLEN; the caller must release that
1306    buffer. On error PK and PKLEN are not changed and an error code is
1307    returned.  */
1308 static gpg_error_t
1309 do_readkey (app_t app, const char *keyid, unsigned char **pk, size_t *pklen)
1310 {
1311 #if GNUPG_MAJOR_VERSION > 1
1312   gpg_error_t err;
1313   int keyno;
1314   unsigned char *buf;
1315
1316   if (!strcmp (keyid, "OPENPGP.1"))
1317     keyno = 1;
1318   else if (!strcmp (keyid, "OPENPGP.2"))
1319     keyno = 2;
1320   else if (!strcmp (keyid, "OPENPGP.3"))
1321     keyno = 3;
1322   else
1323     return gpg_error (GPG_ERR_INV_ID);
1324
1325   err = get_public_key (app, keyno);
1326   if (err)
1327     return err;
1328
1329   buf = app->app_local->pk[keyno-1].key;
1330   if (!buf)
1331     return gpg_error (GPG_ERR_NO_PUBKEY);
1332   *pklen = app->app_local->pk[keyno-1].keylen;;
1333   *pk = xtrymalloc (*pklen);
1334   if (!*pk)
1335     {
1336       err = gpg_error_from_syserror ();
1337       *pklen = 0;
1338       return err;
1339     }
1340   memcpy (*pk, buf, *pklen);
1341   return 0;
1342 #else
1343   return gpg_error (GPG_ERR_NOT_IMPLEMENTED);
1344 #endif
1345 }
1346
1347 /* Read the standard certificate of an OpenPGP v2 card.  It is
1348    returned in a freshly allocated buffer with that address stored at
1349    CERT and the length of the certificate stored at CERTLEN.  CERTID
1350    needs to be set to "OPENPGP.3".  */
1351 static gpg_error_t
1352 do_readcert (app_t app, const char *certid,
1353              unsigned char **cert, size_t *certlen)
1354 {
1355 #if GNUPG_MAJOR_VERSION > 1
1356   gpg_error_t err;
1357   unsigned char *buffer;
1358   size_t buflen;
1359   void *relptr;
1360
1361   *cert = NULL;
1362   *certlen = 0;
1363   if (strcmp (certid, "OPENPGP.3"))
1364     return gpg_error (GPG_ERR_INV_ID);
1365   if (!app->app_local->extcap.is_v2)
1366     return gpg_error (GPG_ERR_NOT_FOUND);
1367
1368   relptr = get_one_do (app, 0x7F21, &buffer, &buflen, NULL);
1369   if (!relptr)
1370     return gpg_error (GPG_ERR_NOT_FOUND);
1371
1372   *cert = xtrymalloc (buflen);
1373   if (!*cert)
1374     err = gpg_error_from_syserror ();
1375   else
1376     {
1377       memcpy (*cert, buffer, buflen);
1378       *certlen = buflen;
1379       err  = 0;
1380     }
1381   xfree (relptr);
1382   return err;
1383 #else
1384   return gpg_error (GPG_ERR_NOT_IMPLEMENTED);
1385 #endif
1386 }
1387
1388
1389 /* Verify a CHV either using using the pinentry or if possibile by
1390    using a keypad.  PINCB and PINCB_ARG describe the usual callback
1391    for the pinentry.  CHVNO must be either 1 or 2. SIGCOUNT is only
1392    used with CHV1.  PINVALUE is the address of a pointer which will
1393    receive a newly allocated block with the actual PIN (this is useful
1394    in case that PIN shall be used for another verifiy operation).  The
1395    caller needs to free this value.  If the function returns with
1396    success and NULL is stored at PINVALUE, the caller should take this
1397    as an indication that the keypad has been used.
1398    */
1399 static gpg_error_t
1400 verify_a_chv (app_t app,
1401               gpg_error_t (*pincb)(void*, const char *, char **),
1402               void *pincb_arg,
1403               int chvno, unsigned long sigcount, char **pinvalue)
1404 {
1405   int rc = 0;
1406   char *prompt_buffer = NULL;
1407   const char *prompt;
1408   iso7816_pininfo_t pininfo;
1409   int minlen = 6;
1410
1411   assert (chvno == 1 || chvno == 2);
1412
1413   *pinvalue = NULL;
1414
1415   if (chvno == 2 && app->app_local->flags.def_chv2)
1416     {
1417       /* Special case for def_chv2 mechanism. */
1418       if (opt.verbose)
1419         log_info (_("using default PIN as %s\n"), "CHV2");
1420       rc = iso7816_verify (app->slot, 0x82, "123456", 6);
1421       if (rc)
1422         {
1423           /* Verification of CHV2 with the default PIN failed,
1424              although the card pretends to have the default PIN set as
1425              CHV2.  We better disable the def_chv2 flag now. */
1426           log_info (_("failed to use default PIN as %s: %s"
1427                       " - disabling further default use\n"),
1428                     "CHV2", gpg_strerror (rc));
1429           app->app_local->flags.def_chv2 = 0;
1430         }
1431       return rc;
1432     }
1433
1434   memset (&pininfo, 0, sizeof pininfo);
1435   pininfo.mode = 1;
1436   pininfo.minlen = minlen;
1437
1438
1439   if (chvno == 1)
1440     {
1441 #define PROMPTSTRING  _("||Please enter the PIN%%0A[sigs done: %lu]")
1442       size_t promptsize = strlen (PROMPTSTRING) + 50;
1443
1444       prompt_buffer = xtrymalloc (promptsize);
1445       if (!prompt_buffer)
1446         return gpg_error_from_syserror ();
1447       snprintf (prompt_buffer, promptsize-1, PROMPTSTRING, sigcount);
1448       prompt = prompt_buffer;
1449 #undef PROMPTSTRING
1450     }
1451   else
1452     prompt = _("||Please enter the PIN");
1453
1454   
1455   if (!opt.disable_keypad
1456       && !iso7816_check_keypad (app->slot, ISO7816_VERIFY, &pininfo) )
1457     {
1458       /* The reader supports the verify command through the keypad.
1459          Note that the pincb appends a text to the prompt telling the
1460          user to use the keypad. */
1461       rc = pincb (pincb_arg, prompt, NULL); 
1462       prompt = NULL;
1463       xfree (prompt_buffer); 
1464       prompt_buffer = NULL;
1465       if (rc)
1466         {
1467           log_info (_("PIN callback returned error: %s\n"),
1468                     gpg_strerror (rc));
1469           return rc;
1470         }
1471       rc = iso7816_verify_kp (app->slot, 0x80+chvno, "", 0, &pininfo); 
1472       /* Dismiss the prompt. */
1473       pincb (pincb_arg, NULL, NULL);
1474
1475       assert (!*pinvalue);
1476     }
1477   else
1478     {
1479       /* The reader has no keypad or we don't want to use it. */
1480       rc = pincb (pincb_arg, prompt, pinvalue); 
1481       prompt = NULL;
1482       xfree (prompt_buffer); 
1483       prompt_buffer = NULL;
1484       if (rc)
1485         {
1486           log_info (_("PIN callback returned error: %s\n"),
1487                     gpg_strerror (rc));
1488           return rc;
1489         }
1490       
1491       if (strlen (*pinvalue) < minlen)
1492         {
1493           log_error (_("PIN for CHV%d is too short;"
1494                        " minimum length is %d\n"), chvno, minlen);
1495           xfree (*pinvalue);
1496           *pinvalue = NULL;
1497           return gpg_error (GPG_ERR_BAD_PIN);
1498         }
1499
1500       rc = iso7816_verify (app->slot, 0x80+chvno,
1501                            *pinvalue, strlen (*pinvalue));
1502     }
1503   
1504   if (rc)
1505     {
1506       log_error (_("verify CHV%d failed: %s\n"), chvno, gpg_strerror (rc));
1507       xfree (*pinvalue);
1508       *pinvalue = NULL;
1509       flush_cache_after_error (app);
1510     }
1511
1512   return rc;
1513 }
1514
1515
1516 /* Verify CHV2 if required.  Depending on the configuration of the
1517    card CHV1 will also be verified. */
1518 static gpg_error_t
1519 verify_chv2 (app_t app,
1520              gpg_error_t (*pincb)(void*, const char *, char **),
1521              void *pincb_arg)
1522 {
1523   int rc;
1524   char *pinvalue;
1525
1526   if (app->did_chv2) 
1527     return 0;  /* We already verified CHV2.  */
1528
1529   rc = verify_a_chv (app, pincb, pincb_arg, 2, 0, &pinvalue);
1530   if (rc)
1531     return rc;
1532
1533   app->did_chv2 = 1;
1534   
1535   if (!app->did_chv1 && !app->force_chv1 && pinvalue)
1536     {
1537       /* For convenience we verify CHV1 here too.  We do this only if
1538          the card is not configured to require a verification before
1539          each CHV1 controlled operation (force_chv1) and if we are not
1540          using the keypad (PINVALUE == NULL). */
1541       rc = iso7816_verify (app->slot, 0x81, pinvalue, strlen (pinvalue));
1542       if (gpg_err_code (rc) == GPG_ERR_BAD_PIN)
1543         rc = gpg_error (GPG_ERR_PIN_NOT_SYNCED);
1544       if (rc)
1545         {
1546           log_error (_("verify CHV%d failed: %s\n"), 1, gpg_strerror (rc));
1547           flush_cache_after_error (app);
1548         }
1549       else
1550         app->did_chv1 = 1;
1551     }
1552   xfree (pinvalue);
1553
1554   return rc;
1555 }
1556
1557
1558 /* Verify CHV3 if required. */
1559 static gpg_error_t
1560 verify_chv3 (app_t app,
1561              gpg_error_t (*pincb)(void*, const char *, char **),
1562              void *pincb_arg)
1563 {
1564   int rc = 0;
1565
1566 #if GNUPG_MAJOR_VERSION != 1
1567   if (!opt.allow_admin)
1568     {
1569       log_info (_("access to admin commands is not configured\n"));
1570       return gpg_error (GPG_ERR_EACCES);
1571     }
1572 #endif
1573       
1574   if (!app->did_chv3) 
1575     {
1576       void *relptr;
1577       unsigned char *value;
1578       size_t valuelen;
1579       iso7816_pininfo_t pininfo;
1580       int minlen = 8;
1581       int remaining;
1582       char *prompt_buffer = NULL;
1583       const char *prompt;
1584
1585       memset (&pininfo, 0, sizeof pininfo);
1586       pininfo.mode = 1;
1587       pininfo.minlen = minlen;
1588
1589       relptr = get_one_do (app, 0x00C4, &value, &valuelen, NULL);
1590       if (!relptr || valuelen < 7)
1591         {
1592           log_error (_("error retrieving CHV status from card\n"));
1593           xfree (relptr);
1594           return gpg_error (GPG_ERR_CARD);
1595         }
1596       if (value[6] == 0)
1597         {
1598           log_info (_("card is permanently locked!\n"));
1599           xfree (relptr);
1600           return gpg_error (GPG_ERR_BAD_PIN);
1601         }
1602       remaining = value[6];
1603       xfree (relptr);
1604
1605       log_info(_("%d Admin PIN attempts remaining before card"
1606                  " is permanently locked\n"), remaining);
1607
1608       if (remaining < 3)
1609         {
1610           /* TRANSLATORS: Do not translate the "|A|" prefix but keep
1611              it at the start of the string.  Use %%0A to force a
1612              lienfeed.  */
1613 #define PROMPTSTRING  _("|A|Please enter the Admin PIN%%0A" \
1614                         "[remaining attempts: %d]")
1615           size_t promptsize = strlen (PROMPTSTRING) + 50;
1616           
1617           prompt_buffer = xtrymalloc (promptsize);
1618           if (!prompt_buffer)
1619             return gpg_error_from_syserror ();
1620           snprintf (prompt_buffer, promptsize-1, PROMPTSTRING, remaining);
1621           prompt = prompt_buffer;
1622 #undef PROMPTSTRING
1623         }
1624       else
1625         prompt = _("|A|Please enter the Admin PIN");
1626
1627       if (!opt.disable_keypad
1628           && !iso7816_check_keypad (app->slot, ISO7816_VERIFY, &pininfo) )
1629         {
1630           /* The reader supports the verify command through the keypad. */
1631           rc = pincb (pincb_arg, prompt, NULL); 
1632           prompt = NULL;
1633           xfree (prompt_buffer);
1634           prompt_buffer = NULL;
1635           if (rc)
1636             {
1637               log_info (_("PIN callback returned error: %s\n"),
1638                         gpg_strerror (rc));
1639               return rc;
1640             }
1641           rc = iso7816_verify_kp (app->slot, 0x83, "", 0, &pininfo); 
1642           /* Dismiss the prompt. */
1643           pincb (pincb_arg, NULL, NULL);
1644         }
1645       else
1646         {
1647           char *pinvalue;
1648
1649           rc = pincb (pincb_arg, prompt, &pinvalue); 
1650           prompt = NULL;
1651           xfree (prompt_buffer);
1652           prompt_buffer = NULL;
1653           if (rc)
1654             {
1655               log_info (_("PIN callback returned error: %s\n"),
1656                         gpg_strerror (rc));
1657               return rc;
1658             }
1659           
1660           if (strlen (pinvalue) < minlen)
1661             {
1662               log_error (_("PIN for CHV%d is too short;"
1663                            " minimum length is %d\n"), 3, minlen);
1664               xfree (pinvalue);
1665               return gpg_error (GPG_ERR_BAD_PIN);
1666             }
1667           
1668           rc = iso7816_verify (app->slot, 0x83, pinvalue, strlen (pinvalue));
1669           xfree (pinvalue);
1670         }
1671       
1672       if (rc)
1673         {
1674           log_error (_("verify CHV%d failed: %s\n"), 3, gpg_strerror (rc));
1675           flush_cache_after_error (app);
1676           return rc;
1677         }
1678       app->did_chv3 = 1;
1679     }
1680   return rc;
1681 }
1682
1683
1684 /* Handle the SETATTR operation. All arguments are already basically
1685    checked. */
1686 static gpg_error_t 
1687 do_setattr (app_t app, const char *name,
1688             gpg_error_t (*pincb)(void*, const char *, char **),
1689             void *pincb_arg,
1690             const unsigned char *value, size_t valuelen)
1691 {
1692   gpg_error_t rc;
1693   int idx;
1694   static struct {
1695     const char *name;
1696     int tag;
1697     int need_chv;
1698     int special;
1699     unsigned int need_v2:1;
1700   } table[] = {
1701     { "DISP-NAME",    0x005B, 3 },
1702     { "LOGIN-DATA",   0x005E, 3, 2 },
1703     { "DISP-LANG",    0x5F2D, 3 },
1704     { "DISP-SEX",     0x5F35, 3 },
1705     { "PUBKEY-URL",   0x5F50, 3 },
1706     { "CHV-STATUS-1", 0x00C4, 3, 1 },
1707     { "CA-FPR-1",     0x00CA, 3 },
1708     { "CA-FPR-2",     0x00CB, 3 },
1709     { "CA-FPR-3",     0x00CC, 3 },
1710     { "PRIVATE-DO-1", 0x0101, 2 },
1711     { "PRIVATE-DO-2", 0x0102, 3 },
1712     { "PRIVATE-DO-3", 0x0103, 2 },
1713     { "PRIVATE-DO-4", 0x0104, 3 },
1714     { "CERT-3",       0x7F21, 3, 0, 1 },
1715     { "SM-KEY-ENC",   0x00D1, 3, 0, 1 },
1716     { "SM-KEY-MAC",   0x00D2, 3, 0, 1 },
1717     { NULL, 0 }
1718   };
1719   int exmode;
1720
1721   for (idx=0; table[idx].name && strcmp (table[idx].name, name); idx++)
1722     ;
1723   if (!table[idx].name)
1724     return gpg_error (GPG_ERR_INV_NAME); 
1725   if (table[idx].need_v2 && !app->app_local->extcap.is_v2)
1726     return gpg_error (GPG_ERR_NOT_SUPPORTED); /* Not yet supported.  */
1727
1728   switch (table[idx].need_chv)
1729     {
1730     case 2:
1731       rc = verify_chv2 (app, pincb, pincb_arg);
1732       break;
1733     case 3:
1734       rc = verify_chv3 (app, pincb, pincb_arg);
1735       break;
1736     default:
1737       rc = 0;
1738     }
1739   if (rc)
1740     return rc;
1741
1742   /* Flush the cache before writing it, so that the next get operation
1743      will reread the data from the card and thus get synced in case of
1744      errors (e.g. data truncated by the card). */
1745   flush_cache_item (app, table[idx].tag);
1746   /* For command chaining we use a value of 254 for this card.  */
1747   if (app->app_local->cardcap.cmd_chaining && valuelen > 254)
1748     exmode = -254;
1749   else
1750     exmode = 0;
1751   rc = iso7816_put_data (app->slot, exmode, table[idx].tag, value, valuelen);
1752   if (rc)
1753     log_error ("failed to set `%s': %s\n", table[idx].name, gpg_strerror (rc));
1754
1755   if (table[idx].special == 1)
1756     app->force_chv1 = (valuelen && *value == 0);
1757   else if (table[idx].special == 2)
1758     parse_login_data (app);
1759
1760   return rc;
1761 }
1762
1763
1764 /* Handle the WRITECERT command for OpenPGP.  This rites the standard
1765    certifciate to the card; CERTID needs to be set to "OPENPGP.3".
1766    PINCB and PINCB_ARG are the usual arguments for the pinentry
1767    callback.  */
1768 static gpg_error_t
1769 do_writecert (app_t app, ctrl_t ctrl,
1770               const char *certidstr, 
1771               gpg_error_t (*pincb)(void*, const char *, char **),
1772               void *pincb_arg,
1773               const unsigned char *certdata, size_t certdatalen)
1774 {
1775   (void)ctrl;
1776 #if GNUPG_MAJOR_VERSION > 1
1777   if (strcmp (certidstr, "OPENPGP.3"))
1778     return gpg_error (GPG_ERR_INV_ID);
1779   if (!certdata || !certdatalen)
1780     return gpg_error (GPG_ERR_INV_ARG);
1781   if (!app->app_local->extcap.is_v2)
1782     return gpg_error (GPG_ERR_NOT_SUPPORTED);
1783   if (certdatalen > app->app_local->extcap.max_certlen_3)
1784     return gpg_error (GPG_ERR_TOO_LARGE);
1785   return do_setattr (app, "CERT-3", pincb, pincb_arg, certdata, certdatalen);
1786 #else
1787   return gpg_error (GPG_ERR_NOT_IMPLEMENTED);
1788 #endif
1789 }
1790
1791
1792
1793 /* Handle the PASSWD command. */
1794 static gpg_error_t 
1795 do_change_pin (app_t app, ctrl_t ctrl,  const char *chvnostr, 
1796                unsigned int flags,
1797                gpg_error_t (*pincb)(void*, const char *, char **),
1798                void *pincb_arg)
1799 {
1800   int rc = 0;
1801   int chvno = atoi (chvnostr);
1802   char *resetcode = NULL;
1803   char *pinvalue;
1804   int reset_mode = !!(flags & APP_CHANGE_FLAG_RESET);
1805   int set_resetcode = 0;
1806
1807   (void)ctrl;
1808
1809   if (reset_mode && chvno == 3)
1810     {
1811       rc = gpg_error (GPG_ERR_INV_ID);
1812       goto leave;
1813     }
1814   else if (reset_mode || chvno == 3)
1815     {
1816       /* We always require that the PIN is entered. */
1817       app->did_chv3 = 0;
1818       rc = verify_chv3 (app, pincb, pincb_arg);
1819       if (rc)
1820         goto leave;
1821   
1822       if (chvno == 2 && app->app_local->extcap.is_v2)
1823         set_resetcode = 1;
1824     }
1825   else if (chvno == 2 && app->app_local->extcap.is_v2)
1826     {
1827       /* There is no PW2 for v2 cards.  We use this condition to allow
1828          a PW reset using the Reset Code.  */
1829       void *relptr;
1830       unsigned char *value;
1831       size_t valuelen;
1832       int remaining;
1833
1834       relptr = get_one_do (app, 0x00C4, &value, &valuelen, NULL);
1835       if (!relptr || valuelen < 7)
1836         {
1837           log_error (_("error retrieving CHV status from card\n"));
1838           xfree (relptr);
1839           rc = gpg_error (GPG_ERR_CARD);
1840           goto leave;
1841         }
1842       remaining = value[5];
1843       xfree (relptr);
1844       if (!remaining)
1845         {
1846           log_error (_("Reset Code not or not anymore available\n"));
1847           rc = gpg_error (GPG_ERR_BAD_PIN);
1848           goto leave;
1849         }          
1850
1851       rc = pincb (pincb_arg, _("||Please enter the Reset Code for the card"),
1852                   &resetcode); 
1853       if (rc)
1854         {
1855           log_info (_("PIN callback returned error: %s\n"), gpg_strerror (rc));
1856           goto leave;
1857         }
1858       if (strlen (resetcode) < 8)
1859         {
1860           log_error (_("Reset Code is too short; minimum length is %d\n"), 8);
1861           rc = gpg_error (GPG_ERR_BAD_PIN);
1862           goto leave;
1863         }
1864     }
1865   else if (chvno == 1 || chvno == 2)
1866     {
1867       /* CHV1 and CVH2 should always have the same value, thus we
1868          enforce it here.  */
1869       int save_force = app->force_chv1;
1870
1871       app->force_chv1 = 0;
1872       app->did_chv1 = 0;
1873       app->did_chv2 = 0;
1874       rc = verify_chv2 (app, pincb, pincb_arg);
1875       app->force_chv1 = save_force;
1876       if (rc)
1877         goto leave;
1878     }
1879   else
1880     {
1881       rc = gpg_error (GPG_ERR_INV_ID);
1882       goto leave;
1883     }
1884
1885   if (chvno == 3)
1886     app->did_chv3 = 0;
1887   else
1888     app->did_chv1 = app->did_chv2 = 0;
1889
1890   /* TRANSLATORS: Do not translate the "|*|" prefixes but
1891      keep it at the start of the string.  We need this elsewhere
1892      to get some infos on the string. */
1893   rc = pincb (pincb_arg, 
1894               set_resetcode? _("|RN|New Reset Code") :
1895               chvno == 3? _("|AN|New Admin PIN") : _("|N|New PIN"), 
1896               &pinvalue); 
1897   if (rc)
1898     {
1899       log_error (_("error getting new PIN: %s\n"), gpg_strerror (rc));
1900       goto leave;
1901     }
1902
1903   if (resetcode)
1904     {
1905       char *buffer;
1906
1907       buffer = xtrymalloc (strlen (resetcode) + strlen (pinvalue) + 1);
1908       if (!buffer)
1909         rc = gpg_error_from_syserror ();
1910       else
1911         {
1912           strcpy (stpcpy (buffer, resetcode), pinvalue);
1913           rc = iso7816_reset_retry_counter_with_rc (app->slot, 0x81,
1914                                                     buffer, strlen (buffer));
1915           wipememory (buffer, strlen (buffer));
1916           xfree (buffer);
1917         }
1918     }
1919   else if (set_resetcode)
1920     {
1921       if (strlen (pinvalue) < 8)
1922         {
1923           log_error (_("Reset Code is too short; minimum length is %d\n"), 8);
1924           rc = gpg_error (GPG_ERR_BAD_PIN);
1925         }
1926       else
1927         rc = iso7816_put_data (app->slot, 0, 0xD3,
1928                                pinvalue, strlen (pinvalue));
1929     }
1930   else if (reset_mode)
1931     {
1932       rc = iso7816_reset_retry_counter (app->slot, 0x81,
1933                                         pinvalue, strlen (pinvalue));
1934       if (!rc && !app->app_local->extcap.is_v2)
1935         rc = iso7816_reset_retry_counter (app->slot, 0x82,
1936                                           pinvalue, strlen (pinvalue));
1937     }
1938   else
1939     {
1940       if (chvno == 1 || chvno == 2)
1941         {
1942           rc = iso7816_change_reference_data (app->slot, 0x81, NULL, 0,
1943                                               pinvalue, strlen (pinvalue));
1944           if (!rc && !app->app_local->extcap.is_v2)
1945             rc = iso7816_change_reference_data (app->slot, 0x82, NULL, 0,
1946                                                 pinvalue, strlen (pinvalue));
1947         }
1948       else
1949         rc = iso7816_change_reference_data (app->slot, 0x80 + chvno, NULL, 0,
1950                                             pinvalue, strlen (pinvalue));
1951     }
1952   if (pinvalue)
1953     {
1954       wipememory (pinvalue, strlen (pinvalue));
1955       xfree (pinvalue);
1956     }
1957   if (rc)
1958     flush_cache_after_error (app);
1959
1960  leave:
1961   if (resetcode)
1962     {
1963       wipememory (resetcode, strlen (resetcode));
1964       xfree (resetcode);
1965     }
1966   return rc;
1967 }
1968
1969
1970 /* Check whether a key already exists.  KEYIDX is the index of the key
1971    (0..2).  If FORCE is TRUE a diagnositic will be printed but no
1972    error returned if the key already exists. */
1973 static gpg_error_t
1974 does_key_exist (app_t app, int keyidx, int force)
1975 {
1976   const unsigned char *fpr;
1977   unsigned char *buffer;
1978   size_t buflen, n;
1979   int i;
1980
1981   assert (keyidx >=0 && keyidx <= 2);
1982
1983   if (iso7816_get_data (app->slot, 0x006E, &buffer, &buflen))
1984     {
1985       log_error (_("error reading application data\n"));
1986       return gpg_error (GPG_ERR_GENERAL);
1987     }
1988   fpr = find_tlv (buffer, buflen, 0x00C5, &n);
1989   if (!fpr || n < 60)
1990     {
1991       log_error (_("error reading fingerprint DO\n"));
1992       xfree (buffer);
1993       return gpg_error (GPG_ERR_GENERAL);
1994     }
1995   fpr += 20*keyidx;
1996   for (i=0; i < 20 && !fpr[i]; i++)
1997     ;
1998   xfree (buffer);
1999   if (i!=20 && !force)
2000     {
2001       log_error (_("key already exists\n"));
2002       return gpg_error (GPG_ERR_EEXIST);
2003     }
2004   else if (i!=20)
2005     log_info (_("existing key will be replaced\n"));
2006   else
2007     log_info (_("generating new key\n"));
2008   return 0;
2009 }
2010
2011
2012 /* Create a TLV tag and value and store it at BUFFER.  Return the length
2013    of tag and length.  A LENGTH greater than 65535 is truncated. */
2014 static size_t
2015 add_tlv (unsigned char *buffer, unsigned int tag, size_t length)
2016
2017   unsigned char *p = buffer;
2018
2019   assert (tag <= 0xffff);
2020   if ( tag > 0xff )
2021     *p++ = tag >> 8;
2022   *p++ = tag;
2023   if (length < 128)
2024     *p++ = length;
2025   else if (length < 256)
2026     {
2027       *p++ = 0x81;
2028       *p++ = length;
2029     }
2030   else
2031     {
2032       if (length > 0xffff)
2033         length = 0xffff;
2034       *p++ = 0x82;
2035       *p++ = length >> 8;
2036       *p++ = length;
2037     }
2038
2039   return p - buffer;
2040 }
2041
2042
2043 /* Build the private key template as specified in the OpenPGP specs
2044    v2.0 section 4.3.3.7.  */
2045 static gpg_error_t
2046 build_privkey_template (app_t app, int keyno,
2047                         const unsigned char *rsa_n, size_t rsa_n_len,
2048                         const unsigned char *rsa_e, size_t rsa_e_len,
2049                         const unsigned char *rsa_p, size_t rsa_p_len,
2050                         const unsigned char *rsa_q, size_t rsa_q_len,
2051                         unsigned char **result, size_t *resultlen)
2052 {
2053   size_t rsa_e_reqlen;
2054   unsigned char privkey[7*(1+3)];
2055   size_t privkey_len;
2056   unsigned char exthdr[2+2+3];
2057   size_t exthdr_len;
2058   unsigned char suffix[2+3];
2059   size_t suffix_len;
2060   unsigned char *tp;
2061   size_t datalen;
2062   unsigned char *template;
2063   size_t template_size;
2064
2065   *result = NULL;
2066   *resultlen = 0;
2067
2068   switch (app->app_local->keyattr[keyno].format)
2069     {
2070     case RSA_STD:
2071     case RSA_STD_N:
2072       break;
2073     case RSA_CRT:
2074     case RSA_CRT_N:
2075       return gpg_error (GPG_ERR_NOT_SUPPORTED);
2076
2077     default:
2078       return gpg_error (GPG_ERR_INV_VALUE);
2079     }
2080
2081   /* Get the required length for E.  */
2082   rsa_e_reqlen = app->app_local->keyattr[keyno].e_bits/8;
2083   assert (rsa_e_len <= rsa_e_reqlen);
2084
2085   /* Build the 7f48 cardholder private key template.  */
2086   datalen = 0;
2087   tp = privkey;
2088
2089   tp += add_tlv (tp, 0x91, rsa_e_reqlen);
2090   datalen += rsa_e_reqlen;
2091
2092   tp += add_tlv (tp, 0x92, rsa_p_len);
2093   datalen += rsa_p_len;
2094
2095   tp += add_tlv (tp, 0x93, rsa_q_len);
2096   datalen += rsa_q_len;
2097
2098   if (app->app_local->keyattr[keyno].format == RSA_STD_N
2099       || app->app_local->keyattr[keyno].format == RSA_CRT_N)
2100     {
2101       tp += add_tlv (tp, 0x97, rsa_n_len);
2102       datalen += rsa_n_len;
2103     }
2104   privkey_len = tp - privkey;
2105
2106   /* Build the extended header list without the private key template.  */
2107   tp = exthdr;
2108   *tp++ = keyno ==0 ? 0xb6 : keyno == 1? 0xb8 : 0xa4;
2109   *tp++ = 0;
2110   tp += add_tlv (tp, 0x7f48, privkey_len);
2111   exthdr_len = tp - exthdr;
2112
2113   /* Build the 5f48 suffix of the data.  */
2114   tp = suffix;
2115   tp += add_tlv (tp, 0x5f48, datalen);
2116   suffix_len = tp - suffix;
2117
2118   /* Now concatenate everything.  */
2119   template_size = (1 + 3   /* 0x4d and len. */
2120                    + exthdr_len
2121                    + privkey_len
2122                    + suffix_len
2123                    + datalen);
2124   tp = template = xtrymalloc_secure (template_size);
2125   if (!template)
2126     return gpg_error_from_syserror ();
2127
2128   tp += add_tlv (tp, 0x4d, exthdr_len + privkey_len + suffix_len + datalen);
2129   memcpy (tp, exthdr, exthdr_len);
2130   tp += exthdr_len;
2131   memcpy (tp, privkey, privkey_len);
2132   tp += privkey_len;
2133   memcpy (tp, suffix, suffix_len);
2134   tp += suffix_len;
2135
2136   memcpy (tp, rsa_e, rsa_e_len);
2137   if (rsa_e_len < rsa_e_reqlen)
2138     {
2139       /* Right justify E. */
2140       memmove (tp + rsa_e_reqlen - rsa_e_len, tp, rsa_e_len);
2141       memset (tp, 0, rsa_e_reqlen - rsa_e_len);
2142     }                 
2143   tp += rsa_e_reqlen;
2144       
2145   memcpy (tp, rsa_p, rsa_p_len);
2146   tp += rsa_p_len;
2147       
2148   memcpy (tp, rsa_q, rsa_q_len);
2149   tp += rsa_q_len;
2150   
2151   if (app->app_local->keyattr[keyno].format == RSA_STD_N
2152       || app->app_local->keyattr[keyno].format == RSA_CRT_N)
2153     {
2154       memcpy (tp, rsa_n, rsa_n_len);
2155       tp += rsa_n_len;
2156     }
2157
2158   /* Sanity check.  We don't know the exact length because we
2159      allocated 3 bytes for the first length header.  */
2160   assert (tp - template <= template_size);
2161
2162   *result = template;
2163   *resultlen = tp - template;
2164   return 0;
2165 }
2166
2167
2168
2169 /* Handle the WRITEKEY command for OpenPGP.  This function expects a
2170    canonical encoded S-expression with the secret key in KEYDATA and
2171    its length (for assertions) in KEYDATALEN.  KEYID needs to be the
2172    usual keyid which for OpenPGP is the string "OPENPGP.n" with
2173    n=1,2,3.  Bit 0 of FLAGS indicates whether an existing key shall
2174    get overwritten.  PINCB and PINCB_ARG are the usual arguments for
2175    the pinentry callback.  */
2176 static gpg_error_t
2177 do_writekey (app_t app, ctrl_t ctrl,
2178              const char *keyid, unsigned int flags,
2179              gpg_error_t (*pincb)(void*, const char *, char **),
2180              void *pincb_arg,
2181              const unsigned char *keydata, size_t keydatalen)
2182 {
2183   gpg_error_t err;
2184   int force = (flags & 1);
2185   int keyno;
2186   const unsigned char *buf, *tok;
2187   size_t buflen, toklen;
2188   int depth, last_depth1, last_depth2;
2189   const unsigned char *rsa_n = NULL;
2190   const unsigned char *rsa_e = NULL;
2191   const unsigned char *rsa_p = NULL;
2192   const unsigned char *rsa_q = NULL;
2193   size_t rsa_n_len, rsa_e_len, rsa_p_len, rsa_q_len;
2194   unsigned int nbits;
2195   unsigned int maxbits;
2196   unsigned char *template = NULL;
2197   unsigned char *tp;
2198   size_t template_len;
2199   unsigned char fprbuf[20];
2200   u32 created_at = 0;
2201
2202   (void)ctrl;
2203
2204   if (!strcmp (keyid, "OPENPGP.1"))
2205     keyno = 0;
2206   else if (!strcmp (keyid, "OPENPGP.2"))
2207     keyno = 1;
2208   else if (!strcmp (keyid, "OPENPGP.3"))
2209     keyno = 2;
2210   else
2211     return gpg_error (GPG_ERR_INV_ID);
2212   
2213   err = does_key_exist (app, keyno, force);
2214   if (err)
2215     return err;
2216
2217
2218   /* 
2219      Parse the S-expression
2220    */
2221   buf = keydata;
2222   buflen = keydatalen;
2223   depth = 0;
2224   if ((err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen)))
2225     goto leave;
2226   if ((err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen)))
2227     goto leave;
2228   if (!tok || toklen != 11 || memcmp ("private-key", tok, toklen))
2229     {
2230       if (!tok)
2231         ;
2232       else if (toklen == 21 && !memcmp ("protected-private-key", tok, toklen))
2233         log_info ("protected-private-key passed to writekey\n");
2234       else if (toklen == 20 && !memcmp ("shadowed-private-key", tok, toklen))
2235         log_info ("shadowed-private-key passed to writekey\n");
2236       err = gpg_error (GPG_ERR_BAD_SECKEY);
2237       goto leave;
2238     }
2239   if ((err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen)))
2240     goto leave;
2241   if ((err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen)))
2242     goto leave;
2243   if (!tok || toklen != 3 || memcmp ("rsa", tok, toklen))
2244     {
2245       err = gpg_error (GPG_ERR_WRONG_PUBKEY_ALGO);
2246       goto leave;
2247     }
2248   last_depth1 = depth;
2249   while (!(err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen))
2250          && depth && depth >= last_depth1)
2251     {
2252       if (tok)
2253         {
2254           err = gpg_error (GPG_ERR_UNKNOWN_SEXP);
2255           goto leave;
2256         }
2257       if ((err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen)))
2258         goto leave;
2259       if (tok && toklen == 1)
2260         {
2261           const unsigned char **mpi;
2262           size_t *mpi_len;
2263
2264           switch (*tok)
2265             {
2266             case 'n': mpi = &rsa_n; mpi_len = &rsa_n_len; break; 
2267             case 'e': mpi = &rsa_e; mpi_len = &rsa_e_len; break; 
2268             case 'p': mpi = &rsa_p; mpi_len = &rsa_p_len; break; 
2269             case 'q': mpi = &rsa_q; mpi_len = &rsa_q_len;break; 
2270             default: mpi = NULL;  mpi_len = NULL; break;
2271             }
2272           if (mpi && *mpi)
2273             {
2274               err = gpg_error (GPG_ERR_DUP_VALUE);
2275               goto leave;
2276             }
2277           if ((err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen)))
2278             goto leave;
2279           if (tok && mpi)
2280             {
2281               /* Strip off leading zero bytes and save. */
2282               for (;toklen && !*tok; toklen--, tok++)
2283                 ;
2284               *mpi = tok;
2285               *mpi_len = toklen;
2286             }
2287         }
2288       /* Skip until end of list. */
2289       last_depth2 = depth;
2290       while (!(err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen))
2291              && depth && depth >= last_depth2)
2292         ;
2293       if (err)
2294         goto leave;
2295     }
2296   /* Parse other attributes. */
2297   last_depth1 = depth;
2298   while (!(err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen))
2299          && depth && depth >= last_depth1)
2300     {
2301       if (tok)
2302         {
2303           err = gpg_error (GPG_ERR_UNKNOWN_SEXP);
2304           goto leave;
2305         }
2306       if ((err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen)))
2307         goto leave;
2308       if (tok && toklen == 10 && !memcmp ("created-at", tok, toklen))
2309         {
2310           if ((err = parse_sexp (&buf,&buflen,&depth,&tok,&toklen)))
2311             goto leave;
2312           if (tok)
2313             {
2314               for (created_at=0; toklen && *tok && *tok >= '0' && *tok <= '9';
2315                    tok++, toklen--)
2316                 created_at = created_at*10 + (*tok - '0');
2317             }
2318         }
2319       /* Skip until end of list. */
2320       last_depth2 = depth;
2321       while (!(err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen))
2322              && depth && depth >= last_depth2)
2323         ;
2324       if (err)
2325         goto leave;
2326     }
2327
2328
2329   /* Check that we have all parameters and that they match the card
2330      description. */
2331   if (!created_at)
2332     {
2333       log_error (_("creation timestamp missing\n"));
2334       err = gpg_error (GPG_ERR_INV_VALUE);
2335       goto leave;
2336     }
2337
2338   maxbits = app->app_local->keyattr[keyno].n_bits;
2339   nbits = rsa_n? count_bits (rsa_n, rsa_n_len) : 0;
2340   if (nbits != maxbits)
2341     {
2342       log_error (_("RSA modulus missing or not of size %d bits\n"), 
2343                  (int)maxbits);
2344       err = gpg_error (GPG_ERR_BAD_SECKEY);
2345       goto leave;
2346     }
2347
2348   maxbits = app->app_local->keyattr[keyno].e_bits;
2349   if (maxbits > 32 && !app->app_local->extcap.is_v2)
2350     maxbits = 32; /* Our code for v1 does only support 32 bits.  */
2351   nbits = rsa_e? count_bits (rsa_e, rsa_e_len) : 0;
2352   if (nbits < 2 || nbits > maxbits)
2353     {
2354       log_error (_("RSA public exponent missing or larger than %d bits\n"),
2355                  (int)maxbits);
2356       err = gpg_error (GPG_ERR_BAD_SECKEY);
2357       goto leave;
2358     }
2359
2360   maxbits = app->app_local->keyattr[keyno].n_bits/2;
2361   nbits = rsa_p? count_bits (rsa_p, rsa_p_len) : 0;
2362   if (nbits != maxbits)
2363     {
2364       log_error (_("RSA prime %s missing or not of size %d bits\n"), 
2365                  "P", (int)maxbits);
2366       err = gpg_error (GPG_ERR_BAD_SECKEY);
2367       goto leave;
2368     }
2369   nbits = rsa_q? count_bits (rsa_q, rsa_q_len) : 0;
2370   if (nbits != maxbits)
2371     {
2372       log_error (_("RSA prime %s missing or not of size %d bits\n"), 
2373                  "Q", (int)maxbits);
2374       err = gpg_error (GPG_ERR_BAD_SECKEY);
2375       goto leave;
2376     }
2377   
2378   /* We need to remove the cached public key.  */
2379   xfree (app->app_local->pk[keyno].key);
2380   app->app_local->pk[keyno].key = NULL;
2381   app->app_local->pk[keyno].keylen = 0;
2382   app->app_local->pk[keyno].read_done = 0;
2383
2384
2385   if (app->app_local->extcap.is_v2)
2386     {
2387       /* Build the private key template as described in section 4.3.3.7 of
2388          the OpenPGP card specs version 2.0.  */
2389       int exmode;
2390  
2391       err = build_privkey_template (app, keyno,
2392                                     rsa_n, rsa_n_len,
2393                                     rsa_e, rsa_e_len,
2394                                     rsa_p, rsa_p_len,
2395                                     rsa_q, rsa_q_len,
2396                                     &template, &template_len);
2397       if (err)
2398         goto leave;
2399
2400       /* Prepare for storing the key.  */
2401       err = verify_chv3 (app, pincb, pincb_arg);
2402       if (err)
2403         goto leave;
2404
2405       /* Store the key. */
2406       if (app->app_local->cardcap.cmd_chaining && template_len > 254)
2407         exmode = -254;
2408       else
2409         exmode = 0;
2410       err = iso7816_put_data_odd (app->slot, exmode, 0x3fff,
2411                                   template, template_len);
2412     }
2413   else
2414     {
2415       /* Build the private key template as described in section 4.3.3.6 of
2416          the OpenPGP card specs version 1.1:
2417          0xC0   <length> public exponent
2418          0xC1   <length> prime p 
2419          0xC2   <length> prime q 
2420       */
2421       assert (rsa_e_len <= 4);
2422       template_len = (1 + 1 + 4
2423                       + 1 + 1 + rsa_p_len
2424                       + 1 + 1 + rsa_q_len);
2425       template = tp = xtrymalloc_secure (template_len);
2426       if (!template)
2427         {
2428           err = gpg_error_from_syserror ();
2429           goto leave;
2430         }
2431       *tp++ = 0xC0;
2432       *tp++ = 4;
2433       memcpy (tp, rsa_e, rsa_e_len);
2434       if (rsa_e_len < 4)
2435         {
2436           /* Right justify E. */
2437           memmove (tp+4-rsa_e_len, tp, rsa_e_len);
2438           memset (tp, 0, 4-rsa_e_len);
2439         }                 
2440       tp += 4;
2441       
2442       *tp++ = 0xC1;
2443       *tp++ = rsa_p_len;
2444       memcpy (tp, rsa_p, rsa_p_len);
2445       tp += rsa_p_len;
2446       
2447       *tp++ = 0xC2;
2448       *tp++ = rsa_q_len;
2449       memcpy (tp, rsa_q, rsa_q_len);
2450       tp += rsa_q_len;
2451       
2452       assert (tp - template == template_len);
2453       
2454       /* Prepare for storing the key.  */
2455       err = verify_chv3 (app, pincb, pincb_arg);
2456       if (err)
2457         goto leave;
2458
2459       /* Store the key. */
2460       err = iso7816_put_data (app->slot, 0,
2461                               (app->card_version > 0x0007? 0xE0:0xE9)+keyno,
2462                               template, template_len);
2463     }
2464   if (err)
2465     {
2466       log_error (_("failed to store the key: %s\n"), gpg_strerror (err));
2467       goto leave;
2468     }
2469  
2470   err = store_fpr (app->slot, keyno, created_at,
2471                   rsa_n, rsa_n_len, rsa_e, rsa_e_len,
2472                   fprbuf, app->card_version);
2473   if (err)
2474     goto leave;
2475
2476
2477  leave:
2478   xfree (template);
2479   return err;
2480 }
2481
2482
2483 /* Handle the GENKEY command. */
2484 static gpg_error_t 
2485 do_genkey (app_t app, ctrl_t ctrl,  const char *keynostr, unsigned int flags,
2486            time_t createtime,
2487            gpg_error_t (*pincb)(void*, const char *, char **),
2488            void *pincb_arg)
2489 {
2490   int rc;
2491   char numbuf[30];
2492   unsigned char fprbuf[20];
2493   const unsigned char *keydata, *m, *e;
2494   unsigned char *buffer = NULL;
2495   size_t buflen, keydatalen, mlen, elen;
2496   time_t created_at;
2497   int keyno = atoi (keynostr);
2498   int force = (flags & 1);
2499   time_t start_at;
2500
2501   if (keyno < 1 || keyno > 3)
2502     return gpg_error (GPG_ERR_INV_ID);
2503   keyno--;
2504
2505   /* We flush the cache to increase the traffic before a key
2506      generation.  This _might_ help a card to gather more entropy. */
2507   flush_cache (app);
2508
2509   /* Obviously we need to remove the cached public key.  */
2510   xfree (app->app_local->pk[keyno].key);
2511   app->app_local->pk[keyno].key = NULL;
2512   app->app_local->pk[keyno].keylen = 0;
2513   app->app_local->pk[keyno].read_done = 0;
2514
2515   /* Check whether a key already exists.  */
2516   rc = does_key_exist (app, keyno, force);
2517   if (rc)
2518     return rc;
2519
2520   /* Prepare for key generation by verifying the Admin PIN.  */
2521   rc = verify_chv3 (app, pincb, pincb_arg);
2522   if (rc)
2523     goto leave;
2524    
2525 #if 1
2526   log_info (_("please wait while key is being generated ...\n"));
2527   start_at = time (NULL);
2528   rc = iso7816_generate_keypair 
2529 #else
2530 # warning key generation temporary replaced by reading an existing key.
2531   rc = iso7816_read_public_key
2532 #endif
2533     (app->slot, (const unsigned char*)(keyno == 0? "\xB6" :
2534                                        keyno == 1? "\xB8" : "\xA4"),
2535      2,
2536      &buffer, &buflen);
2537   if (rc)
2538     {
2539       rc = gpg_error (GPG_ERR_CARD);
2540       log_error (_("generating key failed\n"));
2541       goto leave;
2542     }
2543   log_info (_("key generation completed (%d seconds)\n"),
2544             (int)(time (NULL) - start_at));
2545   keydata = find_tlv (buffer, buflen, 0x7F49, &keydatalen);
2546   if (!keydata)
2547     {
2548       rc = gpg_error (GPG_ERR_CARD);
2549       log_error (_("response does not contain the public key data\n"));
2550       goto leave;
2551     }
2552  
2553   m = find_tlv (keydata, keydatalen, 0x0081, &mlen);
2554   if (!m)
2555     {
2556       rc = gpg_error (GPG_ERR_CARD);
2557       log_error (_("response does not contain the RSA modulus\n"));
2558       goto leave;
2559     }
2560 /*    log_printhex ("RSA n:", m, mlen); */
2561   send_key_data (ctrl, "n", m, mlen);
2562
2563   e = find_tlv (keydata, keydatalen, 0x0082, &elen);
2564   if (!e)
2565     {
2566       rc = gpg_error (GPG_ERR_CARD);
2567       log_error (_("response does not contain the RSA public exponent\n"));
2568       goto leave;
2569     }
2570 /*    log_printhex ("RSA e:", e, elen); */
2571   send_key_data (ctrl, "e", e, elen);
2572
2573   created_at = createtime? createtime : gnupg_get_time ();
2574   sprintf (numbuf, "%lu", (unsigned long)created_at);
2575   send_status_info (ctrl, "KEY-CREATED-AT",
2576                     numbuf, (size_t)strlen(numbuf), NULL, 0);
2577
2578   rc = store_fpr (app->slot, keyno, (u32)created_at,
2579                   m, mlen, e, elen, fprbuf, app->card_version);
2580   if (rc)
2581     goto leave;
2582   send_fpr_if_not_null (ctrl, "KEY-FPR", -1, fprbuf);
2583
2584
2585  leave:
2586   xfree (buffer);
2587   return rc;
2588 }
2589
2590
2591 static unsigned long
2592 convert_sig_counter_value (const unsigned char *value, size_t valuelen)
2593 {
2594   unsigned long ul;
2595
2596   if (valuelen == 3 )
2597     ul = (value[0] << 16) | (value[1] << 8) | value[2];
2598   else
2599     {
2600       log_error (_("invalid structure of OpenPGP card (DO 0x93)\n"));
2601       ul = 0;
2602     }
2603   return ul;
2604 }
2605
2606 static unsigned long
2607 get_sig_counter (app_t app)
2608 {
2609   void *relptr;
2610   unsigned char *value;
2611   size_t valuelen;
2612   unsigned long ul;
2613
2614   relptr = get_one_do (app, 0x0093, &value, &valuelen, NULL);
2615   if (!relptr)
2616     return 0;
2617   ul = convert_sig_counter_value (value, valuelen);
2618   xfree (relptr);
2619   return ul;
2620 }
2621
2622 static gpg_error_t
2623 compare_fingerprint (app_t app, int keyno, unsigned char *sha1fpr)
2624 {
2625   const unsigned char *fpr;
2626   unsigned char *buffer;
2627   size_t buflen, n;
2628   int rc, i;
2629   
2630   assert (keyno >= 1 && keyno <= 3);
2631
2632   rc = get_cached_data (app, 0x006E, &buffer, &buflen, 0);
2633   if (rc)
2634     {
2635       log_error (_("error reading application data\n"));
2636       return gpg_error (GPG_ERR_GENERAL);
2637     }
2638   fpr = find_tlv (buffer, buflen, 0x00C5, &n);
2639   if (!fpr || n != 60)
2640     {
2641       xfree (buffer);
2642       log_error (_("error reading fingerprint DO\n"));
2643       return gpg_error (GPG_ERR_GENERAL);
2644     }
2645   fpr += (keyno-1)*20;
2646   for (i=0; i < 20; i++)
2647     if (sha1fpr[i] != fpr[i])
2648       {
2649         xfree (buffer);
2650         log_info (_("fingerprint on card does not match requested one\n"));
2651         return gpg_error (GPG_ERR_WRONG_SECKEY);
2652       }
2653   xfree (buffer);
2654   return 0;
2655 }
2656
2657
2658   /* If a fingerprint has been specified check it against the one on
2659      the card.  This is allows for a meaningful error message in case
2660      the key on the card has been replaced but the shadow information
2661      known to gpg was not updated.  If there is no fingerprint we
2662      assume that this is okay. */
2663 static gpg_error_t
2664 check_against_given_fingerprint (app_t app, const char *fpr, int keyno)
2665 {
2666   unsigned char tmp[20];
2667   const char *s;
2668   int n;
2669
2670   for (s=fpr, n=0; hexdigitp (s); s++, n++)
2671     ;
2672   if (n != 40)
2673     return gpg_error (GPG_ERR_INV_ID);
2674   else if (!*s)
2675     ; /* okay */
2676   else
2677     return gpg_error (GPG_ERR_INV_ID);
2678
2679   for (s=fpr, n=0; n < 20; s += 2, n++)
2680         tmp[n] = xtoi_2 (s);
2681   return compare_fingerprint (app, keyno, tmp);
2682 }
2683
2684
2685
2686 /* Compute a digital signature on INDATA which is expected to be the
2687    raw message digest. For this application the KEYIDSTR consists of
2688    the serialnumber and the fingerprint delimited by a slash.
2689
2690    Note that this function may return the error code
2691    GPG_ERR_WRONG_CARD to indicate that the card currently present does
2692    not match the one required for the requested action (e.g. the
2693    serial number does not match). 
2694    
2695    As a special feature a KEYIDSTR of "OPENPGP.3" redirects the
2696    operation to the auth command.
2697 */
2698 static gpg_error_t 
2699 do_sign (app_t app, const char *keyidstr, int hashalgo,
2700          gpg_error_t (*pincb)(void*, const char *, char **),
2701          void *pincb_arg,
2702          const void *indata, size_t indatalen,
2703          unsigned char **outdata, size_t *outdatalen )
2704 {
2705   static unsigned char rmd160_prefix[15] = /* Object ID is 1.3.36.3.2.1 */
2706     { 0x30, 0x21, 0x30, 0x09, 0x06, 0x05, 0x2b, 0x24, 0x03,
2707       0x02, 0x01, 0x05, 0x00, 0x04, 0x14  };
2708   static unsigned char sha1_prefix[15] =   /* (1.3.14.3.2.26) */
2709     { 0x30, 0x21, 0x30, 0x09, 0x06, 0x05, 0x2b, 0x0e, 0x03,
2710       0x02, 0x1a, 0x05, 0x00, 0x04, 0x14  };
2711   static unsigned char sha224_prefix[19] = /* (2.16.840.1.101.3.4.2.4) */
2712     { 0x30, 0x2D, 0x30, 0x0d, 0x06, 0x09, 0x60, 0x86, 0x48,
2713       0x01, 0x65, 0x03, 0x04, 0x02, 0x04, 0x05, 0x00, 0x04,
2714       0x1C  };
2715   static unsigned char sha256_prefix[19] = /* (2.16.840.1.101.3.4.2.1) */
2716     { 0x30, 0x31, 0x30, 0x0d, 0x06, 0x09, 0x60, 0x86,
2717       0x48, 0x01, 0x65, 0x03, 0x04, 0x02, 0x01, 0x05,
2718       0x00, 0x04, 0x20  };
2719   static unsigned char sha384_prefix[19] = /* (2.16.840.1.101.3.4.2.2) */
2720     { 0x30, 0x41, 0x30, 0x0d, 0x06, 0x09, 0x60, 0x86,
2721       0x48, 0x01, 0x65, 0x03, 0x04, 0x02, 0x02, 0x05,
2722       0x00, 0x04, 0x30  };
2723   static unsigned char sha512_prefix[19] = /* (2.16.840.1.101.3.4.2.3) */
2724     { 0x30, 0x51, 0x30, 0x0d, 0x06, 0x09, 0x60, 0x86,
2725       0x48, 0x01, 0x65, 0x03, 0x04, 0x02, 0x03, 0x05,
2726       0x00, 0x04, 0x40  };
2727   int rc;
2728   unsigned char data[19+64];
2729   size_t datalen;
2730   unsigned char tmp_sn[20]; /* Actually 16 bytes but also for the fpr. */
2731   const char *s;
2732   int n;
2733   const char *fpr = NULL;
2734   unsigned long sigcount;
2735   int use_auth = 0;
2736
2737   if (!keyidstr || !*keyidstr)
2738     return gpg_error (GPG_ERR_INV_VALUE);
2739
2740   /* Strip off known prefixes.  */
2741 #define X(a,b,c,d) \
2742   if (hashalgo == GCRY_MD_ ## a                               \
2743       && (d)                                                  \
2744       && indatalen == sizeof b ## _prefix + (c)               \
2745       && !memcmp (indata, b ## _prefix, sizeof b ## _prefix)) \
2746     {                                                         \
2747       indata = (const char*)indata + sizeof b ## _prefix;     \
2748       indatalen -= sizeof b ## _prefix;                       \
2749     }                                                         
2750
2751   if (indatalen == 20)
2752     ;  /* Assume a plain SHA-1 or RMD160 digest has been given.  */
2753   else X(SHA1,   sha1,   20, 1)
2754   else X(RMD160, rmd160, 20, 1)
2755   else X(SHA224, sha224, 28, app->app_local->extcap.is_v2)
2756   else X(SHA256, sha256, 32, app->app_local->extcap.is_v2)
2757   else X(SHA384, sha384, 48, app->app_local->extcap.is_v2)
2758   else X(SHA512, sha512, 64, app->app_local->extcap.is_v2)
2759   else if ((indatalen == 28 || indatalen == 32 
2760             || indatalen == 48 || indatalen ==64)
2761            && app->app_local->extcap.is_v2)
2762     ;  /* Assume a plain SHA-3 digest has been given.  */
2763   else
2764     {
2765       log_error (_("card does not support digest algorithm %s\n"),
2766                  gcry_md_algo_name (hashalgo));
2767       /* Or the supplied digest length does not match an algorithm.  */
2768       return gpg_error (GPG_ERR_INV_VALUE);
2769     }
2770 #undef X
2771
2772   /* Check whether an OpenPGP card of any version has been requested. */
2773   if (!strcmp (keyidstr, "OPENPGP.1"))
2774     ;
2775   else if (!strcmp (keyidstr, "OPENPGP.3"))
2776     use_auth = 1;
2777   else if (strlen (keyidstr) < 32 || strncmp (keyidstr, "D27600012401", 12))
2778     return gpg_error (GPG_ERR_INV_ID);
2779   else
2780     {
2781       for (s=keyidstr, n=0; hexdigitp (s); s++, n++)
2782         ;
2783       if (n != 32)
2784         return gpg_error (GPG_ERR_INV_ID);
2785       else if (!*s)
2786         ; /* no fingerprint given: we allow this for now. */
2787       else if (*s == '/')
2788         fpr = s + 1; 
2789       else
2790         return gpg_error (GPG_ERR_INV_ID);
2791
2792       for (s=keyidstr, n=0; n < 16; s += 2, n++)
2793         tmp_sn[n] = xtoi_2 (s);
2794
2795       if (app->serialnolen != 16)
2796         return gpg_error (GPG_ERR_INV_CARD);
2797       if (memcmp (app->serialno, tmp_sn, 16))
2798         return gpg_error (GPG_ERR_WRONG_CARD);
2799     }
2800
2801   /* If a fingerprint has been specified check it against the one on
2802      the card.  This is allows for a meaningful error message in case
2803      the key on the card has been replaced but the shadow information
2804      known to gpg was not updated.  If there is no fingerprint, gpg
2805      will detect a bogus signature anyway due to the
2806      verify-after-signing feature. */
2807   rc = fpr? check_against_given_fingerprint (app, fpr, 1) : 0;
2808   if (rc)
2809     return rc;
2810
2811   /* Concatenate prefix and digest.  */
2812 #define X(a,b,d) \
2813   if (hashalgo == GCRY_MD_ ## a && (d) )                      \
2814     {                                                         \
2815       datalen = sizeof b ## _prefix + indatalen;              \
2816       assert (datalen <= sizeof data);                        \
2817       memcpy (data, b ## _prefix, sizeof b ## _prefix);       \
2818       memcpy (data + sizeof b ## _prefix, indata, indatalen); \
2819     }                                                         
2820
2821   X(SHA1,   sha1,   1)
2822   else X(RMD160, rmd160, 1)
2823   else X(SHA224, sha224, app->app_local->extcap.is_v2)
2824   else X(SHA256, sha256, app->app_local->extcap.is_v2)
2825   else X(SHA384, sha384, app->app_local->extcap.is_v2)
2826   else X(SHA512, sha512, app->app_local->extcap.is_v2)
2827   else 
2828     return gpg_error (GPG_ERR_UNSUPPORTED_ALGORITHM);
2829 #undef X
2830
2831   /* Redirect to the AUTH command if asked to. */
2832   if (use_auth)
2833     {
2834       return do_auth (app, "OPENPGP.3", pincb, pincb_arg,
2835                       data, datalen,
2836                       outdata, outdatalen);
2837     }
2838
2839   /* Show the number of signature done using this key.  */
2840   sigcount = get_sig_counter (app);
2841   log_info (_("signatures created so far: %lu\n"), sigcount);
2842
2843   /* Check CHV if needed.  */
2844   if (!app->did_chv1 || app->force_chv1 ) 
2845     {
2846       char *pinvalue;
2847
2848       rc = verify_a_chv (app, pincb, pincb_arg, 1, sigcount, &pinvalue);
2849       if (rc)
2850         return rc;
2851
2852       app->did_chv1 = 1;
2853
2854       /* For cards with versions < 2 we want to keep CHV1 and CHV2 in
2855          sync, thus we verify CHV2 here using the given PIN.  Cards
2856          with version2 to not have the need for a separate CHV2 and
2857          internally use just one.  Obviously we can't do that if the
2858          keypad has been used. */
2859       if (!app->did_chv2 && pinvalue && !app->app_local->extcap.is_v2)
2860         {
2861           rc = iso7816_verify (app->slot, 0x82, pinvalue, strlen (pinvalue));
2862           if (gpg_err_code (rc) == GPG_ERR_BAD_PIN)
2863             rc = gpg_error (GPG_ERR_PIN_NOT_SYNCED);
2864           if (rc)
2865             {
2866               log_error (_("verify CHV%d failed: %s\n"), 2, gpg_strerror (rc));
2867               xfree (pinvalue);
2868               flush_cache_after_error (app);
2869               return rc;
2870             }
2871           app->did_chv2 = 1;
2872         }
2873       xfree (pinvalue);
2874     }
2875
2876   rc = iso7816_compute_ds (app->slot, data, datalen, outdata, outdatalen);
2877   return rc;
2878 }
2879
2880 /* Compute a digital signature using the INTERNAL AUTHENTICATE command
2881    on INDATA which is expected to be the raw message digest. For this
2882    application the KEYIDSTR consists of the serialnumber and the
2883    fingerprint delimited by a slash.  Optionally the id OPENPGP.3 may
2884    be given.
2885
2886    Note that this function may return the error code
2887    GPG_ERR_WRONG_CARD to indicate that the card currently present does
2888    not match the one required for the requested action (e.g. the
2889    serial number does not match). */
2890 static gpg_error_t 
2891 do_auth (app_t app, const char *keyidstr,
2892          gpg_error_t (*pincb)(void*, const char *, char **),
2893          void *pincb_arg,
2894          const void *indata, size_t indatalen,
2895          unsigned char **outdata, size_t *outdatalen )
2896 {
2897   int rc;
2898   unsigned char tmp_sn[20]; /* Actually 16 but we use it also for the fpr. */
2899   const char *s;
2900   int n;
2901   const char *fpr = NULL;
2902
2903   if (!keyidstr || !*keyidstr)
2904     return gpg_error (GPG_ERR_INV_VALUE);
2905   if (indatalen > 101) /* For a 2048 bit key. */
2906     return gpg_error (GPG_ERR_INV_VALUE);
2907
2908   /* Check whether an OpenPGP card of any version has been requested. */
2909   if (!strcmp (keyidstr, "OPENPGP.3"))
2910     ;
2911   else if (strlen (keyidstr) < 32 || strncmp (keyidstr, "D27600012401", 12))
2912     return gpg_error (GPG_ERR_INV_ID);
2913   else
2914     {
2915       for (s=keyidstr, n=0; hexdigitp (s); s++, n++)
2916         ;
2917       if (n != 32)
2918         return gpg_error (GPG_ERR_INV_ID);
2919       else if (!*s)
2920         ; /* no fingerprint given: we allow this for now. */
2921       else if (*s == '/')
2922         fpr = s + 1; 
2923       else
2924         return gpg_error (GPG_ERR_INV_ID);
2925
2926       for (s=keyidstr, n=0; n < 16; s += 2, n++)
2927         tmp_sn[n] = xtoi_2 (s);
2928       
2929       if (app->serialnolen != 16)
2930         return gpg_error (GPG_ERR_INV_CARD);
2931       if (memcmp (app->serialno, tmp_sn, 16))
2932         return gpg_error (GPG_ERR_WRONG_CARD);
2933     }
2934
2935   /* If a fingerprint has been specified check it against the one on
2936      the card.  This is allows for a meaningful error message in case
2937      the key on the card has been replaced but the shadow information
2938      known to gpg was not updated.  If there is no fingerprint, gpg
2939      will detect a bogus signature anyway due to the
2940      verify-after-signing feature. */
2941   rc = fpr? check_against_given_fingerprint (app, fpr, 3) : 0;
2942   if (rc)
2943     return rc;
2944
2945   rc = verify_chv2 (app, pincb, pincb_arg);
2946   if (!rc)
2947     rc = iso7816_internal_authenticate (app->slot, indata, indatalen,
2948                                         outdata, outdatalen);
2949   return rc;
2950 }
2951
2952
2953 static gpg_error_t 
2954 do_decipher (app_t app, const char *keyidstr,
2955              gpg_error_t (*pincb)(void*, const char *, char **),
2956              void *pincb_arg,
2957              const void *indata, size_t indatalen,
2958              unsigned char **outdata, size_t *outdatalen )
2959 {
2960   int rc;
2961   unsigned char tmp_sn[20]; /* actually 16 but we use it also for the fpr. */
2962   const char *s;
2963   int n;
2964   const char *fpr = NULL;
2965
2966   if (!keyidstr || !*keyidstr || !indatalen)
2967     return gpg_error (GPG_ERR_INV_VALUE);
2968
2969   /* Check whether an OpenPGP card of any version has been requested. */
2970   if (!strcmp (keyidstr, "OPENPGP.2"))
2971     ;
2972   else if (strlen (keyidstr) < 32 || strncmp (keyidstr, "D27600012401", 12))
2973     return gpg_error (GPG_ERR_INV_ID);
2974   else
2975     {
2976       for (s=keyidstr, n=0; hexdigitp (s); s++, n++)
2977         ;
2978       if (n != 32)
2979         return gpg_error (GPG_ERR_INV_ID);
2980       else if (!*s)
2981         ; /* no fingerprint given: we allow this for now. */
2982       else if (*s == '/')
2983         fpr = s + 1; 
2984       else
2985         return gpg_error (GPG_ERR_INV_ID);
2986       
2987       for (s=keyidstr, n=0; n < 16; s += 2, n++)
2988         tmp_sn[n] = xtoi_2 (s);
2989       
2990       if (app->serialnolen != 16)
2991         return gpg_error (GPG_ERR_INV_CARD);
2992       if (memcmp (app->serialno, tmp_sn, 16))
2993         return gpg_error (GPG_ERR_WRONG_CARD);
2994     }
2995
2996   /* If a fingerprint has been specified check it against the one on
2997      the card.  This is allows for a meaningful error message in case
2998      the key on the card has been replaced but the shadow information
2999      known to gpg was not updated.  If there is no fingerprint, the
3000      decryption will won't produce the right plaintext anyway. */
3001   rc = fpr? check_against_given_fingerprint (app, fpr, 2) : 0;
3002   if (rc)
3003     return rc;
3004
3005   rc = verify_chv2 (app, pincb, pincb_arg);
3006   if (!rc)
3007     {
3008       size_t fixuplen;
3009
3010       /* We might encounter a couple of leading zeroes in the
3011          cryptogram.  Due to internal use of MPIs thease leading
3012          zeroes are stripped.  However the OpenPGP card expects
3013          exactly 128 bytes for the cryptogram (for a 1k key).  Thus we
3014          need to fix it up.  We do this for up to 16 leading zero
3015          bytes; a cryptogram with more than this is with a very high
3016          probability anyway broken.  */
3017       if (indatalen >= (128-16) && indatalen < 128)      /* 1024 bit key.  */
3018         fixuplen = 128 - indatalen;
3019       else if (indatalen >= (256-16) && indatalen < 256) /* 2048 bit key.  */
3020         fixuplen = 256 - indatalen;
3021       else if (indatalen >= (192-16) && indatalen < 192) /* 1536 bit key.  */
3022         fixuplen = 192 - indatalen;
3023       else
3024         fixuplen = 0;
3025       if (fixuplen)
3026         {
3027           unsigned char *fixbuf;
3028
3029           /* While we have to prepend stuff anyway, we can also
3030              include the padding byte here so that iso1816_decipher
3031              does not need to do yet another data mangling.  */
3032           fixuplen++;
3033           fixbuf = xtrymalloc (fixuplen + indatalen);
3034           if (!fixbuf)
3035             rc = gpg_error_from_syserror ();
3036           else
3037             {
3038               memset (fixbuf, 0, fixuplen);
3039               memcpy (fixbuf+fixuplen, indata, indatalen);
3040               rc = iso7816_decipher (app->slot, fixbuf, fixuplen+indatalen, -1,
3041                                      outdata, outdatalen);
3042               xfree (fixbuf);
3043             }
3044
3045         }
3046       else
3047         rc = iso7816_decipher (app->slot, indata, indatalen, 0,
3048                                outdata, outdatalen);
3049     }
3050   return rc;
3051 }
3052
3053
3054 /* Perform a simple verify operation for CHV1 and CHV2, so that
3055    further operations won't ask for CHV2 and it is possible to do a
3056    cheap check on the PIN: If there is something wrong with the PIN
3057    entry system, only the regular CHV will get blocked and not the
3058    dangerous CHV3.  KEYIDSTR is the usual card's serial number; an
3059    optional fingerprint part will be ignored.
3060
3061    There is a special mode if the keyidstr is "<serialno>[CHV3]" with
3062    the "[CHV3]" being a literal string:  The Admin Pin is checked if
3063    and only if the retry counter is still at 3. */
3064 static gpg_error_t 
3065 do_check_pin (app_t app, const char *keyidstr,
3066               gpg_error_t (*pincb)(void*, const char *, char **),
3067               void *pincb_arg)
3068 {
3069   unsigned char tmp_sn[20]; 
3070   const char *s;
3071   int n;
3072   int admin_pin = 0;
3073
3074   if (!keyidstr || !*keyidstr)
3075     return gpg_error (GPG_ERR_INV_VALUE);
3076
3077   /* Check whether an OpenPGP card of any version has been requested. */
3078   if (strlen (keyidstr) < 32 || strncmp (keyidstr, "D27600012401", 12))
3079     return gpg_error (GPG_ERR_INV_ID);
3080   
3081   for (s=keyidstr, n=0; hexdigitp (s); s++, n++)
3082     ;
3083   if (n != 32)
3084     return gpg_error (GPG_ERR_INV_ID);
3085   else if (!*s)
3086     ; /* No fingerprint given: we allow this for now. */
3087   else if (*s == '/')
3088     ; /* We ignore a fingerprint. */
3089   else if (!strcmp (s, "[CHV3]") )
3090     admin_pin = 1;
3091   else
3092     return gpg_error (GPG_ERR_INV_ID);
3093
3094   for (s=keyidstr, n=0; n < 16; s += 2, n++)
3095     tmp_sn[n] = xtoi_2 (s);
3096
3097   if (app->serialnolen != 16)
3098     return gpg_error (GPG_ERR_INV_CARD);
3099   if (memcmp (app->serialno, tmp_sn, 16))
3100     return gpg_error (GPG_ERR_WRONG_CARD);
3101
3102   /* Yes, there is a race conditions: The user might pull the card
3103      right here and we won't notice that.  However this is not a
3104      problem and the check above is merely for a graceful failure
3105      between operations. */
3106
3107   if (admin_pin)
3108     {
3109       void *relptr;
3110       unsigned char *value;
3111       size_t valuelen;
3112       int count;
3113       
3114       relptr = get_one_do (app, 0x00C4, &value, &valuelen, NULL);
3115       if (!relptr || valuelen < 7)
3116         {
3117           log_error (_("error retrieving CHV status from card\n"));
3118           xfree (relptr);
3119           return gpg_error (GPG_ERR_CARD);
3120         }
3121       count = value[6];
3122       xfree (relptr);
3123
3124       if (!count)
3125         {
3126           log_info (_("card is permanently locked!\n"));
3127           return gpg_error (GPG_ERR_BAD_PIN);
3128         }
3129       else if (value[6] < 3)
3130         {
3131           log_info (_("verification of Admin PIN is currently prohibited "
3132                       "through this command\n"));
3133           return gpg_error (GPG_ERR_GENERAL);
3134         }
3135
3136       app->did_chv3 = 0; /* Force verification.  */
3137       return verify_chv3 (app, pincb, pincb_arg);
3138     }
3139   else
3140     return verify_chv2 (app, pincb, pincb_arg);
3141 }
3142
3143
3144 /* Show information about card capabilities.  */
3145 static void
3146 show_caps (struct app_local_s *s)
3147 {
3148   log_info ("Version-2 ......: %s\n", s->extcap.is_v2? "yes":"no");
3149   log_info ("Get-Challenge ..: %s", s->extcap.get_challenge? "yes":"no");
3150   if (s->extcap.get_challenge)
3151     log_printf (" (%u bytes max)", s->extcap.max_get_challenge);
3152   log_info ("Key-Import .....: %s\n", s->extcap.key_import? "yes":"no");
3153   log_info ("Change-Force-PW1: %s\n", s->extcap.change_force_chv? "yes":"no");
3154   log_info ("Private-DOs ....: %s\n", s->extcap.private_dos? "yes":"no");
3155   log_info ("Algo-Attr-Change: %s\n", s->extcap.algo_attr_change? "yes":"no");
3156   log_info ("SM-Support .....: %s", s->extcap.sm_supported? "yes":"no");
3157   if (s->extcap.sm_supported)
3158     log_printf (" (%s)", s->extcap.sm_aes128? "AES-128":"3DES");
3159   log_info ("Max-Cert3-Len ..: %u\n", s->extcap.max_certlen_3);
3160   log_info ("Max-Cmd-Data ...: %u\n", s->extcap.max_cmd_data);
3161   log_info ("Max-Rsp-Data ...: %u\n", s->extcap.max_rsp_data);
3162   log_info ("Cmd-Chaining ...: %s\n", s->cardcap.cmd_chaining?"yes":"no");
3163   log_info ("Ext-Lc-Le ......: %s\n", s->cardcap.ext_lc_le?"yes":"no");
3164   log_info ("Status Indicator: %02X\n", s->status_indicator);
3165
3166   log_info ("GnuPG-No-Sync ..: %s\n",  s->flags.no_sync? "yes":"no");
3167   log_info ("GnuPG-Def-PW2 ..: %s\n",  s->flags.def_chv2? "yes":"no");
3168 }
3169
3170
3171 /* Parse the historical bytes in BUFFER of BUFLEN and store them in
3172    APPLOC.  */
3173 static void
3174 parse_historical (struct app_local_s *apploc, 
3175                   const unsigned char * buffer, size_t buflen)
3176 {
3177   /* Example buffer: 00 31 C5 73 C0 01 80 00 90 00  */
3178   if (buflen < 4)
3179     {
3180       log_error ("warning: historical bytes are too short\n");
3181       return; /* Too short.  */
3182     }
3183   if (*buffer)
3184     {
3185       log_error ("warning: bad category indicator in historical bytes\n");
3186       return; 
3187     }
3188   
3189   /* Skip category indicator.  */
3190   buffer++;
3191   buflen--;
3192
3193   /* Get the status indicator.  */
3194   apploc->status_indicator = buffer[buflen-3];
3195   buflen -= 3;
3196
3197   /* Parse the compact TLV.  */
3198   while (buflen)
3199     {
3200       unsigned int tag = (*buffer & 0xf0) >> 4;
3201       unsigned int len = (*buffer & 0x0f);
3202       if (len+1 > buflen)
3203         {
3204           log_error ("warning: bad Compact-TLV in historical bytes\n");
3205           return; /* Error.  */
3206         }
3207       buffer++;
3208       buflen--;
3209       if (tag == 7 && len == 3)
3210         {
3211           /* Card capabilities.  */
3212           apploc->cardcap.cmd_chaining = !!(buffer[2] & 0x80);
3213           apploc->cardcap.ext_lc_le    = !!(buffer[2] & 0x40);
3214         }
3215       buffer += len;
3216       buflen -= len;
3217     }
3218 }
3219
3220
3221 /* Parse and optionally show the algorithm attributes for KEYNO.
3222    KEYNO must be in the range 0..2.  */
3223 static void 
3224 parse_algorithm_attribute (app_t app, int keyno)
3225
3226   unsigned char *buffer;
3227   size_t buflen;
3228   void *relptr;
3229   const char const desc[3][5] = {"sign", "encr", "auth"};
3230
3231   assert (keyno >=0 && keyno <= 2);
3232
3233   app->app_local->keyattr[keyno].n_bits = 0;
3234       
3235   relptr = get_one_do (app, 0xC1+keyno, &buffer, &buflen, NULL);
3236   if (!relptr)
3237     {
3238       log_error ("error reading DO 0x%02X\n", 0xc1+keyno);
3239       return;
3240     }
3241   if (buflen < 1)
3242     {
3243       log_error ("error reading DO 0x%02X\n", 0xc1+keyno);
3244       xfree (relptr);
3245       return;
3246     }
3247
3248   if (opt.verbose)
3249     log_info ("Key-Attr-%s ..: ", desc[keyno]);
3250   if (*buffer == 1 && (buflen == 5 || buflen == 6))
3251     {
3252       app->app_local->keyattr[keyno].n_bits = (buffer[1]<<8 | buffer[2]);
3253       app->app_local->keyattr[keyno].e_bits = (buffer[3]<<8 | buffer[4]);
3254       app->app_local->keyattr[keyno].format = 0;
3255       if (buflen < 6)
3256         app->app_local->keyattr[keyno].format = RSA_STD;
3257       else
3258         app->app_local->keyattr[keyno].format = (buffer[5] == 0? RSA_STD   :
3259                                                  buffer[5] == 1? RSA_STD_N :
3260                                                  buffer[5] == 2? RSA_CRT   :
3261                                                  buffer[5] == 3? RSA_CRT_N : 
3262                                                  RSA_UNKNOWN_FMT);
3263
3264       if (opt.verbose)
3265         log_printf
3266           ("RSA, n=%u, e=%u, fmt=%s\n",
3267            app->app_local->keyattr[keyno].n_bits,
3268            app->app_local->keyattr[keyno].e_bits,
3269            app->app_local->keyattr[keyno].format == RSA_STD?  "std"  :
3270            app->app_local->keyattr[keyno].format == RSA_STD_N?"std+n":
3271            app->app_local->keyattr[keyno].format == RSA_CRT?  "crt"  :
3272            app->app_local->keyattr[keyno].format == RSA_CRT_N?"crt+n":"?");
3273     }
3274   else if (opt.verbose)
3275     log_printhex ("", buffer, buflen);
3276
3277   xfree (relptr);
3278 }
3279
3280 /* Select the OpenPGP application on the card in SLOT.  This function
3281    must be used before any other OpenPGP application functions. */
3282 gpg_error_t
3283 app_select_openpgp (app_t app)
3284 {
3285   static char const aid[] = { 0xD2, 0x76, 0x00, 0x01, 0x24, 0x01 };
3286   int slot = app->slot;
3287   int rc;
3288   unsigned char *buffer;
3289   size_t buflen;
3290   void *relptr;
3291   
3292   /* Note that the card can't cope with P2=0xCO, thus we need to pass a
3293      special flag value. */
3294   rc = iso7816_select_application (slot, aid, sizeof aid, 0x0001);
3295   if (!rc)
3296     {
3297       unsigned int manufacturer;
3298
3299       app->apptype = "OPENPGP";
3300
3301       app->did_chv1 = 0;
3302       app->did_chv2 = 0;
3303       app->did_chv3 = 0;
3304       app->app_local = NULL;
3305
3306       /* The OpenPGP card returns the serial number as part of the
3307          AID; because we prefer to use OpenPGP serial numbers, we
3308          replace a possibly already set one from a EF.GDO with this
3309          one.  Note, that for current OpenPGP cards, no EF.GDO exists
3310          and thus it won't matter at all. */
3311       rc = iso7816_get_data (slot, 0x004F, &buffer, &buflen);
3312       if (rc)
3313         goto leave;
3314       if (opt.verbose)
3315         {
3316           log_info ("AID: ");
3317           log_printhex ("", buffer, buflen);
3318         }
3319
3320       app->card_version = buffer[6] << 8;
3321       app->card_version |= buffer[7];
3322       manufacturer = (buffer[8]<<8 | buffer[9]);
3323
3324       xfree (app->serialno);
3325       app->serialno = buffer;
3326       app->serialnolen = buflen;
3327       buffer = NULL;
3328       app->app_local = xtrycalloc (1, sizeof *app->app_local);
3329       if (!app->app_local)
3330         {
3331           rc = gpg_error (gpg_err_code_from_errno (errno));
3332           goto leave;
3333         }
3334
3335       if (app->card_version >= 0x0200)
3336         app->app_local->extcap.is_v2 = 1;
3337
3338
3339       /* Read the historical bytes.  */
3340       relptr = get_one_do (app, 0x5f52, &buffer, &buflen, NULL);
3341       if (relptr)
3342         {
3343           if (opt.verbose)
3344             {
3345               log_info ("Historical Bytes: ");
3346               log_printhex ("", buffer, buflen);
3347             }
3348           parse_historical (app->app_local, buffer, buflen);
3349           xfree (relptr);
3350         }
3351
3352       /* Read the force-chv1 flag.  */
3353       relptr = get_one_do (app, 0x00C4, &buffer, &buflen, NULL);
3354       if (!relptr)
3355         {
3356           log_error (_("can't access %s - invalid OpenPGP card?\n"),
3357                      "CHV Status Bytes");
3358           goto leave;
3359         }
3360       app->force_chv1 = (buflen && *buffer == 0);
3361       xfree (relptr);
3362
3363       /* Read the extended capabilities.  */
3364       relptr = get_one_do (app, 0x00C0, &buffer, &buflen, NULL);
3365       if (!relptr)
3366         {
3367           log_error (_("can't access %s - invalid OpenPGP card?\n"),
3368                      "Extended Capability Flags" );
3369           goto leave;
3370         }
3371       if (buflen)
3372         {
3373           app->app_local->extcap.sm_supported     = !!(*buffer & 0x80);
3374           app->app_local->extcap.get_challenge    = !!(*buffer & 0x40);
3375           app->app_local->extcap.key_import       = !!(*buffer & 0x20);
3376           app->app_local->extcap.change_force_chv = !!(*buffer & 0x10);
3377           app->app_local->extcap.private_dos      = !!(*buffer & 0x08);
3378           app->app_local->extcap.algo_attr_change = !!(*buffer & 0x04);
3379         }
3380       if (buflen >= 10)
3381         {
3382           /* Available with v2 cards.  */
3383           app->app_local->extcap.sm_aes128     = (buffer[1] == 1);
3384           app->app_local->extcap.max_get_challenge 
3385                                                = (buffer[2] << 8 | buffer[3]);
3386           app->app_local->extcap.max_certlen_3 = (buffer[4] << 8 | buffer[5]);
3387           app->app_local->extcap.max_cmd_data  = (buffer[6] << 8 | buffer[7]);
3388           app->app_local->extcap.max_rsp_data  = (buffer[8] << 8 | buffer[9]);
3389         }
3390       xfree (relptr);
3391
3392       /* Some of the first cards accidently don't set the
3393          CHANGE_FORCE_CHV bit but allow it anyway. */
3394       if (app->card_version <= 0x0100 && manufacturer == 1)
3395         app->app_local->extcap.change_force_chv = 1;
3396
3397       parse_login_data (app);
3398
3399       if (opt.verbose)
3400         show_caps (app->app_local);
3401
3402       parse_algorithm_attribute (app, 0);
3403       parse_algorithm_attribute (app, 1);
3404       parse_algorithm_attribute (app, 2);
3405       
3406       if (opt.verbose > 1)
3407         dump_all_do (slot);
3408
3409       app->fnc.deinit = do_deinit;
3410       app->fnc.learn_status = do_learn_status;
3411       app->fnc.readcert = do_readcert;
3412       app->fnc.readkey = do_readkey;
3413       app->fnc.getattr = do_getattr;
3414       app->fnc.setattr = do_setattr;
3415       app->fnc.writecert = do_writecert;
3416       app->fnc.writekey = do_writekey;
3417       app->fnc.genkey = do_genkey;
3418       app->fnc.sign = do_sign;
3419       app->fnc.auth = do_auth;
3420       app->fnc.decipher = do_decipher;
3421       app->fnc.change_pin = do_change_pin;
3422       app->fnc.check_pin = do_check_pin;
3423    }
3424
3425 leave:
3426   if (rc)
3427     do_deinit (app);
3428   return rc;
3429 }
3430
3431
3432