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