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