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