app-openpgp changes
[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 usually 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
750 static void
751 send_key_attr (ctrl_t ctrl, app_t app, const char *keyword, int number)
752 {                      
753   char buffer[200];
754
755   assert (number >=0 && number < DIM(app->app_local->keyattr));
756
757   /* We only support RSA thus the algo identifier is fixed to 1.  */
758   snprintf (buffer, sizeof buffer, "%d 1 %u %u %d",
759             number+1,
760             app->app_local->keyattr[number].n_bits,
761             app->app_local->keyattr[number].e_bits,
762             app->app_local->keyattr[number].format);
763   send_status_direct (ctrl, keyword, buffer);
764 }
765
766
767 /* Implement the GETATTR command.  This is similar to the LEARN
768    command but returns just one value via the status interface. */
769 static gpg_error_t 
770 do_getattr (app_t app, ctrl_t ctrl, const char *name)
771 {
772   static struct {
773     const char *name;
774     int tag;
775     int special;
776   } table[] = {
777     { "DISP-NAME",    0x005B },
778     { "LOGIN-DATA",   0x005E },
779     { "DISP-LANG",    0x5F2D },
780     { "DISP-SEX",     0x5F35 },
781     { "PUBKEY-URL",   0x5F50 },
782     { "KEY-FPR",      0x00C5, 3 },
783     { "KEY-TIME",     0x00CD, 4 },
784     { "KEY-ATTR",     0x0000, -5 },
785     { "CA-FPR",       0x00C6, 3 },
786     { "CHV-STATUS",   0x00C4, 1 }, 
787     { "SIG-COUNTER",  0x0093, 2 },
788     { "SERIALNO",     0x004F, -1 },
789     { "AID",          0x004F },
790     { "EXTCAP",       0x0000, -2 },
791     { "PRIVATE-DO-1", 0x0101 },
792     { "PRIVATE-DO-2", 0x0102 },
793     { "PRIVATE-DO-3", 0x0103 },
794     { "PRIVATE-DO-4", 0x0104 },
795     { "$AUTHKEYID",   0x0000, -3 },
796     { "$DISPSERIALNO",0x0000, -4 },
797     { NULL, 0 }
798   };
799   int idx, i, rc;
800   void *relptr;
801   unsigned char *value;
802   size_t valuelen;
803
804   for (idx=0; table[idx].name && strcmp (table[idx].name, name); idx++)
805     ;
806   if (!table[idx].name)
807     return gpg_error (GPG_ERR_INV_NAME); 
808   
809   if (table[idx].special == -1)
810     {
811       /* The serial number is very special.  We could have used the
812          AID DO to retrieve it, but we have it already in the app
813          context and the stamp argument is required anyway which we
814          can't by other means. The AID DO is available anyway but not
815          hex formatted. */
816       char *serial;
817       time_t stamp;
818       char tmp[50];
819
820       if (!app_get_serial_and_stamp (app, &serial, &stamp))
821         {
822           sprintf (tmp, "%lu", (unsigned long)stamp);
823           send_status_info (ctrl, "SERIALNO",
824                             serial, strlen (serial),
825                             tmp, strlen (tmp),
826                             NULL, 0);
827           xfree (serial);
828         }
829       return 0;
830     }
831   if (table[idx].special == -2)
832     {
833       char tmp[100];
834
835       snprintf (tmp, sizeof tmp,
836                 "gc=%d ki=%d fc=%d pd=%d mcl3=%u aac=%d sm=%d", 
837                 app->app_local->extcap.get_challenge,
838                 app->app_local->extcap.key_import,
839                 app->app_local->extcap.change_force_chv,
840                 app->app_local->extcap.private_dos,
841                 app->app_local->extcap.max_certlen_3,
842                 app->app_local->extcap.algo_attr_change,
843                 (app->app_local->extcap.sm_supported
844                  ? (app->app_local->extcap.sm_aes128? 7 : 2)
845                  : 0));
846       send_status_info (ctrl, table[idx].name, tmp, strlen (tmp), NULL, 0);
847       return 0;
848     }
849   if (table[idx].special == -3)
850     {
851       char const tmp[] = "OPENPGP.3";
852       send_status_info (ctrl, table[idx].name, tmp, strlen (tmp), NULL, 0);
853       return 0;
854     }
855   if (table[idx].special == -4)
856     {
857       char *serial;
858       time_t stamp;
859     
860       if (!app_get_serial_and_stamp (app, &serial, &stamp))
861         {
862           if (strlen (serial) > 16+12)
863             {
864               send_status_info (ctrl, table[idx].name, serial+16, 12, NULL, 0);
865               xfree (serial);
866               return 0;
867             }
868           xfree (serial);
869         }
870       return gpg_error (GPG_ERR_INV_NAME); 
871     }
872   if (table[idx].special == -5)
873     {
874       for (i=0; i < 3; i++)
875         send_key_attr (ctrl, app, table[idx].name, i);
876       return 0;
877     }
878
879   relptr = get_one_do (app, table[idx].tag, &value, &valuelen, &rc);
880   if (relptr)
881     {
882       if (table[idx].special == 1)
883         {
884           char numbuf[7*23];
885           
886           for (i=0,*numbuf=0; i < valuelen && i < 7; i++)
887             sprintf (numbuf+strlen (numbuf), " %d", value[i]); 
888           send_status_info (ctrl, table[idx].name,
889                             numbuf, strlen (numbuf), NULL, 0);
890         }
891       else if (table[idx].special == 2)
892         {
893           char numbuf[50];
894
895           sprintf (numbuf, "%lu", convert_sig_counter_value (value, valuelen));
896           send_status_info (ctrl, table[idx].name,
897                             numbuf, strlen (numbuf), NULL, 0);
898         }
899       else if (table[idx].special == 3)
900         {
901           if (valuelen >= 60)
902             for (i=0; i < 3; i++)
903               send_fpr_if_not_null (ctrl, table[idx].name, i+1, value+i*20);
904         }
905       else if (table[idx].special == 4)
906         {
907           if (valuelen >= 12)
908             for (i=0; i < 3; i++)
909               send_fprtime_if_not_null (ctrl, table[idx].name, i+1, value+i*4);
910         }
911       else
912         send_status_info (ctrl, table[idx].name, value, valuelen, NULL, 0);
913
914       xfree (relptr);
915     }
916   return rc;
917 }
918
919 /* Retrieve the fingerprint from the card inserted in SLOT and write
920    the according hex representation to FPR.  Caller must have provide
921    a buffer at FPR of least 41 bytes.  Returns 0 on success or an
922    error code. */
923 #if GNUPG_MAJOR_VERSION > 1
924 static gpg_error_t
925 retrieve_fpr_from_card (app_t app, int keyno, char *fpr)
926 {
927   gpg_error_t err = 0;
928   void *relptr;
929   unsigned char *value;
930   size_t valuelen;
931
932   assert (keyno >=0 && keyno <= 2);
933
934   relptr = get_one_do (app, 0x00C5, &value, &valuelen, NULL);
935   if (relptr && valuelen >= 60)
936     bin2hex (value+keyno*20, 20, fpr);
937   else
938     err = gpg_error (GPG_ERR_NOT_FOUND);
939   xfree (relptr);
940   return err;
941 }
942 #endif /*GNUPG_MAJOR_VERSION > 1*/
943
944
945 /* Retrieve the public key material for the RSA key, whose fingerprint
946    is FPR, from gpg output, which can be read through the stream FP.
947    The RSA modulus will be stored at the address of M and MLEN, the
948    public exponent at E and ELEN.  Returns zero on success, an error
949    code on failure.  Caller must release the allocated buffers at M
950    and E if the function returns success.  */
951 #if GNUPG_MAJOR_VERSION > 1
952 static gpg_error_t
953 retrieve_key_material (FILE *fp, const char *hexkeyid,
954                        const unsigned char **m, size_t *mlen,
955                        const unsigned char **e, size_t *elen)
956 {
957   gcry_error_t err = 0;
958   char *line = NULL;    /* read_line() buffer. */
959   size_t line_size = 0; /* Helper for for read_line. */
960   int found_key = 0;    /* Helper to find a matching key. */
961   unsigned char *m_new = NULL;
962   unsigned char *e_new = NULL;
963   size_t m_new_n = 0;
964   size_t e_new_n = 0;
965
966   /* Loop over all records until we have found the subkey
967      corresponding to the fingerprint. Inm general the first record
968      should be the pub record, but we don't rely on that.  Given that
969      we only need to look at one key, it is sufficient to compare the
970      keyid so that we don't need to look at "fpr" records. */
971   for (;;)
972     {
973       char *p;
974       char *fields[6];
975       int nfields;
976       size_t max_length;
977       gcry_mpi_t mpi;
978       int i;
979
980       max_length = 4096;
981       i = read_line (fp, &line, &line_size, &max_length);
982       if (!i)
983         break; /* EOF. */
984       if (i < 0)
985         {
986           err = gpg_error_from_syserror ();
987           goto leave; /* Error. */
988         }
989       if (!max_length)
990         {
991           err = gpg_error (GPG_ERR_TRUNCATED);
992           goto leave;  /* Line truncated - we better stop processing.  */
993         }
994
995       /* Parse the line into fields. */
996       for (nfields=0, p=line; p && nfields < DIM (fields); nfields++)
997         {
998           fields[nfields] = p;
999           p = strchr (p, ':');
1000           if (p)
1001             *(p++) = 0;
1002         }
1003       if (!nfields)
1004         continue; /* No fields at all - skip line.  */
1005
1006       if (!found_key)
1007         {
1008           if ( (!strcmp (fields[0], "sub") || !strcmp (fields[0], "pub") )
1009                && nfields > 4 && !strcmp (fields[4], hexkeyid))
1010             found_key = 1;
1011           continue;
1012         }
1013       
1014       if ( !strcmp (fields[0], "sub") || !strcmp (fields[0], "pub") )
1015         break; /* Next key - stop.  */
1016
1017       if ( strcmp (fields[0], "pkd") )
1018         continue; /* Not a key data record.  */
1019       i = 0; /* Avoid erroneous compiler warning. */
1020       if ( nfields < 4 || (i = atoi (fields[1])) < 0 || i > 1
1021            || (!i && m_new) || (i && e_new))
1022         {
1023           err = gpg_error (GPG_ERR_GENERAL);
1024           goto leave; /* Error: Invalid key data record or not an RSA key.  */
1025         }
1026       
1027       err = gcry_mpi_scan (&mpi, GCRYMPI_FMT_HEX, fields[3], 0, NULL);
1028       if (err)
1029         mpi = NULL;
1030       else if (!i)
1031         err = gcry_mpi_aprint (GCRYMPI_FMT_STD, &m_new, &m_new_n, mpi);
1032       else
1033         err = gcry_mpi_aprint (GCRYMPI_FMT_STD, &e_new, &e_new_n, mpi);
1034       gcry_mpi_release (mpi);
1035       if (err)
1036         goto leave;
1037     }
1038   
1039   if (m_new && e_new)
1040     {
1041       *m = m_new;
1042       *mlen = m_new_n;
1043       m_new = NULL;
1044       *e = e_new;
1045       *elen = e_new_n;
1046       e_new = NULL;
1047     }
1048   else
1049     err = gpg_error (GPG_ERR_GENERAL);
1050
1051  leave:
1052   xfree (m_new);
1053   xfree (e_new);
1054   xfree (line);
1055   return err;
1056 }
1057 #endif /*GNUPG_MAJOR_VERSION > 1*/
1058
1059
1060 /* Get the public key for KEYNO and store it as an S-expresion with
1061    the APP handle.  On error that field gets cleared.  If we already
1062    know about the public key we will just return.  Note that this does
1063    not mean a key is available; this is soley indicated by the
1064    presence of the app->app_local->pk[KEYNO-1].key field.
1065
1066    Note that GnuPG 1.x does not need this and it would be too time
1067    consuming to send it just for the fun of it. However, given that we
1068    use the same code in gpg 1.4, we can't use the gcry S-expresion
1069    here but need to open encode it. */
1070 #if GNUPG_MAJOR_VERSION > 1
1071 static gpg_error_t
1072 get_public_key (app_t app, int keyno)
1073 {
1074   gpg_error_t err = 0;
1075   unsigned char *buffer;
1076   const unsigned char *keydata, *m, *e;
1077   size_t buflen, keydatalen, mlen, elen;
1078   unsigned char *mbuf = NULL;
1079   unsigned char *ebuf = NULL;
1080   char *keybuf = NULL;
1081   char *keybuf_p;
1082
1083   if (keyno < 1 || keyno > 3)
1084     return gpg_error (GPG_ERR_INV_ID);
1085   keyno--;
1086
1087   /* Already cached? */
1088   if (app->app_local->pk[keyno].read_done)
1089     return 0;
1090
1091   xfree (app->app_local->pk[keyno].key);
1092   app->app_local->pk[keyno].key = NULL;
1093   app->app_local->pk[keyno].keylen = 0;
1094
1095   m = e = NULL; /* (avoid cc warning) */
1096
1097   if (app->card_version > 0x0100)
1098     {
1099       /* We may simply read the public key out of these cards.  */
1100       err = iso7816_read_public_key 
1101         (app->slot, 0, (const unsigned char*)(keyno == 0? "\xB6" :
1102                                               keyno == 1? "\xB8" : "\xA4"), 2,  
1103          0,
1104          &buffer, &buflen);
1105       if (err)
1106         {
1107           log_error (_("reading public key failed: %s\n"), gpg_strerror (err));
1108           goto leave;
1109         }
1110
1111       keydata = find_tlv (buffer, buflen, 0x7F49, &keydatalen);
1112       if (!keydata)
1113         {
1114           err = gpg_error (GPG_ERR_CARD);
1115           log_error (_("response does not contain the public key data\n"));
1116           goto leave;
1117         }
1118  
1119       m = find_tlv (keydata, keydatalen, 0x0081, &mlen);
1120       if (!m)
1121         {
1122           err = gpg_error (GPG_ERR_CARD);
1123           log_error (_("response does not contain the RSA modulus\n"));
1124           goto leave;
1125         }
1126       
1127
1128       e = find_tlv (keydata, keydatalen, 0x0082, &elen);
1129       if (!e)
1130         {
1131           err = gpg_error (GPG_ERR_CARD);
1132           log_error (_("response does not contain the RSA public exponent\n"));
1133           goto leave;
1134         }
1135
1136       /* Prepend numbers with a 0 if needed.  */
1137       if (mlen && (*m & 0x80))
1138         {
1139           mbuf = xtrymalloc ( mlen + 1);
1140           if (!mbuf)
1141             {
1142               err = gpg_error_from_syserror ();
1143               goto leave;
1144             }
1145           *mbuf = 0;
1146           memcpy (mbuf+1, m, mlen);
1147           mlen++;
1148           m = mbuf;
1149         }
1150       if (elen && (*e & 0x80))
1151         {
1152           ebuf = xtrymalloc ( elen + 1);
1153           if (!ebuf)
1154             {
1155               err = gpg_error_from_syserror ();
1156               goto leave;
1157             }
1158           *ebuf = 0;
1159           memcpy (ebuf+1, e, elen);
1160           elen++;
1161           e = ebuf;
1162         }
1163
1164     }
1165   else
1166     {
1167       /* Due to a design problem in v1.0 cards we can't get the public
1168          key out of these cards without doing a verify on CHV3.
1169          Clearly that is not an option and thus we try to locate the
1170          key using an external helper.
1171
1172          The helper we use here is gpg itself, which should know about
1173          the key in any case.  */
1174
1175       char fpr[41];
1176       char *hexkeyid;
1177       char *command = NULL;
1178       FILE *fp;
1179       int ret;
1180
1181       buffer = NULL; /* We don't need buffer.  */
1182
1183       err = retrieve_fpr_from_card (app, keyno, fpr);
1184       if (err)
1185         {
1186           log_error ("error while retrieving fpr from card: %s\n",
1187                      gpg_strerror (err));
1188           goto leave;
1189         }
1190       hexkeyid = fpr + 24;
1191
1192       ret = estream_asprintf (&command,
1193                               "gpg --list-keys --with-colons --with-key-data '%s'",
1194                               fpr);
1195       if (ret < 0)
1196         {
1197           err = gpg_error_from_syserror ();
1198           goto leave;
1199         }
1200
1201       fp = popen (command, "r");
1202       xfree (command);
1203       if (!fp)
1204         {
1205           err = gpg_error_from_syserror ();
1206           log_error ("running gpg failed: %s\n", gpg_strerror (err));
1207           goto leave;
1208         }
1209
1210       err = retrieve_key_material (fp, hexkeyid, &m, &mlen, &e, &elen);
1211       fclose (fp);
1212       if (err)
1213         {
1214           log_error ("error while retrieving key material through pipe: %s\n",
1215                      gpg_strerror (err));
1216           goto leave;
1217         }
1218     }
1219
1220   /* Allocate a buffer to construct the S-expression.  */
1221   /* FIXME: We should provide a generalized S-expression creation
1222      mechanism. */
1223   keybuf = xtrymalloc (50 + 2*35 + mlen + elen + 1);
1224   if (!keybuf)
1225     {
1226       err = gpg_error_from_syserror ();
1227       goto leave;
1228     }
1229   
1230   sprintf (keybuf, "(10:public-key(3:rsa(1:n%u:", (unsigned int) mlen);
1231   keybuf_p = keybuf + strlen (keybuf);
1232   memcpy (keybuf_p, m, mlen);
1233   keybuf_p += mlen;
1234   sprintf (keybuf_p, ")(1:e%u:", (unsigned int)elen);
1235   keybuf_p += strlen (keybuf_p);
1236   memcpy (keybuf_p, e, elen);
1237   keybuf_p += elen;
1238   strcpy (keybuf_p, ")))");
1239   keybuf_p += strlen (keybuf_p);
1240   
1241   app->app_local->pk[keyno].key = (unsigned char*)keybuf;
1242   app->app_local->pk[keyno].keylen = (keybuf_p - keybuf);
1243
1244  leave:
1245   /* Set a flag to indicate that we tried to read the key.  */
1246   app->app_local->pk[keyno].read_done = 1;
1247
1248   xfree (buffer);
1249   xfree (mbuf);
1250   xfree (ebuf);
1251   return 0;
1252 }
1253 #endif /* GNUPG_MAJOR_VERSION > 1 */
1254
1255
1256
1257 /* Send the KEYPAIRINFO back. KEYNO needs to be in the range [1,3].
1258    This is used by the LEARN command. */
1259 static gpg_error_t
1260 send_keypair_info (app_t app, ctrl_t ctrl, int keyno)
1261 {
1262   gpg_error_t err = 0;
1263   /* Note that GnuPG 1.x does not need this and it would be too time
1264      consuming to send it just for the fun of it. */
1265 #if GNUPG_MAJOR_VERSION > 1
1266   unsigned char grip[20];
1267   char gripstr[41];
1268   char idbuf[50];
1269
1270   err = get_public_key (app, keyno);
1271   if (err)
1272     goto leave;
1273   
1274   assert (keyno >= 1 && keyno <= 3);
1275   if (!app->app_local->pk[keyno-1].key)
1276     goto leave; /* No such key - ignore. */
1277
1278   err = keygrip_from_canon_sexp (app->app_local->pk[keyno-1].key,
1279                                  app->app_local->pk[keyno-1].keylen,
1280                                  grip);
1281   if (err)
1282     goto leave;
1283   
1284   bin2hex (grip, 20, gripstr);
1285
1286   sprintf (idbuf, "OPENPGP.%d", keyno);
1287   send_status_info (ctrl, "KEYPAIRINFO", 
1288                     gripstr, 40, 
1289                     idbuf, strlen (idbuf), 
1290                     NULL, (size_t)0);
1291
1292  leave:
1293 #endif /* GNUPG_MAJOR_VERSION > 1 */
1294
1295   return err; 
1296 }
1297
1298
1299 /* Handle the LEARN command for OpenPGP.  */
1300 static gpg_error_t
1301 do_learn_status (app_t app, ctrl_t ctrl, unsigned int flags)
1302 {
1303   (void)flags;
1304   
1305   do_getattr (app, ctrl, "EXTCAP");
1306   do_getattr (app, ctrl, "DISP-NAME");
1307   do_getattr (app, ctrl, "DISP-LANG");
1308   do_getattr (app, ctrl, "DISP-SEX");
1309   do_getattr (app, ctrl, "PUBKEY-URL");
1310   do_getattr (app, ctrl, "LOGIN-DATA");
1311   do_getattr (app, ctrl, "KEY-FPR");
1312   if (app->card_version > 0x0100)
1313     do_getattr (app, ctrl, "KEY-TIME");
1314   do_getattr (app, ctrl, "CA-FPR");
1315   do_getattr (app, ctrl, "CHV-STATUS");
1316   do_getattr (app, ctrl, "SIG-COUNTER");
1317   if (app->app_local->extcap.private_dos)
1318     {
1319       do_getattr (app, ctrl, "PRIVATE-DO-1");
1320       do_getattr (app, ctrl, "PRIVATE-DO-2");
1321       if (app->did_chv2)
1322         do_getattr (app, ctrl, "PRIVATE-DO-3");
1323       if (app->did_chv3)
1324         do_getattr (app, ctrl, "PRIVATE-DO-4");
1325     }
1326   send_keypair_info (app, ctrl, 1);
1327   send_keypair_info (app, ctrl, 2);
1328   send_keypair_info (app, ctrl, 3);
1329   /* Note: We do not send the Cardholder Certificate, because that is
1330      relativly long and for OpenPGP applications not really needed.  */
1331   return 0;
1332 }
1333
1334
1335 /* Handle the READKEY command for OpenPGP.  On success a canonical
1336    encoded S-expression with the public key will get stored at PK and
1337    its length (for assertions) at PKLEN; the caller must release that
1338    buffer. On error PK and PKLEN are not changed and an error code is
1339    returned.  */
1340 static gpg_error_t
1341 do_readkey (app_t app, const char *keyid, unsigned char **pk, size_t *pklen)
1342 {
1343 #if GNUPG_MAJOR_VERSION > 1
1344   gpg_error_t err;
1345   int keyno;
1346   unsigned char *buf;
1347
1348   if (!strcmp (keyid, "OPENPGP.1"))
1349     keyno = 1;
1350   else if (!strcmp (keyid, "OPENPGP.2"))
1351     keyno = 2;
1352   else if (!strcmp (keyid, "OPENPGP.3"))
1353     keyno = 3;
1354   else
1355     return gpg_error (GPG_ERR_INV_ID);
1356
1357   err = get_public_key (app, keyno);
1358   if (err)
1359     return err;
1360
1361   buf = app->app_local->pk[keyno-1].key;
1362   if (!buf)
1363     return gpg_error (GPG_ERR_NO_PUBKEY);
1364   *pklen = app->app_local->pk[keyno-1].keylen;;
1365   *pk = xtrymalloc (*pklen);
1366   if (!*pk)
1367     {
1368       err = gpg_error_from_syserror ();
1369       *pklen = 0;
1370       return err;
1371     }
1372   memcpy (*pk, buf, *pklen);
1373   return 0;
1374 #else
1375   return gpg_error (GPG_ERR_NOT_IMPLEMENTED);
1376 #endif
1377 }
1378
1379 /* Read the standard certificate of an OpenPGP v2 card.  It is
1380    returned in a freshly allocated buffer with that address stored at
1381    CERT and the length of the certificate stored at CERTLEN.  CERTID
1382    needs to be set to "OPENPGP.3".  */
1383 static gpg_error_t
1384 do_readcert (app_t app, const char *certid,
1385              unsigned char **cert, size_t *certlen)
1386 {
1387 #if GNUPG_MAJOR_VERSION > 1
1388   gpg_error_t err;
1389   unsigned char *buffer;
1390   size_t buflen;
1391   void *relptr;
1392
1393   *cert = NULL;
1394   *certlen = 0;
1395   if (strcmp (certid, "OPENPGP.3"))
1396     return gpg_error (GPG_ERR_INV_ID);
1397   if (!app->app_local->extcap.is_v2)
1398     return gpg_error (GPG_ERR_NOT_FOUND);
1399
1400   relptr = get_one_do (app, 0x7F21, &buffer, &buflen, NULL);
1401   if (!relptr)
1402     return gpg_error (GPG_ERR_NOT_FOUND);
1403
1404   if (!buflen)
1405     err = gpg_error (GPG_ERR_NOT_FOUND);
1406   else if (!(*cert = xtrymalloc (buflen)))
1407     err = gpg_error_from_syserror ();
1408   else
1409     {
1410       memcpy (*cert, buffer, buflen);
1411       *certlen = buflen;
1412       err  = 0;
1413     }
1414   xfree (relptr);
1415   return err;
1416 #else
1417   return gpg_error (GPG_ERR_NOT_IMPLEMENTED);
1418 #endif
1419 }
1420
1421
1422 /* Verify a CHV either using using the pinentry or if possibile by
1423    using a keypad.  PINCB and PINCB_ARG describe the usual callback
1424    for the pinentry.  CHVNO must be either 1 or 2. SIGCOUNT is only
1425    used with CHV1.  PINVALUE is the address of a pointer which will
1426    receive a newly allocated block with the actual PIN (this is useful
1427    in case that PIN shall be used for another verify operation).  The
1428    caller needs to free this value.  If the function returns with
1429    success and NULL is stored at PINVALUE, the caller should take this
1430    as an indication that the keypad has been used.
1431    */
1432 static gpg_error_t
1433 verify_a_chv (app_t app,
1434               gpg_error_t (*pincb)(void*, const char *, char **),
1435               void *pincb_arg,
1436               int chvno, unsigned long sigcount, char **pinvalue)
1437 {
1438   int rc = 0;
1439   char *prompt_buffer = NULL;
1440   const char *prompt;
1441   iso7816_pininfo_t pininfo;
1442   int minlen = 6;
1443
1444   assert (chvno == 1 || chvno == 2);
1445
1446   *pinvalue = NULL;
1447
1448   if (chvno == 2 && app->app_local->flags.def_chv2)
1449     {
1450       /* Special case for def_chv2 mechanism. */
1451       if (opt.verbose)
1452         log_info (_("using default PIN as %s\n"), "CHV2");
1453       rc = iso7816_verify (app->slot, 0x82, "123456", 6);
1454       if (rc)
1455         {
1456           /* Verification of CHV2 with the default PIN failed,
1457              although the card pretends to have the default PIN set as
1458              CHV2.  We better disable the def_chv2 flag now. */
1459           log_info (_("failed to use default PIN as %s: %s"
1460                       " - disabling further default use\n"),
1461                     "CHV2", gpg_strerror (rc));
1462           app->app_local->flags.def_chv2 = 0;
1463         }
1464       return rc;
1465     }
1466
1467   memset (&pininfo, 0, sizeof pininfo);
1468   pininfo.mode = 1;
1469   pininfo.minlen = minlen;
1470
1471
1472   if (chvno == 1)
1473     {
1474 #define PROMPTSTRING  _("||Please enter the PIN%%0A[sigs done: %lu]")
1475       size_t promptsize = strlen (PROMPTSTRING) + 50;
1476
1477       prompt_buffer = xtrymalloc (promptsize);
1478       if (!prompt_buffer)
1479         return gpg_error_from_syserror ();
1480       snprintf (prompt_buffer, promptsize-1, PROMPTSTRING, sigcount);
1481       prompt = prompt_buffer;
1482 #undef PROMPTSTRING
1483     }
1484   else
1485     prompt = _("||Please enter the PIN");
1486
1487   
1488   if (!opt.disable_keypad
1489       && !iso7816_check_keypad (app->slot, ISO7816_VERIFY, &pininfo) )
1490     {
1491       /* The reader supports the verify command through the keypad.
1492          Note that the pincb appends a text to the prompt telling the
1493          user to use the keypad. */
1494       rc = pincb (pincb_arg, prompt, NULL); 
1495       prompt = NULL;
1496       xfree (prompt_buffer); 
1497       prompt_buffer = NULL;
1498       if (rc)
1499         {
1500           log_info (_("PIN callback returned error: %s\n"),
1501                     gpg_strerror (rc));
1502           return rc;
1503         }
1504       rc = iso7816_verify_kp (app->slot, 0x80+chvno, "", 0, &pininfo); 
1505       /* Dismiss the prompt. */
1506       pincb (pincb_arg, NULL, NULL);
1507
1508       assert (!*pinvalue);
1509     }
1510   else
1511     {
1512       /* The reader has no keypad or we don't want to use it. */
1513       rc = pincb (pincb_arg, prompt, pinvalue); 
1514       prompt = NULL;
1515       xfree (prompt_buffer); 
1516       prompt_buffer = NULL;
1517       if (rc)
1518         {
1519           log_info (_("PIN callback returned error: %s\n"),
1520                     gpg_strerror (rc));
1521           return rc;
1522         }
1523       
1524       if (strlen (*pinvalue) < minlen)
1525         {
1526           log_error (_("PIN for CHV%d is too short;"
1527                        " minimum length is %d\n"), chvno, minlen);
1528           xfree (*pinvalue);
1529           *pinvalue = NULL;
1530           return gpg_error (GPG_ERR_BAD_PIN);
1531         }
1532
1533       rc = iso7816_verify (app->slot, 0x80+chvno,
1534                            *pinvalue, strlen (*pinvalue));
1535     }
1536   
1537   if (rc)
1538     {
1539       log_error (_("verify CHV%d failed: %s\n"), chvno, gpg_strerror (rc));
1540       xfree (*pinvalue);
1541       *pinvalue = NULL;
1542       flush_cache_after_error (app);
1543     }
1544
1545   return rc;
1546 }
1547
1548
1549 /* Verify CHV2 if required.  Depending on the configuration of the
1550    card CHV1 will also be verified. */
1551 static gpg_error_t
1552 verify_chv2 (app_t app,
1553              gpg_error_t (*pincb)(void*, const char *, char **),
1554              void *pincb_arg)
1555 {
1556   int rc;
1557   char *pinvalue;
1558
1559   if (app->did_chv2) 
1560     return 0;  /* We already verified CHV2 (PW1 for v2 cards).  */
1561
1562   if (app->app_local->extcap.is_v2)
1563     {
1564       /* Version two cards don't have a CHV2 anymore.  We need to
1565          verify CHV1 (now called PW1) instead.  */
1566       rc = verify_a_chv (app, pincb, pincb_arg, 1, 0, &pinvalue);
1567       if (rc)
1568         return rc;
1569       app->did_chv2 = 1;
1570     }
1571   else
1572     {
1573       /* Version 1 cards only.  */
1574       rc = verify_a_chv (app, pincb, pincb_arg, 2, 0, &pinvalue);
1575       if (rc)
1576         return rc;
1577       app->did_chv2 = 1;
1578   
1579       if (!app->did_chv1 && !app->force_chv1 && pinvalue)
1580         {
1581           /* For convenience we verify CHV1 here too.  We do this only
1582              if the card is not configured to require a verification
1583              before each CHV1 controlled operation (force_chv1) and if
1584              we are not using the keypad (PINVALUE == NULL). */
1585           rc = iso7816_verify (app->slot, 0x81, pinvalue, strlen (pinvalue));
1586           if (gpg_err_code (rc) == GPG_ERR_BAD_PIN)
1587             rc = gpg_error (GPG_ERR_PIN_NOT_SYNCED);
1588           if (rc)
1589             {
1590               log_error (_("verify CHV%d failed: %s\n"), 1, gpg_strerror (rc));
1591               flush_cache_after_error (app);
1592             }
1593           else
1594             app->did_chv1 = 1;
1595         }
1596     }
1597   xfree (pinvalue);
1598
1599   return rc;
1600 }
1601
1602
1603 /* Build the prompt to enter the Admin PIN.  The prompt depends on the
1604    current sdtate of the card.  */
1605 static gpg_error_t 
1606 build_enter_admin_pin_prompt (app_t app, char **r_prompt)
1607 {
1608   void *relptr;
1609   unsigned char *value;
1610   size_t valuelen;
1611   int remaining;
1612   char *prompt;
1613
1614   *r_prompt = NULL;
1615
1616   relptr = get_one_do (app, 0x00C4, &value, &valuelen, NULL);
1617   if (!relptr || valuelen < 7)
1618     {
1619       log_error (_("error retrieving CHV status from card\n"));
1620       xfree (relptr);
1621       return gpg_error (GPG_ERR_CARD);
1622     }
1623   if (value[6] == 0)
1624     {
1625       log_info (_("card is permanently locked!\n"));
1626       xfree (relptr);
1627       return gpg_error (GPG_ERR_BAD_PIN);
1628     }
1629   remaining = value[6];
1630   xfree (relptr);
1631   
1632   log_info(_("%d Admin PIN attempts remaining before card"
1633              " is permanently locked\n"), remaining);
1634
1635   if (remaining < 3)
1636     {
1637       /* TRANSLATORS: Do not translate the "|A|" prefix but keep it at
1638          the start of the string.  Use %%0A to force a linefeed.  */
1639       prompt = xtryasprintf (_("|A|Please enter the Admin PIN%%0A"
1640                                "[remaining attempts: %d]"), remaining);
1641     }
1642   else
1643     prompt = xtrystrdup (_("|A|Please enter the Admin PIN"));
1644   
1645   if (!prompt)
1646     return gpg_error_from_syserror ();
1647   
1648   *r_prompt = prompt;
1649   return 0;
1650 }
1651
1652
1653 /* Verify CHV3 if required. */
1654 static gpg_error_t
1655 verify_chv3 (app_t app,
1656              gpg_error_t (*pincb)(void*, const char *, char **),
1657              void *pincb_arg)
1658 {
1659   int rc = 0;
1660
1661 #if GNUPG_MAJOR_VERSION != 1
1662   if (!opt.allow_admin)
1663     {
1664       log_info (_("access to admin commands is not configured\n"));
1665       return gpg_error (GPG_ERR_EACCES);
1666     }
1667 #endif
1668       
1669   if (!app->did_chv3) 
1670     {
1671       iso7816_pininfo_t pininfo;
1672       int minlen = 8;
1673       char *prompt;
1674
1675       memset (&pininfo, 0, sizeof pininfo);
1676       pininfo.mode = 1;
1677       pininfo.minlen = minlen;
1678
1679       rc = build_enter_admin_pin_prompt (app, &prompt);
1680       if (rc)
1681         return rc;
1682
1683       if (!opt.disable_keypad
1684           && !iso7816_check_keypad (app->slot, ISO7816_VERIFY, &pininfo) )
1685         {
1686           /* The reader supports the verify command through the keypad. */
1687           rc = pincb (pincb_arg, prompt, NULL); 
1688           xfree (prompt);
1689           prompt = NULL;
1690           if (rc)
1691             {
1692               log_info (_("PIN callback returned error: %s\n"),
1693                         gpg_strerror (rc));
1694               return rc;
1695             }
1696           rc = iso7816_verify_kp (app->slot, 0x83, "", 0, &pininfo); 
1697           /* Dismiss the prompt. */
1698           pincb (pincb_arg, NULL, NULL);
1699         }
1700       else
1701         {
1702           char *pinvalue;
1703
1704           rc = pincb (pincb_arg, prompt, &pinvalue); 
1705           xfree (prompt);
1706           prompt = NULL;
1707           if (rc)
1708             {
1709               log_info (_("PIN callback returned error: %s\n"),
1710                         gpg_strerror (rc));
1711               return rc;
1712             }
1713           
1714           if (strlen (pinvalue) < minlen)
1715             {
1716               log_error (_("PIN for CHV%d is too short;"
1717                            " minimum length is %d\n"), 3, minlen);
1718               xfree (pinvalue);
1719               return gpg_error (GPG_ERR_BAD_PIN);
1720             }
1721           
1722           rc = iso7816_verify (app->slot, 0x83, pinvalue, strlen (pinvalue));
1723           xfree (pinvalue);
1724         }
1725       
1726       if (rc)
1727         {
1728           log_error (_("verify CHV%d failed: %s\n"), 3, gpg_strerror (rc));
1729           flush_cache_after_error (app);
1730           return rc;
1731         }
1732       app->did_chv3 = 1;
1733     }
1734   return rc;
1735 }
1736
1737
1738 /* Handle the SETATTR operation. All arguments are already basically
1739    checked. */
1740 static gpg_error_t 
1741 do_setattr (app_t app, const char *name,
1742             gpg_error_t (*pincb)(void*, const char *, char **),
1743             void *pincb_arg,
1744             const unsigned char *value, size_t valuelen)
1745 {
1746   gpg_error_t rc;
1747   int idx;
1748   static struct {
1749     const char *name;
1750     int tag;
1751     int need_chv;
1752     int special;
1753     unsigned int need_v2:1;
1754   } table[] = {
1755     { "DISP-NAME",    0x005B, 3 },
1756     { "LOGIN-DATA",   0x005E, 3, 2 },
1757     { "DISP-LANG",    0x5F2D, 3 },
1758     { "DISP-SEX",     0x5F35, 3 },
1759     { "PUBKEY-URL",   0x5F50, 3 },
1760     { "CHV-STATUS-1", 0x00C4, 3, 1 },
1761     { "CA-FPR-1",     0x00CA, 3 },
1762     { "CA-FPR-2",     0x00CB, 3 },
1763     { "CA-FPR-3",     0x00CC, 3 },
1764     { "PRIVATE-DO-1", 0x0101, 2 },
1765     { "PRIVATE-DO-2", 0x0102, 3 },
1766     { "PRIVATE-DO-3", 0x0103, 2 },
1767     { "PRIVATE-DO-4", 0x0104, 3 },
1768     { "CERT-3",       0x7F21, 3, 0, 1 },
1769     { "SM-KEY-ENC",   0x00D1, 3, 0, 1 },
1770     { "SM-KEY-MAC",   0x00D2, 3, 0, 1 },
1771     { NULL, 0 }
1772   };
1773   int exmode;
1774
1775   for (idx=0; table[idx].name && strcmp (table[idx].name, name); idx++)
1776     ;
1777   if (!table[idx].name)
1778     return gpg_error (GPG_ERR_INV_NAME); 
1779   if (table[idx].need_v2 && !app->app_local->extcap.is_v2)
1780     return gpg_error (GPG_ERR_NOT_SUPPORTED); /* Not yet supported.  */
1781
1782   switch (table[idx].need_chv)
1783     {
1784     case 2:
1785       rc = verify_chv2 (app, pincb, pincb_arg);
1786       break;
1787     case 3:
1788       rc = verify_chv3 (app, pincb, pincb_arg);
1789       break;
1790     default:
1791       rc = 0;
1792     }
1793   if (rc)
1794     return rc;
1795
1796   /* Flush the cache before writing it, so that the next get operation
1797      will reread the data from the card and thus get synced in case of
1798      errors (e.g. data truncated by the card). */
1799   flush_cache_item (app, table[idx].tag);
1800
1801   if (app->app_local->cardcap.ext_lc_le && valuelen > 254)
1802     exmode = 1;    /* Use extended length w/o a limit.  */
1803   else if (app->app_local->cardcap.cmd_chaining && valuelen > 254)
1804     exmode = -254; /* Command chaining with max. 254 bytes.  */
1805   else
1806     exmode = 0;
1807   rc = iso7816_put_data (app->slot, exmode, table[idx].tag, value, valuelen);
1808   if (rc)
1809     log_error ("failed to set `%s': %s\n", table[idx].name, gpg_strerror (rc));
1810
1811   if (table[idx].special == 1)
1812     app->force_chv1 = (valuelen && *value == 0);
1813   else if (table[idx].special == 2)
1814     parse_login_data (app);
1815
1816   return rc;
1817 }
1818
1819
1820 /* Handle the WRITECERT command for OpenPGP.  This rites the standard
1821    certifciate to the card; CERTID needs to be set to "OPENPGP.3".
1822    PINCB and PINCB_ARG are the usual arguments for the pinentry
1823    callback.  */
1824 static gpg_error_t
1825 do_writecert (app_t app, ctrl_t ctrl,
1826               const char *certidstr, 
1827               gpg_error_t (*pincb)(void*, const char *, char **),
1828               void *pincb_arg,
1829               const unsigned char *certdata, size_t certdatalen)
1830 {
1831   (void)ctrl;
1832 #if GNUPG_MAJOR_VERSION > 1
1833   if (strcmp (certidstr, "OPENPGP.3"))
1834     return gpg_error (GPG_ERR_INV_ID);
1835   if (!certdata || !certdatalen)
1836     return gpg_error (GPG_ERR_INV_ARG);
1837   if (!app->app_local->extcap.is_v2)
1838     return gpg_error (GPG_ERR_NOT_SUPPORTED);
1839   if (certdatalen > app->app_local->extcap.max_certlen_3)
1840     return gpg_error (GPG_ERR_TOO_LARGE);
1841   return do_setattr (app, "CERT-3", pincb, pincb_arg, certdata, certdatalen);
1842 #else
1843   return gpg_error (GPG_ERR_NOT_IMPLEMENTED);
1844 #endif
1845 }
1846
1847
1848
1849 /* Handle the PASSWD command.  The following combinations are
1850    possible:
1851
1852     Flags  CHVNO Vers.  Description
1853     RESET    1   1      Verify CHV3 and set a new CHV1 and CHV2
1854     RESET    1   2      Verify PW3 and set a new PW1.
1855     RESET    2   1      Verify CHV3 and set a new CHV1 and CHV2.
1856     RESET    2   2      Verify PW3 and set a new Reset Code.
1857     RESET    3   any    Returns GPG_ERR_INV_ID.
1858      -       1   1      Verify CHV2 and set a new CHV1 and CHV2.
1859      -       1   2      Verify PW1 and set a new PW1.
1860      -       2   1      Verify CHV2 and set a new CHV1 and CHV2.
1861      -       2   2      Verify Reset Code and set a new PW1.
1862      -       3   any    Verify CHV3/PW3 and set a new CHV3/PW3.
1863  */
1864 static gpg_error_t 
1865 do_change_pin (app_t app, ctrl_t ctrl,  const char *chvnostr, 
1866                unsigned int flags,
1867                gpg_error_t (*pincb)(void*, const char *, char **),
1868                void *pincb_arg)
1869 {
1870   int rc = 0;
1871   int chvno = atoi (chvnostr);
1872   char *resetcode = NULL;
1873   char *oldpinvalue = NULL;
1874   char *pinvalue;
1875   int reset_mode = !!(flags & APP_CHANGE_FLAG_RESET);
1876   int set_resetcode = 0;
1877
1878   (void)ctrl;
1879
1880   if (reset_mode && chvno == 3)
1881     {
1882       rc = gpg_error (GPG_ERR_INV_ID);
1883       goto leave;
1884     }
1885
1886   if (!app->app_local->extcap.is_v2)
1887     {
1888       /* Version 1 cards.  */
1889
1890       if (reset_mode || chvno == 3)
1891         {
1892           /* We always require that the PIN is entered. */
1893           app->did_chv3 = 0;
1894           rc = verify_chv3 (app, pincb, pincb_arg);
1895           if (rc)
1896             goto leave;
1897         }
1898       else if (chvno == 1 || chvno == 2)
1899         {
1900           /* On a v1.x card CHV1 and CVH2 should always have the same
1901              value, thus we enforce it here.  */
1902           int save_force = app->force_chv1;
1903           
1904           app->force_chv1 = 0;
1905           app->did_chv1 = 0;
1906           app->did_chv2 = 0;
1907           rc = verify_chv2 (app, pincb, pincb_arg);
1908           app->force_chv1 = save_force;
1909           if (rc)
1910             goto leave;
1911         }
1912       else
1913         {
1914           rc = gpg_error (GPG_ERR_INV_ID);
1915           goto leave;
1916         }
1917     }
1918   else
1919     {
1920       /* Version 2 cards.  */
1921
1922       if (reset_mode)
1923         {
1924           /* To reset a PIN the Admin PIN is required. */
1925           app->did_chv3 = 0;
1926           rc = verify_chv3 (app, pincb, pincb_arg);
1927           if (rc)
1928             goto leave;
1929           
1930           if (chvno == 2)
1931             set_resetcode = 1;
1932         }
1933       else if (chvno == 1 || chvno == 3)
1934         {
1935           int minlen = (chvno ==3)? 8 : 6;
1936           char *promptbuf = NULL;
1937           const char *prompt;
1938
1939           if (chvno == 3)
1940             {
1941               rc = build_enter_admin_pin_prompt (app, &promptbuf);
1942               if (rc)
1943                 goto leave;
1944               prompt = promptbuf;
1945             }
1946           else
1947             prompt = _("||Please enter the PIN");
1948           rc = pincb (pincb_arg, prompt, &oldpinvalue);
1949           xfree (promptbuf);
1950           promptbuf = NULL;
1951           if (rc)
1952             {
1953               log_info (_("PIN callback returned error: %s\n"),
1954                         gpg_strerror (rc));
1955               goto leave;
1956             }
1957
1958           if (strlen (oldpinvalue) < minlen)
1959             {
1960               log_info (_("PIN for CHV%d is too short;"
1961                           " minimum length is %d\n"), chvno, minlen);
1962               rc = gpg_error (GPG_ERR_BAD_PIN);
1963               goto leave;
1964             }
1965         }
1966       else if (chvno == 2)
1967         {
1968           /* There is no PW2 for v2 cards.  We use this condition to
1969              allow a PW reset using the Reset Code.  */
1970           void *relptr;
1971           unsigned char *value;
1972           size_t valuelen;
1973           int remaining;
1974           int minlen = 8;
1975
1976           relptr = get_one_do (app, 0x00C4, &value, &valuelen, NULL);
1977           if (!relptr || valuelen < 7)
1978             {
1979               log_error (_("error retrieving CHV status from card\n"));
1980               xfree (relptr);
1981               rc = gpg_error (GPG_ERR_CARD);
1982               goto leave;
1983             }
1984           remaining = value[5];
1985           xfree (relptr);
1986           if (!remaining)
1987             {
1988               log_error (_("Reset Code not or not anymore available\n"));
1989               rc = gpg_error (GPG_ERR_BAD_PIN);
1990               goto leave;
1991             }          
1992           
1993           rc = pincb (pincb_arg,
1994                       _("||Please enter the Reset Code for the card"),
1995                       &resetcode); 
1996           if (rc)
1997             {
1998               log_info (_("PIN callback returned error: %s\n"), 
1999                         gpg_strerror (rc));
2000               goto leave;
2001             }
2002           if (strlen (resetcode) < minlen)
2003             {
2004               log_info (_("Reset Code is too short; minimum length is %d\n"),
2005                         minlen);
2006               rc = gpg_error (GPG_ERR_BAD_PIN);
2007               goto leave;
2008             }
2009         }
2010       else
2011         {
2012           rc = gpg_error (GPG_ERR_INV_ID);
2013           goto leave;
2014         }
2015     }
2016
2017   if (chvno == 3)
2018     app->did_chv3 = 0;
2019   else
2020     app->did_chv1 = app->did_chv2 = 0;
2021
2022   /* TRANSLATORS: Do not translate the "|*|" prefixes but
2023      keep it at the start of the string.  We need this elsewhere
2024      to get some infos on the string. */
2025   rc = pincb (pincb_arg, 
2026               set_resetcode? _("|RN|New Reset Code") :
2027               chvno == 3? _("|AN|New Admin PIN") : _("|N|New PIN"), 
2028               &pinvalue); 
2029   if (rc)
2030     {
2031       log_error (_("error getting new PIN: %s\n"), gpg_strerror (rc));
2032       goto leave;
2033     }
2034
2035
2036   if (resetcode)
2037     {
2038       char *buffer;
2039
2040       buffer = xtrymalloc (strlen (resetcode) + strlen (pinvalue) + 1);
2041       if (!buffer)
2042         rc = gpg_error_from_syserror ();
2043       else
2044         {
2045           strcpy (stpcpy (buffer, resetcode), pinvalue);
2046           rc = iso7816_reset_retry_counter_with_rc (app->slot, 0x81,
2047                                                     buffer, strlen (buffer));
2048           wipememory (buffer, strlen (buffer));
2049           xfree (buffer);
2050         }
2051     }
2052   else if (set_resetcode)
2053     {
2054       if (strlen (pinvalue) < 8)
2055         {
2056           log_error (_("Reset Code is too short; minimum length is %d\n"), 8);
2057           rc = gpg_error (GPG_ERR_BAD_PIN);
2058         }
2059       else
2060         rc = iso7816_put_data (app->slot, 0, 0xD3,
2061                                pinvalue, strlen (pinvalue));
2062     }
2063   else if (reset_mode)
2064     {
2065       rc = iso7816_reset_retry_counter (app->slot, 0x81,
2066                                         pinvalue, strlen (pinvalue));
2067       if (!rc && !app->app_local->extcap.is_v2)
2068         rc = iso7816_reset_retry_counter (app->slot, 0x82,
2069                                           pinvalue, strlen (pinvalue));
2070     }
2071   else if (!app->app_local->extcap.is_v2)
2072     {
2073       /* Version 1 cards.  */
2074       if (chvno == 1 || chvno == 2)
2075         {
2076           rc = iso7816_change_reference_data (app->slot, 0x81, NULL, 0,
2077                                               pinvalue, strlen (pinvalue));
2078           if (!rc)
2079             rc = iso7816_change_reference_data (app->slot, 0x82, NULL, 0,
2080                                                 pinvalue, strlen (pinvalue));
2081         }
2082       else /* CHVNO == 3 */
2083         {
2084           rc = iso7816_change_reference_data (app->slot, 0x80 + chvno, NULL, 0,
2085                                               pinvalue, strlen (pinvalue));
2086         }
2087     }
2088   else
2089     {
2090       /* Version 2 cards.  */
2091       assert (chvno == 1 || chvno == 3);
2092       
2093       rc = iso7816_change_reference_data (app->slot, 0x80 + chvno,
2094                                           oldpinvalue, strlen (oldpinvalue),
2095                                           pinvalue, strlen (pinvalue));
2096     }
2097
2098   if (pinvalue)
2099     {
2100       wipememory (pinvalue, strlen (pinvalue));
2101       xfree (pinvalue);
2102     }
2103   if (rc)
2104     flush_cache_after_error (app);
2105
2106  leave:
2107   if (resetcode)
2108     {
2109       wipememory (resetcode, strlen (resetcode));
2110       xfree (resetcode);
2111     }
2112   if (oldpinvalue)
2113     {
2114       wipememory (oldpinvalue, strlen (oldpinvalue));
2115       xfree (oldpinvalue);
2116     }
2117   return rc;
2118 }
2119
2120
2121 /* Check whether a key already exists.  KEYIDX is the index of the key
2122    (0..2).  If FORCE is TRUE a diagnositic will be printed but no
2123    error returned if the key already exists. */
2124 static gpg_error_t
2125 does_key_exist (app_t app, int keyidx, int force)
2126 {
2127   const unsigned char *fpr;
2128   unsigned char *buffer;
2129   size_t buflen, n;
2130   int i;
2131
2132   assert (keyidx >=0 && keyidx <= 2);
2133
2134   if (iso7816_get_data (app->slot, 0x006E, &buffer, &buflen))
2135     {
2136       log_error (_("error reading application data\n"));
2137       return gpg_error (GPG_ERR_GENERAL);
2138     }
2139   fpr = find_tlv (buffer, buflen, 0x00C5, &n);
2140   if (!fpr || n < 60)
2141     {
2142       log_error (_("error reading fingerprint DO\n"));
2143       xfree (buffer);
2144       return gpg_error (GPG_ERR_GENERAL);
2145     }
2146   fpr += 20*keyidx;
2147   for (i=0; i < 20 && !fpr[i]; i++)
2148     ;
2149   xfree (buffer);
2150   if (i!=20 && !force)
2151     {
2152       log_error (_("key already exists\n"));
2153       return gpg_error (GPG_ERR_EEXIST);
2154     }
2155   else if (i!=20)
2156     log_info (_("existing key will be replaced\n"));
2157   else
2158     log_info (_("generating new key\n"));
2159   return 0;
2160 }
2161
2162
2163 /* Create a TLV tag and value and store it at BUFFER.  Return the length
2164    of tag and length.  A LENGTH greater than 65535 is truncated. */
2165 static size_t
2166 add_tlv (unsigned char *buffer, unsigned int tag, size_t length)
2167
2168   unsigned char *p = buffer;
2169
2170   assert (tag <= 0xffff);
2171   if ( tag > 0xff )
2172     *p++ = tag >> 8;
2173   *p++ = tag;
2174   if (length < 128)
2175     *p++ = length;
2176   else if (length < 256)
2177     {
2178       *p++ = 0x81;
2179       *p++ = length;
2180     }
2181   else
2182     {
2183       if (length > 0xffff)
2184         length = 0xffff;
2185       *p++ = 0x82;
2186       *p++ = length >> 8;
2187       *p++ = length;
2188     }
2189
2190   return p - buffer;
2191 }
2192
2193
2194 /* Build the private key template as specified in the OpenPGP specs
2195    v2.0 section 4.3.3.7.  */
2196 static gpg_error_t
2197 build_privkey_template (app_t app, int keyno,
2198                         const unsigned char *rsa_n, size_t rsa_n_len,
2199                         const unsigned char *rsa_e, size_t rsa_e_len,
2200                         const unsigned char *rsa_p, size_t rsa_p_len,
2201                         const unsigned char *rsa_q, size_t rsa_q_len,
2202                         unsigned char **result, size_t *resultlen)
2203 {
2204   size_t rsa_e_reqlen;
2205   unsigned char privkey[7*(1+3)];
2206   size_t privkey_len;
2207   unsigned char exthdr[2+2+3];
2208   size_t exthdr_len;
2209   unsigned char suffix[2+3];
2210   size_t suffix_len;
2211   unsigned char *tp;
2212   size_t datalen;
2213   unsigned char *template;
2214   size_t template_size;
2215
2216   *result = NULL;
2217   *resultlen = 0;
2218
2219   switch (app->app_local->keyattr[keyno].format)
2220     {
2221     case RSA_STD:
2222     case RSA_STD_N:
2223       break;
2224     case RSA_CRT:
2225     case RSA_CRT_N:
2226       return gpg_error (GPG_ERR_NOT_SUPPORTED);
2227
2228     default:
2229       return gpg_error (GPG_ERR_INV_VALUE);
2230     }
2231
2232   /* Get the required length for E.  */
2233   rsa_e_reqlen = app->app_local->keyattr[keyno].e_bits/8;
2234   assert (rsa_e_len <= rsa_e_reqlen);
2235
2236   /* Build the 7f48 cardholder private key template.  */
2237   datalen = 0;
2238   tp = privkey;
2239
2240   tp += add_tlv (tp, 0x91, rsa_e_reqlen);
2241   datalen += rsa_e_reqlen;
2242
2243   tp += add_tlv (tp, 0x92, rsa_p_len);
2244   datalen += rsa_p_len;
2245
2246   tp += add_tlv (tp, 0x93, rsa_q_len);
2247   datalen += rsa_q_len;
2248
2249   if (app->app_local->keyattr[keyno].format == RSA_STD_N
2250       || app->app_local->keyattr[keyno].format == RSA_CRT_N)
2251     {
2252       tp += add_tlv (tp, 0x97, rsa_n_len);
2253       datalen += rsa_n_len;
2254     }
2255   privkey_len = tp - privkey;
2256
2257   /* Build the extended header list without the private key template.  */
2258   tp = exthdr;
2259   *tp++ = keyno ==0 ? 0xb6 : keyno == 1? 0xb8 : 0xa4;
2260   *tp++ = 0;
2261   tp += add_tlv (tp, 0x7f48, privkey_len);
2262   exthdr_len = tp - exthdr;
2263
2264   /* Build the 5f48 suffix of the data.  */
2265   tp = suffix;
2266   tp += add_tlv (tp, 0x5f48, datalen);
2267   suffix_len = tp - suffix;
2268
2269   /* Now concatenate everything.  */
2270   template_size = (1 + 3   /* 0x4d and len. */
2271                    + exthdr_len
2272                    + privkey_len
2273                    + suffix_len
2274                    + datalen);
2275   tp = template = xtrymalloc_secure (template_size);
2276   if (!template)
2277     return gpg_error_from_syserror ();
2278
2279   tp += add_tlv (tp, 0x4d, exthdr_len + privkey_len + suffix_len + datalen);
2280   memcpy (tp, exthdr, exthdr_len);
2281   tp += exthdr_len;
2282   memcpy (tp, privkey, privkey_len);
2283   tp += privkey_len;
2284   memcpy (tp, suffix, suffix_len);
2285   tp += suffix_len;
2286
2287   memcpy (tp, rsa_e, rsa_e_len);
2288   if (rsa_e_len < rsa_e_reqlen)
2289     {
2290       /* Right justify E. */
2291       memmove (tp + rsa_e_reqlen - rsa_e_len, tp, rsa_e_len);
2292       memset (tp, 0, rsa_e_reqlen - rsa_e_len);
2293     }                 
2294   tp += rsa_e_reqlen;
2295       
2296   memcpy (tp, rsa_p, rsa_p_len);
2297   tp += rsa_p_len;
2298       
2299   memcpy (tp, rsa_q, rsa_q_len);
2300   tp += rsa_q_len;
2301   
2302   if (app->app_local->keyattr[keyno].format == RSA_STD_N
2303       || app->app_local->keyattr[keyno].format == RSA_CRT_N)
2304     {
2305       memcpy (tp, rsa_n, rsa_n_len);
2306       tp += rsa_n_len;
2307     }
2308
2309   /* Sanity check.  We don't know the exact length because we
2310      allocated 3 bytes for the first length header.  */
2311   assert (tp - template <= template_size);
2312
2313   *result = template;
2314   *resultlen = tp - template;
2315   return 0;
2316 }
2317
2318
2319
2320 /* Handle the WRITEKEY command for OpenPGP.  This function expects a
2321    canonical encoded S-expression with the secret key in KEYDATA and
2322    its length (for assertions) in KEYDATALEN.  KEYID needs to be the
2323    usual keyid which for OpenPGP is the string "OPENPGP.n" with
2324    n=1,2,3.  Bit 0 of FLAGS indicates whether an existing key shall
2325    get overwritten.  PINCB and PINCB_ARG are the usual arguments for
2326    the pinentry callback.  */
2327 static gpg_error_t
2328 do_writekey (app_t app, ctrl_t ctrl,
2329              const char *keyid, unsigned int flags,
2330              gpg_error_t (*pincb)(void*, const char *, char **),
2331              void *pincb_arg,
2332              const unsigned char *keydata, size_t keydatalen)
2333 {
2334   gpg_error_t err;
2335   int force = (flags & 1);
2336   int keyno;
2337   const unsigned char *buf, *tok;
2338   size_t buflen, toklen;
2339   int depth, last_depth1, last_depth2;
2340   const unsigned char *rsa_n = NULL;
2341   const unsigned char *rsa_e = NULL;
2342   const unsigned char *rsa_p = NULL;
2343   const unsigned char *rsa_q = NULL;
2344   size_t rsa_n_len, rsa_e_len, rsa_p_len, rsa_q_len;
2345   unsigned int nbits;
2346   unsigned int maxbits;
2347   unsigned char *template = NULL;
2348   unsigned char *tp;
2349   size_t template_len;
2350   unsigned char fprbuf[20];
2351   u32 created_at = 0;
2352
2353   (void)ctrl;
2354
2355   if (!strcmp (keyid, "OPENPGP.1"))
2356     keyno = 0;
2357   else if (!strcmp (keyid, "OPENPGP.2"))
2358     keyno = 1;
2359   else if (!strcmp (keyid, "OPENPGP.3"))
2360     keyno = 2;
2361   else
2362     return gpg_error (GPG_ERR_INV_ID);
2363   
2364   err = does_key_exist (app, keyno, force);
2365   if (err)
2366     return err;
2367
2368
2369   /* 
2370      Parse the S-expression
2371    */
2372   buf = keydata;
2373   buflen = keydatalen;
2374   depth = 0;
2375   if ((err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen)))
2376     goto leave;
2377   if ((err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen)))
2378     goto leave;
2379   if (!tok || toklen != 11 || memcmp ("private-key", tok, toklen))
2380     {
2381       if (!tok)
2382         ;
2383       else if (toklen == 21 && !memcmp ("protected-private-key", tok, toklen))
2384         log_info ("protected-private-key passed to writekey\n");
2385       else if (toklen == 20 && !memcmp ("shadowed-private-key", tok, toklen))
2386         log_info ("shadowed-private-key passed to writekey\n");
2387       err = gpg_error (GPG_ERR_BAD_SECKEY);
2388       goto leave;
2389     }
2390   if ((err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen)))
2391     goto leave;
2392   if ((err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen)))
2393     goto leave;
2394   if (!tok || toklen != 3 || memcmp ("rsa", tok, toklen))
2395     {
2396       err = gpg_error (GPG_ERR_WRONG_PUBKEY_ALGO);
2397       goto leave;
2398     }
2399   last_depth1 = depth;
2400   while (!(err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen))
2401          && depth && depth >= last_depth1)
2402     {
2403       if (tok)
2404         {
2405           err = gpg_error (GPG_ERR_UNKNOWN_SEXP);
2406           goto leave;
2407         }
2408       if ((err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen)))
2409         goto leave;
2410       if (tok && toklen == 1)
2411         {
2412           const unsigned char **mpi;
2413           size_t *mpi_len;
2414
2415           switch (*tok)
2416             {
2417             case 'n': mpi = &rsa_n; mpi_len = &rsa_n_len; break; 
2418             case 'e': mpi = &rsa_e; mpi_len = &rsa_e_len; break; 
2419             case 'p': mpi = &rsa_p; mpi_len = &rsa_p_len; break; 
2420             case 'q': mpi = &rsa_q; mpi_len = &rsa_q_len;break; 
2421             default: mpi = NULL;  mpi_len = NULL; break;
2422             }
2423           if (mpi && *mpi)
2424             {
2425               err = gpg_error (GPG_ERR_DUP_VALUE);
2426               goto leave;
2427             }
2428           if ((err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen)))
2429             goto leave;
2430           if (tok && mpi)
2431             {
2432               /* Strip off leading zero bytes and save. */
2433               for (;toklen && !*tok; toklen--, tok++)
2434                 ;
2435               *mpi = tok;
2436               *mpi_len = toklen;
2437             }
2438         }
2439       /* Skip until end of list. */
2440       last_depth2 = depth;
2441       while (!(err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen))
2442              && depth && depth >= last_depth2)
2443         ;
2444       if (err)
2445         goto leave;
2446     }
2447   /* Parse other attributes. */
2448   last_depth1 = depth;
2449   while (!(err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen))
2450          && depth && depth >= last_depth1)
2451     {
2452       if (tok)
2453         {
2454           err = gpg_error (GPG_ERR_UNKNOWN_SEXP);
2455           goto leave;
2456         }
2457       if ((err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen)))
2458         goto leave;
2459       if (tok && toklen == 10 && !memcmp ("created-at", tok, toklen))
2460         {
2461           if ((err = parse_sexp (&buf,&buflen,&depth,&tok,&toklen)))
2462             goto leave;
2463           if (tok)
2464             {
2465               for (created_at=0; toklen && *tok && *tok >= '0' && *tok <= '9';
2466                    tok++, toklen--)
2467                 created_at = created_at*10 + (*tok - '0');
2468             }
2469         }
2470       /* Skip until end of list. */
2471       last_depth2 = depth;
2472       while (!(err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen))
2473              && depth && depth >= last_depth2)
2474         ;
2475       if (err)
2476         goto leave;
2477     }
2478
2479
2480   /* Check that we have all parameters and that they match the card
2481      description. */
2482   if (!created_at)
2483     {
2484       log_error (_("creation timestamp missing\n"));
2485       err = gpg_error (GPG_ERR_INV_VALUE);
2486       goto leave;
2487     }
2488
2489   maxbits = app->app_local->keyattr[keyno].n_bits;
2490   nbits = rsa_n? count_bits (rsa_n, rsa_n_len) : 0;
2491   if (opt.verbose)
2492     log_info ("RSA modulus size is %u bits (%u bytes)\n", 
2493               nbits, (unsigned int)rsa_n_len);
2494   if (nbits != maxbits)
2495     {
2496       log_error (_("RSA modulus missing or not of size %d bits\n"), 
2497                  (int)maxbits);
2498       err = gpg_error (GPG_ERR_BAD_SECKEY);
2499       goto leave;
2500     }
2501
2502   maxbits = app->app_local->keyattr[keyno].e_bits;
2503   if (maxbits > 32 && !app->app_local->extcap.is_v2)
2504     maxbits = 32; /* Our code for v1 does only support 32 bits.  */
2505   nbits = rsa_e? count_bits (rsa_e, rsa_e_len) : 0;
2506   if (nbits < 2 || nbits > maxbits)
2507     {
2508       log_error (_("RSA public exponent missing or larger than %d bits\n"),
2509                  (int)maxbits);
2510       err = gpg_error (GPG_ERR_BAD_SECKEY);
2511       goto leave;
2512     }
2513
2514   maxbits = app->app_local->keyattr[keyno].n_bits/2;
2515   nbits = rsa_p? count_bits (rsa_p, rsa_p_len) : 0;
2516   if (nbits != maxbits)
2517     {
2518       log_error (_("RSA prime %s missing or not of size %d bits\n"), 
2519                  "P", (int)maxbits);
2520       err = gpg_error (GPG_ERR_BAD_SECKEY);
2521       goto leave;
2522     }
2523   nbits = rsa_q? count_bits (rsa_q, rsa_q_len) : 0;
2524   if (nbits != maxbits)
2525     {
2526       log_error (_("RSA prime %s missing or not of size %d bits\n"), 
2527                  "Q", (int)maxbits);
2528       err = gpg_error (GPG_ERR_BAD_SECKEY);
2529       goto leave;
2530     }
2531   
2532   /* We need to remove the cached public key.  */
2533   xfree (app->app_local->pk[keyno].key);
2534   app->app_local->pk[keyno].key = NULL;
2535   app->app_local->pk[keyno].keylen = 0;
2536   app->app_local->pk[keyno].read_done = 0;
2537
2538
2539   if (app->app_local->extcap.is_v2)
2540     {
2541       /* Build the private key template as described in section 4.3.3.7 of
2542          the OpenPGP card specs version 2.0.  */
2543       int exmode;
2544  
2545       err = build_privkey_template (app, keyno,
2546                                     rsa_n, rsa_n_len,
2547                                     rsa_e, rsa_e_len,
2548                                     rsa_p, rsa_p_len,
2549                                     rsa_q, rsa_q_len,
2550                                     &template, &template_len);
2551       if (err)
2552         goto leave;
2553
2554       /* Prepare for storing the key.  */
2555       err = verify_chv3 (app, pincb, pincb_arg);
2556       if (err)
2557         goto leave;
2558
2559       /* Store the key. */
2560       if (app->app_local->cardcap.ext_lc_le && template_len > 254)
2561         exmode = 1;    /* Use extended length w/o a limit.  */
2562       else if (app->app_local->cardcap.cmd_chaining && template_len > 254)
2563         exmode = -254;
2564       else
2565         exmode = 0;
2566       err = iso7816_put_data_odd (app->slot, exmode, 0x3fff,
2567                                   template, template_len);
2568     }
2569   else
2570     {
2571       /* Build the private key template as described in section 4.3.3.6 of
2572          the OpenPGP card specs version 1.1:
2573          0xC0   <length> public exponent
2574          0xC1   <length> prime p 
2575          0xC2   <length> prime q 
2576       */
2577       assert (rsa_e_len <= 4);
2578       template_len = (1 + 1 + 4
2579                       + 1 + 1 + rsa_p_len
2580                       + 1 + 1 + rsa_q_len);
2581       template = tp = xtrymalloc_secure (template_len);
2582       if (!template)
2583         {
2584           err = gpg_error_from_syserror ();
2585           goto leave;
2586         }
2587       *tp++ = 0xC0;
2588       *tp++ = 4;
2589       memcpy (tp, rsa_e, rsa_e_len);
2590       if (rsa_e_len < 4)
2591         {
2592           /* Right justify E. */
2593           memmove (tp+4-rsa_e_len, tp, rsa_e_len);
2594           memset (tp, 0, 4-rsa_e_len);
2595         }                 
2596       tp += 4;
2597       
2598       *tp++ = 0xC1;
2599       *tp++ = rsa_p_len;
2600       memcpy (tp, rsa_p, rsa_p_len);
2601       tp += rsa_p_len;
2602       
2603       *tp++ = 0xC2;
2604       *tp++ = rsa_q_len;
2605       memcpy (tp, rsa_q, rsa_q_len);
2606       tp += rsa_q_len;
2607       
2608       assert (tp - template == template_len);
2609       
2610       /* Prepare for storing the key.  */
2611       err = verify_chv3 (app, pincb, pincb_arg);
2612       if (err)
2613         goto leave;
2614
2615       /* Store the key. */
2616       err = iso7816_put_data (app->slot, 0,
2617                               (app->card_version > 0x0007? 0xE0:0xE9)+keyno,
2618                               template, template_len);
2619     }
2620   if (err)
2621     {
2622       log_error (_("failed to store the key: %s\n"), gpg_strerror (err));
2623       goto leave;
2624     }
2625  
2626   err = store_fpr (app->slot, keyno, created_at,
2627                   rsa_n, rsa_n_len, rsa_e, rsa_e_len,
2628                   fprbuf, app->card_version);
2629   if (err)
2630     goto leave;
2631
2632
2633  leave:
2634   xfree (template);
2635   return err;
2636 }
2637
2638
2639 /* Handle the GENKEY command. */
2640 static gpg_error_t 
2641 do_genkey (app_t app, ctrl_t ctrl,  const char *keynostr, unsigned int flags,
2642            time_t createtime,
2643            gpg_error_t (*pincb)(void*, const char *, char **),
2644            void *pincb_arg)
2645 {
2646   int rc;
2647   char numbuf[30];
2648   unsigned char fprbuf[20];
2649   const unsigned char *keydata, *m, *e;
2650   unsigned char *buffer = NULL;
2651   size_t buflen, keydatalen, mlen, elen;
2652   time_t created_at;
2653   int keyno = atoi (keynostr);
2654   int force = (flags & 1);
2655   time_t start_at;
2656   int exmode;
2657   int le_value;
2658   unsigned int keybits; 
2659
2660   if (keyno < 1 || keyno > 3)
2661     return gpg_error (GPG_ERR_INV_ID);
2662   keyno--;
2663
2664   /* We flush the cache to increase the traffic before a key
2665      generation.  This _might_ help a card to gather more entropy. */
2666   flush_cache (app);
2667
2668   /* Obviously we need to remove the cached public key.  */
2669   xfree (app->app_local->pk[keyno].key);
2670   app->app_local->pk[keyno].key = NULL;
2671   app->app_local->pk[keyno].keylen = 0;
2672   app->app_local->pk[keyno].read_done = 0;
2673
2674   /* Check whether a key already exists.  */
2675   rc = does_key_exist (app, keyno, force);
2676   if (rc)
2677     return rc;
2678
2679   /* Because we send the key parameter back via status lines we need
2680      to put a limit on the max. allowed keysize.  2048 bit will
2681      already lead to a 527 byte long status line and thus a 4096 bit
2682      key would exceed the Assuan line length limit.  */ 
2683   keybits = app->app_local->keyattr[keyno].n_bits;
2684   if (keybits > 3072)
2685     return gpg_error (GPG_ERR_TOO_LARGE);
2686
2687   /* Prepare for key generation by verifying the Admin PIN.  */
2688   rc = verify_chv3 (app, pincb, pincb_arg);
2689   if (rc)
2690     goto leave;
2691
2692   /* Test whether we will need extended length mode.  (1900 is an
2693      arbitrary length which for sure fits into a short apdu.)  */
2694   if (app->app_local->cardcap.ext_lc_le && keybits > 1900)
2695     {
2696       exmode = 1;    /* Use extended length w/o a limit.  */
2697       le_value = app->app_local->extcap.max_rsp_data;
2698       /* No need to check le_value because it comes from a 16 bit
2699          value and thus can't create an overflow on a 32 bit
2700          system.  */ 
2701     }
2702   else
2703     {
2704       exmode = 0;
2705       le_value = 256; /* Use legacy value. */
2706     }
2707
2708   log_info (_("please wait while key is being generated ...\n"));
2709   start_at = time (NULL);
2710   rc = iso7816_generate_keypair 
2711 /* # warning key generation temporary replaced by reading an existing key. */
2712 /*   rc = iso7816_read_public_key */
2713     (app->slot, exmode, 
2714      (const unsigned char*)(keyno == 0? "\xB6" :
2715                             keyno == 1? "\xB8" : "\xA4"), 2,
2716      le_value,
2717      &buffer, &buflen);
2718   if (rc)
2719     {
2720       rc = gpg_error (GPG_ERR_CARD);
2721       log_error (_("generating key failed\n"));
2722       goto leave;
2723     }
2724   log_info (_("key generation completed (%d seconds)\n"),
2725             (int)(time (NULL) - start_at));
2726
2727   keydata = find_tlv (buffer, buflen, 0x7F49, &keydatalen);
2728   if (!keydata)
2729     {
2730       rc = gpg_error (GPG_ERR_CARD);
2731       log_error (_("response does not contain the public key data\n"));
2732       goto leave;
2733     }
2734  
2735   m = find_tlv (keydata, keydatalen, 0x0081, &mlen);
2736   if (!m)
2737     {
2738       rc = gpg_error (GPG_ERR_CARD);
2739       log_error (_("response does not contain the RSA modulus\n"));
2740       goto leave;
2741     }
2742   /* log_printhex ("RSA n:", m, mlen); */
2743   send_key_data (ctrl, "n", m, mlen);
2744
2745   e = find_tlv (keydata, keydatalen, 0x0082, &elen);
2746   if (!e)
2747     {
2748       rc = gpg_error (GPG_ERR_CARD);
2749       log_error (_("response does not contain the RSA public exponent\n"));
2750       goto leave;
2751     }
2752   /* log_printhex ("RSA e:", e, elen); */
2753   send_key_data (ctrl, "e", e, elen);
2754
2755   created_at = createtime? createtime : gnupg_get_time ();
2756   sprintf (numbuf, "%lu", (unsigned long)created_at);
2757   send_status_info (ctrl, "KEY-CREATED-AT",
2758                     numbuf, (size_t)strlen(numbuf), NULL, 0);
2759
2760   rc = store_fpr (app->slot, keyno, (u32)created_at,
2761                   m, mlen, e, elen, fprbuf, app->card_version);
2762   if (rc)
2763     goto leave;
2764   send_fpr_if_not_null (ctrl, "KEY-FPR", -1, fprbuf);
2765
2766
2767  leave:
2768   xfree (buffer);
2769   return rc;
2770 }
2771
2772
2773 static unsigned long
2774 convert_sig_counter_value (const unsigned char *value, size_t valuelen)
2775 {
2776   unsigned long ul;
2777
2778   if (valuelen == 3 )
2779     ul = (value[0] << 16) | (value[1] << 8) | value[2];
2780   else
2781     {
2782       log_error (_("invalid structure of OpenPGP card (DO 0x93)\n"));
2783       ul = 0;
2784     }
2785   return ul;
2786 }
2787
2788 static unsigned long
2789 get_sig_counter (app_t app)
2790 {
2791   void *relptr;
2792   unsigned char *value;
2793   size_t valuelen;
2794   unsigned long ul;
2795
2796   relptr = get_one_do (app, 0x0093, &value, &valuelen, NULL);
2797   if (!relptr)
2798     return 0;
2799   ul = convert_sig_counter_value (value, valuelen);
2800   xfree (relptr);
2801   return ul;
2802 }
2803
2804 static gpg_error_t
2805 compare_fingerprint (app_t app, int keyno, unsigned char *sha1fpr)
2806 {
2807   const unsigned char *fpr;
2808   unsigned char *buffer;
2809   size_t buflen, n;
2810   int rc, i;
2811   
2812   assert (keyno >= 1 && keyno <= 3);
2813
2814   rc = get_cached_data (app, 0x006E, &buffer, &buflen, 0);
2815   if (rc)
2816     {
2817       log_error (_("error reading application data\n"));
2818       return gpg_error (GPG_ERR_GENERAL);
2819     }
2820   fpr = find_tlv (buffer, buflen, 0x00C5, &n);
2821   if (!fpr || n != 60)
2822     {
2823       xfree (buffer);
2824       log_error (_("error reading fingerprint DO\n"));
2825       return gpg_error (GPG_ERR_GENERAL);
2826     }
2827   fpr += (keyno-1)*20;
2828   for (i=0; i < 20; i++)
2829     if (sha1fpr[i] != fpr[i])
2830       {
2831         xfree (buffer);
2832         log_info (_("fingerprint on card does not match requested one\n"));
2833         return gpg_error (GPG_ERR_WRONG_SECKEY);
2834       }
2835   xfree (buffer);
2836   return 0;
2837 }
2838
2839
2840 /* If a fingerprint has been specified check it against the one on the
2841    card.  This allows for a meaningful error message in case the key
2842    on the card has been replaced but the shadow information known to
2843    gpg has not been updated.  If there is no fingerprint we assume
2844    that this is okay. */
2845 static gpg_error_t
2846 check_against_given_fingerprint (app_t app, const char *fpr, int keyno)
2847 {
2848   unsigned char tmp[20];
2849   const char *s;
2850   int n;
2851
2852   for (s=fpr, n=0; hexdigitp (s); s++, n++)
2853     ;
2854   if (n != 40)
2855     return gpg_error (GPG_ERR_INV_ID);
2856   else if (!*s)
2857     ; /* okay */
2858   else
2859     return gpg_error (GPG_ERR_INV_ID);
2860
2861   for (s=fpr, n=0; n < 20; s += 2, n++)
2862         tmp[n] = xtoi_2 (s);
2863   return compare_fingerprint (app, keyno, tmp);
2864 }
2865
2866
2867
2868 /* Compute a digital signature on INDATA which is expected to be the
2869    raw message digest. For this application the KEYIDSTR consists of
2870    the serialnumber and the fingerprint delimited by a slash.
2871
2872    Note that this function may return the error code
2873    GPG_ERR_WRONG_CARD to indicate that the card currently present does
2874    not match the one required for the requested action (e.g. the
2875    serial number does not match). 
2876    
2877    As a special feature a KEYIDSTR of "OPENPGP.3" redirects the
2878    operation to the auth command.
2879 */
2880 static gpg_error_t 
2881 do_sign (app_t app, const char *keyidstr, int hashalgo,
2882          gpg_error_t (*pincb)(void*, const char *, char **),
2883          void *pincb_arg,
2884          const void *indata, size_t indatalen,
2885          unsigned char **outdata, size_t *outdatalen )
2886 {
2887   static unsigned char rmd160_prefix[15] = /* Object ID is 1.3.36.3.2.1 */
2888     { 0x30, 0x21, 0x30, 0x09, 0x06, 0x05, 0x2b, 0x24, 0x03,
2889       0x02, 0x01, 0x05, 0x00, 0x04, 0x14  };
2890   static unsigned char sha1_prefix[15] =   /* (1.3.14.3.2.26) */
2891     { 0x30, 0x21, 0x30, 0x09, 0x06, 0x05, 0x2b, 0x0e, 0x03,
2892       0x02, 0x1a, 0x05, 0x00, 0x04, 0x14  };
2893   static unsigned char sha224_prefix[19] = /* (2.16.840.1.101.3.4.2.4) */
2894     { 0x30, 0x2D, 0x30, 0x0d, 0x06, 0x09, 0x60, 0x86, 0x48,
2895       0x01, 0x65, 0x03, 0x04, 0x02, 0x04, 0x05, 0x00, 0x04,
2896       0x1C  };
2897   static unsigned char sha256_prefix[19] = /* (2.16.840.1.101.3.4.2.1) */
2898     { 0x30, 0x31, 0x30, 0x0d, 0x06, 0x09, 0x60, 0x86,
2899       0x48, 0x01, 0x65, 0x03, 0x04, 0x02, 0x01, 0x05,
2900       0x00, 0x04, 0x20  };
2901   static unsigned char sha384_prefix[19] = /* (2.16.840.1.101.3.4.2.2) */
2902     { 0x30, 0x41, 0x30, 0x0d, 0x06, 0x09, 0x60, 0x86,
2903       0x48, 0x01, 0x65, 0x03, 0x04, 0x02, 0x02, 0x05,
2904       0x00, 0x04, 0x30  };
2905   static unsigned char sha512_prefix[19] = /* (2.16.840.1.101.3.4.2.3) */
2906     { 0x30, 0x51, 0x30, 0x0d, 0x06, 0x09, 0x60, 0x86,
2907       0x48, 0x01, 0x65, 0x03, 0x04, 0x02, 0x03, 0x05,
2908       0x00, 0x04, 0x40  };
2909   int rc;
2910   unsigned char data[19+64];
2911   size_t datalen;
2912   unsigned char tmp_sn[20]; /* Actually 16 bytes but also for the fpr. */
2913   const char *s;
2914   int n;
2915   const char *fpr = NULL;
2916   unsigned long sigcount;
2917   int use_auth = 0;
2918
2919   if (!keyidstr || !*keyidstr)
2920     return gpg_error (GPG_ERR_INV_VALUE);
2921
2922   /* Strip off known prefixes.  */
2923 #define X(a,b,c,d) \
2924   if (hashalgo == GCRY_MD_ ## a                               \
2925       && (d)                                                  \
2926       && indatalen == sizeof b ## _prefix + (c)               \
2927       && !memcmp (indata, b ## _prefix, sizeof b ## _prefix)) \
2928     {                                                         \
2929       indata = (const char*)indata + sizeof b ## _prefix;     \
2930       indatalen -= sizeof b ## _prefix;                       \
2931     }                                                         
2932
2933   if (indatalen == 20)
2934     ;  /* Assume a plain SHA-1 or RMD160 digest has been given.  */
2935   else X(SHA1,   sha1,   20, 1)
2936   else X(RMD160, rmd160, 20, 1)
2937   else X(SHA224, sha224, 28, app->app_local->extcap.is_v2)
2938   else X(SHA256, sha256, 32, app->app_local->extcap.is_v2)
2939   else X(SHA384, sha384, 48, app->app_local->extcap.is_v2)
2940   else X(SHA512, sha512, 64, app->app_local->extcap.is_v2)
2941   else if ((indatalen == 28 || indatalen == 32 
2942             || indatalen == 48 || indatalen ==64)
2943            && app->app_local->extcap.is_v2)
2944     ;  /* Assume a plain SHA-3 digest has been given.  */
2945   else
2946     {
2947       log_error (_("card does not support digest algorithm %s\n"),
2948                  gcry_md_algo_name (hashalgo));
2949       /* Or the supplied digest length does not match an algorithm.  */
2950       return gpg_error (GPG_ERR_INV_VALUE);
2951     }
2952 #undef X
2953
2954   /* Check whether an OpenPGP card of any version has been requested. */
2955   if (!strcmp (keyidstr, "OPENPGP.1"))
2956     ;
2957   else if (!strcmp (keyidstr, "OPENPGP.3"))
2958     use_auth = 1;
2959   else if (strlen (keyidstr) < 32 || strncmp (keyidstr, "D27600012401", 12))
2960     return gpg_error (GPG_ERR_INV_ID);
2961   else
2962     {
2963       for (s=keyidstr, n=0; hexdigitp (s); s++, n++)
2964         ;
2965       if (n != 32)
2966         return gpg_error (GPG_ERR_INV_ID);
2967       else if (!*s)
2968         ; /* no fingerprint given: we allow this for now. */
2969       else if (*s == '/')
2970         fpr = s + 1; 
2971       else
2972         return gpg_error (GPG_ERR_INV_ID);
2973
2974       for (s=keyidstr, n=0; n < 16; s += 2, n++)
2975         tmp_sn[n] = xtoi_2 (s);
2976
2977       if (app->serialnolen != 16)
2978         return gpg_error (GPG_ERR_INV_CARD);
2979       if (memcmp (app->serialno, tmp_sn, 16))
2980         return gpg_error (GPG_ERR_WRONG_CARD);
2981     }
2982
2983   /* If a fingerprint has been specified check it against the one on
2984      the card.  This is allows for a meaningful error message in case
2985      the key on the card has been replaced but the shadow information
2986      known to gpg was not updated.  If there is no fingerprint, gpg
2987      will detect a bogus signature anyway due to the
2988      verify-after-signing feature. */
2989   rc = fpr? check_against_given_fingerprint (app, fpr, 1) : 0;
2990   if (rc)
2991     return rc;
2992
2993   /* Concatenate prefix and digest.  */
2994 #define X(a,b,d) \
2995   if (hashalgo == GCRY_MD_ ## a && (d) )                      \
2996     {                                                         \
2997       datalen = sizeof b ## _prefix + indatalen;              \
2998       assert (datalen <= sizeof data);                        \
2999       memcpy (data, b ## _prefix, sizeof b ## _prefix);       \
3000       memcpy (data + sizeof b ## _prefix, indata, indatalen); \
3001     }                                                         
3002
3003   X(SHA1,   sha1,   1)
3004   else X(RMD160, rmd160, 1)
3005   else X(SHA224, sha224, app->app_local->extcap.is_v2)
3006   else X(SHA256, sha256, app->app_local->extcap.is_v2)
3007   else X(SHA384, sha384, app->app_local->extcap.is_v2)
3008   else X(SHA512, sha512, app->app_local->extcap.is_v2)
3009   else 
3010     return gpg_error (GPG_ERR_UNSUPPORTED_ALGORITHM);
3011 #undef X
3012
3013   /* Redirect to the AUTH command if asked to. */
3014   if (use_auth)
3015     {
3016       return do_auth (app, "OPENPGP.3", pincb, pincb_arg,
3017                       data, datalen,
3018                       outdata, outdatalen);
3019     }
3020
3021   /* Show the number of signature done using this key.  */
3022   sigcount = get_sig_counter (app);
3023   log_info (_("signatures created so far: %lu\n"), sigcount);
3024
3025   /* Check CHV if needed.  */
3026   if (!app->did_chv1 || app->force_chv1 ) 
3027     {
3028       char *pinvalue;
3029
3030       rc = verify_a_chv (app, pincb, pincb_arg, 1, sigcount, &pinvalue);
3031       if (rc)
3032         return rc;
3033
3034       app->did_chv1 = 1;
3035
3036       /* For cards with versions < 2 we want to keep CHV1 and CHV2 in
3037          sync, thus we verify CHV2 here using the given PIN.  Cards
3038          with version2 to not have the need for a separate CHV2 and
3039          internally use just one.  Obviously we can't do that if the
3040          keypad has been used. */
3041       if (!app->did_chv2 && pinvalue && !app->app_local->extcap.is_v2)
3042         {
3043           rc = iso7816_verify (app->slot, 0x82, pinvalue, strlen (pinvalue));
3044           if (gpg_err_code (rc) == GPG_ERR_BAD_PIN)
3045             rc = gpg_error (GPG_ERR_PIN_NOT_SYNCED);
3046           if (rc)
3047             {
3048               log_error (_("verify CHV%d failed: %s\n"), 2, gpg_strerror (rc));
3049               xfree (pinvalue);
3050               flush_cache_after_error (app);
3051               return rc;
3052             }
3053           app->did_chv2 = 1;
3054         }
3055       xfree (pinvalue);
3056     }
3057
3058   rc = iso7816_compute_ds (app->slot, data, datalen, outdata, outdatalen);
3059   return rc;
3060 }
3061
3062 /* Compute a digital signature using the INTERNAL AUTHENTICATE command
3063    on INDATA which is expected to be the raw message digest. For this
3064    application the KEYIDSTR consists of the serialnumber and the
3065    fingerprint delimited by a slash.  Optionally the id OPENPGP.3 may
3066    be given.
3067
3068    Note that this function may return the error code
3069    GPG_ERR_WRONG_CARD to indicate that the card currently present does
3070    not match the one required for the requested action (e.g. the
3071    serial number does not match). */
3072 static gpg_error_t 
3073 do_auth (app_t app, const char *keyidstr,
3074          gpg_error_t (*pincb)(void*, const char *, char **),
3075          void *pincb_arg,
3076          const void *indata, size_t indatalen,
3077          unsigned char **outdata, size_t *outdatalen )
3078 {
3079   int rc;
3080   unsigned char tmp_sn[20]; /* Actually 16 but we use it also for the fpr. */
3081   const char *s;
3082   int n;
3083   const char *fpr = NULL;
3084
3085   if (!keyidstr || !*keyidstr)
3086     return gpg_error (GPG_ERR_INV_VALUE);
3087   if (indatalen > 101) /* For a 2048 bit key. */
3088     return gpg_error (GPG_ERR_INV_VALUE);
3089
3090   /* Check whether an OpenPGP card of any version has been requested. */
3091   if (!strcmp (keyidstr, "OPENPGP.3"))
3092     ;
3093   else if (strlen (keyidstr) < 32 || strncmp (keyidstr, "D27600012401", 12))
3094     return gpg_error (GPG_ERR_INV_ID);
3095   else
3096     {
3097       for (s=keyidstr, n=0; hexdigitp (s); s++, n++)
3098         ;
3099       if (n != 32)
3100         return gpg_error (GPG_ERR_INV_ID);
3101       else if (!*s)
3102         ; /* no fingerprint given: we allow this for now. */
3103       else if (*s == '/')
3104         fpr = s + 1; 
3105       else
3106         return gpg_error (GPG_ERR_INV_ID);
3107
3108       for (s=keyidstr, n=0; n < 16; s += 2, n++)
3109         tmp_sn[n] = xtoi_2 (s);
3110       
3111       if (app->serialnolen != 16)
3112         return gpg_error (GPG_ERR_INV_CARD);
3113       if (memcmp (app->serialno, tmp_sn, 16))
3114         return gpg_error (GPG_ERR_WRONG_CARD);
3115     }
3116
3117   /* If a fingerprint has been specified check it against the one on
3118      the card.  This is allows for a meaningful error message in case
3119      the key on the card has been replaced but the shadow information
3120      known to gpg was not updated.  If there is no fingerprint, gpg
3121      will detect a bogus signature anyway due to the
3122      verify-after-signing feature. */
3123   rc = fpr? check_against_given_fingerprint (app, fpr, 3) : 0;
3124   if (rc)
3125     return rc;
3126
3127   rc = verify_chv2 (app, pincb, pincb_arg);
3128   if (!rc)
3129     rc = iso7816_internal_authenticate (app->slot, indata, indatalen,
3130                                         outdata, outdatalen);
3131   return rc;
3132 }
3133
3134
3135 static gpg_error_t 
3136 do_decipher (app_t app, const char *keyidstr,
3137              gpg_error_t (*pincb)(void*, const char *, char **),
3138              void *pincb_arg,
3139              const void *indata, size_t indatalen,
3140              unsigned char **outdata, size_t *outdatalen )
3141 {
3142   int rc;
3143   unsigned char tmp_sn[20]; /* actually 16 but we use it also for the fpr. */
3144   const char *s;
3145   int n;
3146   const char *fpr = NULL;
3147   int exmode;
3148
3149   if (!keyidstr || !*keyidstr || !indatalen)
3150     return gpg_error (GPG_ERR_INV_VALUE);
3151
3152   /* Check whether an OpenPGP card of any version has been requested. */
3153   if (!strcmp (keyidstr, "OPENPGP.2"))
3154     ;
3155   else if (strlen (keyidstr) < 32 || strncmp (keyidstr, "D27600012401", 12))
3156     return gpg_error (GPG_ERR_INV_ID);
3157   else
3158     {
3159       for (s=keyidstr, n=0; hexdigitp (s); s++, n++)
3160         ;
3161       if (n != 32)
3162         return gpg_error (GPG_ERR_INV_ID);
3163       else if (!*s)
3164         ; /* no fingerprint given: we allow this for now. */
3165       else if (*s == '/')
3166         fpr = s + 1; 
3167       else
3168         return gpg_error (GPG_ERR_INV_ID);
3169       
3170       for (s=keyidstr, n=0; n < 16; s += 2, n++)
3171         tmp_sn[n] = xtoi_2 (s);
3172       
3173       if (app->serialnolen != 16)
3174         return gpg_error (GPG_ERR_INV_CARD);
3175       if (memcmp (app->serialno, tmp_sn, 16))
3176         return gpg_error (GPG_ERR_WRONG_CARD);
3177     }
3178
3179   /* If a fingerprint has been specified check it against the one on
3180      the card.  This is allows for a meaningful error message in case
3181      the key on the card has been replaced but the shadow information
3182      known to gpg was not updated.  If there is no fingerprint, the
3183      decryption won't produce the right plaintext anyway. */
3184   rc = fpr? check_against_given_fingerprint (app, fpr, 2) : 0;
3185   if (rc)
3186     return rc;
3187
3188   rc = verify_chv2 (app, pincb, pincb_arg);
3189   if (!rc)
3190     {
3191       size_t fixuplen;
3192       unsigned char *fixbuf = NULL;
3193       int padind = 0;
3194
3195       /* We might encounter a couple of leading zeroes in the
3196          cryptogram.  Due to internal use of MPIs thease leading
3197          zeroes are stripped.  However the OpenPGP card expects
3198          exactly 128 bytes for the cryptogram (for a 1k key).  Thus we
3199          need to fix it up.  We do this for up to 16 leading zero
3200          bytes; a cryptogram with more than this is with a very high
3201          probability anyway broken.  */
3202       if (indatalen >= (128-16) && indatalen < 128)      /* 1024 bit key.  */
3203         fixuplen = 128 - indatalen;
3204       else if (indatalen >= (192-16) && indatalen < 192) /* 1536 bit key.  */
3205         fixuplen = 192 - indatalen;
3206       else if (indatalen >= (256-16) && indatalen < 256) /* 2048 bit key.  */
3207         fixuplen = 256 - indatalen;
3208       else if (indatalen >= (384-16) && indatalen < 384) /* 3072 bit key.  */
3209         fixuplen = 384 - indatalen;
3210       else
3211         fixuplen = 0;
3212
3213       if (fixuplen)
3214         {
3215           /* While we have to prepend stuff anyway, we can also
3216              include the padding byte here so that iso1816_decipher
3217              does not need to do another data mangling.  */
3218           fixuplen++;
3219
3220           fixbuf = xtrymalloc (fixuplen + indatalen);
3221           if (!fixbuf)
3222             return gpg_error_from_syserror ();
3223           
3224           memset (fixbuf, 0, fixuplen);
3225           memcpy (fixbuf+fixuplen, indata, indatalen);
3226           indata = fixbuf;
3227           indatalen = fixuplen + indatalen;
3228           padind = -1; /* Already padded.  */
3229         }
3230       
3231       if (app->app_local->cardcap.ext_lc_le && indatalen > 254 )
3232         exmode = 1;    /* Extended length w/o a limit.  */
3233       else if (app->app_local->cardcap.cmd_chaining && indatalen > 254)
3234         exmode = -254; /* Command chaining with max. 254 bytes.  */
3235       else
3236         exmode = 0;    
3237
3238       rc = iso7816_decipher (app->slot, exmode, 
3239                              indata, indatalen, padind,
3240                              outdata, outdatalen);
3241       xfree (fixbuf);
3242     }
3243
3244   return rc;
3245 }
3246
3247
3248 /* Perform a simple verify operation for CHV1 and CHV2, so that
3249    further operations won't ask for CHV2 and it is possible to do a
3250    cheap check on the PIN: If there is something wrong with the PIN
3251    entry system, only the regular CHV will get blocked and not the
3252    dangerous CHV3.  KEYIDSTR is the usual card's serial number; an
3253    optional fingerprint part will be ignored.
3254
3255    There is a special mode if the keyidstr is "<serialno>[CHV3]" with
3256    the "[CHV3]" being a literal string:  The Admin Pin is checked if
3257    and only if the retry counter is still at 3. */
3258 static gpg_error_t 
3259 do_check_pin (app_t app, const char *keyidstr,
3260               gpg_error_t (*pincb)(void*, const char *, char **),
3261               void *pincb_arg)
3262 {
3263   unsigned char tmp_sn[20]; 
3264   const char *s;
3265   int n;
3266   int admin_pin = 0;
3267
3268   if (!keyidstr || !*keyidstr)
3269     return gpg_error (GPG_ERR_INV_VALUE);
3270
3271   /* Check whether an OpenPGP card of any version has been requested. */
3272   if (strlen (keyidstr) < 32 || strncmp (keyidstr, "D27600012401", 12))
3273     return gpg_error (GPG_ERR_INV_ID);
3274   
3275   for (s=keyidstr, n=0; hexdigitp (s); s++, n++)
3276     ;
3277   if (n != 32)
3278     return gpg_error (GPG_ERR_INV_ID);
3279   else if (!*s)
3280     ; /* No fingerprint given: we allow this for now. */
3281   else if (*s == '/')
3282     ; /* We ignore a fingerprint. */
3283   else if (!strcmp (s, "[CHV3]") )
3284     admin_pin = 1;
3285   else
3286     return gpg_error (GPG_ERR_INV_ID);
3287
3288   for (s=keyidstr, n=0; n < 16; s += 2, n++)
3289     tmp_sn[n] = xtoi_2 (s);
3290
3291   if (app->serialnolen != 16)
3292     return gpg_error (GPG_ERR_INV_CARD);
3293   if (memcmp (app->serialno, tmp_sn, 16))
3294     return gpg_error (GPG_ERR_WRONG_CARD);
3295
3296   /* Yes, there is a race conditions: The user might pull the card
3297      right here and we won't notice that.  However this is not a
3298      problem and the check above is merely for a graceful failure
3299      between operations. */
3300
3301   if (admin_pin)
3302     {
3303       void *relptr;
3304       unsigned char *value;
3305       size_t valuelen;
3306       int count;
3307       
3308       relptr = get_one_do (app, 0x00C4, &value, &valuelen, NULL);
3309       if (!relptr || valuelen < 7)
3310         {
3311           log_error (_("error retrieving CHV status from card\n"));
3312           xfree (relptr);
3313           return gpg_error (GPG_ERR_CARD);
3314         }
3315       count = value[6];
3316       xfree (relptr);
3317
3318       if (!count)
3319         {
3320           log_info (_("card is permanently locked!\n"));
3321           return gpg_error (GPG_ERR_BAD_PIN);
3322         }
3323       else if (value[6] < 3)
3324         {
3325           log_info (_("verification of Admin PIN is currently prohibited "
3326                       "through this command\n"));
3327           return gpg_error (GPG_ERR_GENERAL);
3328         }
3329
3330       app->did_chv3 = 0; /* Force verification.  */
3331       return verify_chv3 (app, pincb, pincb_arg);
3332     }
3333   else
3334     return verify_chv2 (app, pincb, pincb_arg);
3335 }
3336
3337
3338 /* Show information about card capabilities.  */
3339 static void
3340 show_caps (struct app_local_s *s)
3341 {
3342   log_info ("Version-2 ......: %s\n", s->extcap.is_v2? "yes":"no");
3343   log_info ("Get-Challenge ..: %s", s->extcap.get_challenge? "yes":"no");
3344   if (s->extcap.get_challenge)
3345     log_printf (" (%u bytes max)", s->extcap.max_get_challenge);
3346   log_info ("Key-Import .....: %s\n", s->extcap.key_import? "yes":"no");
3347   log_info ("Change-Force-PW1: %s\n", s->extcap.change_force_chv? "yes":"no");
3348   log_info ("Private-DOs ....: %s\n", s->extcap.private_dos? "yes":"no");
3349   log_info ("Algo-Attr-Change: %s\n", s->extcap.algo_attr_change? "yes":"no");
3350   log_info ("SM-Support .....: %s", s->extcap.sm_supported? "yes":"no");
3351   if (s->extcap.sm_supported)
3352     log_printf (" (%s)", s->extcap.sm_aes128? "AES-128":"3DES");
3353   log_info ("Max-Cert3-Len ..: %u\n", s->extcap.max_certlen_3);
3354   log_info ("Max-Cmd-Data ...: %u\n", s->extcap.max_cmd_data);
3355   log_info ("Max-Rsp-Data ...: %u\n", s->extcap.max_rsp_data);
3356   log_info ("Cmd-Chaining ...: %s\n", s->cardcap.cmd_chaining?"yes":"no");
3357   log_info ("Ext-Lc-Le ......: %s\n", s->cardcap.ext_lc_le?"yes":"no");
3358   log_info ("Status Indicator: %02X\n", s->status_indicator);
3359
3360   log_info ("GnuPG-No-Sync ..: %s\n",  s->flags.no_sync? "yes":"no");
3361   log_info ("GnuPG-Def-PW2 ..: %s\n",  s->flags.def_chv2? "yes":"no");
3362 }
3363
3364
3365 /* Parse the historical bytes in BUFFER of BUFLEN and store them in
3366    APPLOC.  */
3367 static void
3368 parse_historical (struct app_local_s *apploc, 
3369                   const unsigned char * buffer, size_t buflen)
3370 {
3371   /* Example buffer: 00 31 C5 73 C0 01 80 00 90 00  */
3372   if (buflen < 4)
3373     {
3374       log_error ("warning: historical bytes are too short\n");
3375       return; /* Too short.  */
3376     }
3377   if (*buffer)
3378     {
3379       log_error ("warning: bad category indicator in historical bytes\n");
3380       return; 
3381     }
3382   
3383   /* Skip category indicator.  */
3384   buffer++;
3385   buflen--;
3386
3387   /* Get the status indicator.  */
3388   apploc->status_indicator = buffer[buflen-3];
3389   buflen -= 3;
3390
3391   /* Parse the compact TLV.  */
3392   while (buflen)
3393     {
3394       unsigned int tag = (*buffer & 0xf0) >> 4;
3395       unsigned int len = (*buffer & 0x0f);
3396       if (len+1 > buflen)
3397         {
3398           log_error ("warning: bad Compact-TLV in historical bytes\n");
3399           return; /* Error.  */
3400         }
3401       buffer++;
3402       buflen--;
3403       if (tag == 7 && len == 3)
3404         {
3405           /* Card capabilities.  */
3406           apploc->cardcap.cmd_chaining = !!(buffer[2] & 0x80);
3407           apploc->cardcap.ext_lc_le    = !!(buffer[2] & 0x40);
3408         }
3409       buffer += len;
3410       buflen -= len;
3411     }
3412 }
3413
3414
3415 /* Parse and optionally show the algorithm attributes for KEYNO.
3416    KEYNO must be in the range 0..2.  */
3417 static void 
3418 parse_algorithm_attribute (app_t app, int keyno)
3419
3420   unsigned char *buffer;
3421   size_t buflen;
3422   void *relptr;
3423   const char const desc[3][5] = {"sign", "encr", "auth"};
3424
3425   assert (keyno >=0 && keyno <= 2);
3426
3427   app->app_local->keyattr[keyno].n_bits = 0;
3428       
3429   relptr = get_one_do (app, 0xC1+keyno, &buffer, &buflen, NULL);
3430   if (!relptr)
3431     {
3432       log_error ("error reading DO 0x%02X\n", 0xc1+keyno);
3433       return;
3434     }
3435   if (buflen < 1)
3436     {
3437       log_error ("error reading DO 0x%02X\n", 0xc1+keyno);
3438       xfree (relptr);
3439       return;
3440     }
3441
3442   if (opt.verbose)
3443     log_info ("Key-Attr-%s ..: ", desc[keyno]);
3444   if (*buffer == 1 && (buflen == 5 || buflen == 6))
3445     {
3446       app->app_local->keyattr[keyno].n_bits = (buffer[1]<<8 | buffer[2]);
3447       app->app_local->keyattr[keyno].e_bits = (buffer[3]<<8 | buffer[4]);
3448       app->app_local->keyattr[keyno].format = 0;
3449       if (buflen < 6)
3450         app->app_local->keyattr[keyno].format = RSA_STD;
3451       else
3452         app->app_local->keyattr[keyno].format = (buffer[5] == 0? RSA_STD   :
3453                                                  buffer[5] == 1? RSA_STD_N :
3454                                                  buffer[5] == 2? RSA_CRT   :
3455                                                  buffer[5] == 3? RSA_CRT_N : 
3456                                                  RSA_UNKNOWN_FMT);
3457
3458       if (opt.verbose)
3459         log_printf
3460           ("RSA, n=%u, e=%u, fmt=%s\n",
3461            app->app_local->keyattr[keyno].n_bits,
3462            app->app_local->keyattr[keyno].e_bits,
3463            app->app_local->keyattr[keyno].format == RSA_STD?  "std"  :
3464            app->app_local->keyattr[keyno].format == RSA_STD_N?"std+n":
3465            app->app_local->keyattr[keyno].format == RSA_CRT?  "crt"  :
3466            app->app_local->keyattr[keyno].format == RSA_CRT_N?"crt+n":"?");
3467     }
3468   else if (opt.verbose)
3469     log_printhex ("", buffer, buflen);
3470
3471   xfree (relptr);
3472 }
3473
3474 /* Select the OpenPGP application on the card in SLOT.  This function
3475    must be used before any other OpenPGP application functions. */
3476 gpg_error_t
3477 app_select_openpgp (app_t app)
3478 {
3479   static char const aid[] = { 0xD2, 0x76, 0x00, 0x01, 0x24, 0x01 };
3480   int slot = app->slot;
3481   int rc;
3482   unsigned char *buffer;
3483   size_t buflen;
3484   void *relptr;
3485   
3486   /* Note that the card can't cope with P2=0xCO, thus we need to pass a
3487      special flag value. */
3488   rc = iso7816_select_application (slot, aid, sizeof aid, 0x0001);
3489   if (!rc)
3490     {
3491       unsigned int manufacturer;
3492
3493       app->apptype = "OPENPGP";
3494
3495       app->did_chv1 = 0;
3496       app->did_chv2 = 0;
3497       app->did_chv3 = 0;
3498       app->app_local = NULL;
3499
3500       /* The OpenPGP card returns the serial number as part of the
3501          AID; because we prefer to use OpenPGP serial numbers, we
3502          replace a possibly already set one from a EF.GDO with this
3503          one.  Note, that for current OpenPGP cards, no EF.GDO exists
3504          and thus it won't matter at all. */
3505       rc = iso7816_get_data (slot, 0x004F, &buffer, &buflen);
3506       if (rc)
3507         goto leave;
3508       if (opt.verbose)
3509         {
3510           log_info ("AID: ");
3511           log_printhex ("", buffer, buflen);
3512         }
3513
3514       app->card_version = buffer[6] << 8;
3515       app->card_version |= buffer[7];
3516       manufacturer = (buffer[8]<<8 | buffer[9]);
3517
3518       xfree (app->serialno);
3519       app->serialno = buffer;
3520       app->serialnolen = buflen;
3521       buffer = NULL;
3522       app->app_local = xtrycalloc (1, sizeof *app->app_local);
3523       if (!app->app_local)
3524         {
3525           rc = gpg_error (gpg_err_code_from_errno (errno));
3526           goto leave;
3527         }
3528
3529       if (app->card_version >= 0x0200)
3530         app->app_local->extcap.is_v2 = 1;
3531
3532
3533       /* Read the historical bytes.  */
3534       relptr = get_one_do (app, 0x5f52, &buffer, &buflen, NULL);
3535       if (relptr)
3536         {
3537           if (opt.verbose)
3538             {
3539               log_info ("Historical Bytes: ");
3540               log_printhex ("", buffer, buflen);
3541             }
3542           parse_historical (app->app_local, buffer, buflen);
3543           xfree (relptr);
3544         }
3545
3546       /* Read the force-chv1 flag.  */
3547       relptr = get_one_do (app, 0x00C4, &buffer, &buflen, NULL);
3548       if (!relptr)
3549         {
3550           log_error (_("can't access %s - invalid OpenPGP card?\n"),
3551                      "CHV Status Bytes");
3552           goto leave;
3553         }
3554       app->force_chv1 = (buflen && *buffer == 0);
3555       xfree (relptr);
3556
3557       /* Read the extended capabilities.  */
3558       relptr = get_one_do (app, 0x00C0, &buffer, &buflen, NULL);
3559       if (!relptr)
3560         {
3561           log_error (_("can't access %s - invalid OpenPGP card?\n"),
3562                      "Extended Capability Flags" );
3563           goto leave;
3564         }
3565       if (buflen)
3566         {
3567           app->app_local->extcap.sm_supported     = !!(*buffer & 0x80);
3568           app->app_local->extcap.get_challenge    = !!(*buffer & 0x40);
3569           app->app_local->extcap.key_import       = !!(*buffer & 0x20);
3570           app->app_local->extcap.change_force_chv = !!(*buffer & 0x10);
3571           app->app_local->extcap.private_dos      = !!(*buffer & 0x08);
3572           app->app_local->extcap.algo_attr_change = !!(*buffer & 0x04);
3573         }
3574       if (buflen >= 10)
3575         {
3576           /* Available with v2 cards.  */
3577           app->app_local->extcap.sm_aes128     = (buffer[1] == 1);
3578           app->app_local->extcap.max_get_challenge 
3579                                                = (buffer[2] << 8 | buffer[3]);
3580           app->app_local->extcap.max_certlen_3 = (buffer[4] << 8 | buffer[5]);
3581           app->app_local->extcap.max_cmd_data  = (buffer[6] << 8 | buffer[7]);
3582           app->app_local->extcap.max_rsp_data  = (buffer[8] << 8 | buffer[9]);
3583         }
3584       xfree (relptr);
3585
3586       /* Some of the first cards accidently don't set the
3587          CHANGE_FORCE_CHV bit but allow it anyway. */
3588       if (app->card_version <= 0x0100 && manufacturer == 1)
3589         app->app_local->extcap.change_force_chv = 1;
3590
3591       parse_login_data (app);
3592
3593       if (opt.verbose)
3594         show_caps (app->app_local);
3595
3596       parse_algorithm_attribute (app, 0);
3597       parse_algorithm_attribute (app, 1);
3598       parse_algorithm_attribute (app, 2);
3599       
3600       if (opt.verbose > 1)
3601         dump_all_do (slot);
3602
3603       app->fnc.deinit = do_deinit;
3604       app->fnc.learn_status = do_learn_status;
3605       app->fnc.readcert = do_readcert;
3606       app->fnc.readkey = do_readkey;
3607       app->fnc.getattr = do_getattr;
3608       app->fnc.setattr = do_setattr;
3609       app->fnc.writecert = do_writecert;
3610       app->fnc.writekey = do_writekey;
3611       app->fnc.genkey = do_genkey;
3612       app->fnc.sign = do_sign;
3613       app->fnc.auth = do_auth;
3614       app->fnc.decipher = do_decipher;
3615       app->fnc.change_pin = do_change_pin;
3616       app->fnc.check_pin = do_check_pin;
3617    }
3618
3619 leave:
3620   if (rc)
3621     do_deinit (app);
3622   return rc;
3623 }
3624
3625
3626