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