Fix pinpad input support
[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   int with_resetcode = 0;
1919   iso7816_pininfo_t pininfo;
1920   int use_keypad = 0;
1921   int minlen = 6;
1922
1923   (void)ctrl;
1924   memset (&pininfo, 0, sizeof pininfo);
1925   pininfo.mode = 1;
1926   pininfo.minlen = minlen;
1927
1928   if (reset_mode && chvno == 3)
1929     {
1930       rc = gpg_error (GPG_ERR_INV_ID);
1931       goto leave;
1932     }
1933
1934   if (!app->app_local->extcap.is_v2)
1935     {
1936       /* Version 1 cards.  */
1937
1938       if (reset_mode || chvno == 3)
1939         {
1940           /* We always require that the PIN is entered. */
1941           app->did_chv3 = 0;
1942           rc = verify_chv3 (app, pincb, pincb_arg);
1943           if (rc)
1944             goto leave;
1945         }
1946       else if (chvno == 1 || chvno == 2)
1947         {
1948           /* On a v1.x card CHV1 and CVH2 should always have the same
1949              value, thus we enforce it here.  */
1950           int save_force = app->force_chv1;
1951
1952           app->force_chv1 = 0;
1953           app->did_chv1 = 0;
1954           app->did_chv2 = 0;
1955           rc = verify_chv2 (app, pincb, pincb_arg);
1956           app->force_chv1 = save_force;
1957           if (rc)
1958             goto leave;
1959         }
1960       else
1961         {
1962           rc = gpg_error (GPG_ERR_INV_ID);
1963           goto leave;
1964         }
1965     }
1966   else
1967     {
1968       /* Version 2 cards.  */
1969
1970       if (!opt.disable_keypad
1971           && !iso7816_check_keypad (app->slot,
1972                                     ISO7816_CHANGE_REFERENCE_DATA, &pininfo))
1973         use_keypad = 1;
1974
1975       if (reset_mode)
1976         {
1977           /* To reset a PIN the Admin PIN is required. */
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 (!use_keypad && (chvno == 1 || chvno == 3))
1987         {
1988           char *promptbuf = NULL;
1989           const char *prompt;
1990
1991           if (chvno == 3)
1992             {
1993               minlen = 8;
1994               rc = build_enter_admin_pin_prompt (app, &promptbuf);
1995               if (rc)
1996                 goto leave;
1997               prompt = promptbuf;
1998             }
1999           else
2000             prompt = _("||Please enter the PIN");
2001           rc = pincb (pincb_arg, prompt, &oldpinvalue);
2002           xfree (promptbuf);
2003           promptbuf = NULL;
2004           if (rc)
2005             {
2006               log_info (_("PIN callback returned error: %s\n"),
2007                         gpg_strerror (rc));
2008               goto leave;
2009             }
2010
2011           if (strlen (oldpinvalue) < minlen)
2012             {
2013               log_info (_("PIN for CHV%d is too short;"
2014                           " minimum length is %d\n"), chvno, minlen);
2015               rc = gpg_error (GPG_ERR_BAD_PIN);
2016               goto leave;
2017             }
2018         }
2019       else if (chvno == 2)
2020         {
2021           /* There is no PW2 for v2 cards.  We use this condition to
2022              allow a PW reset using the Reset Code.  */
2023           void *relptr;
2024           unsigned char *value;
2025           size_t valuelen;
2026           int remaining;
2027
2028           with_resetcode = 1;
2029           minlen = 8;
2030           relptr = get_one_do (app, 0x00C4, &value, &valuelen, NULL);
2031           if (!relptr || valuelen < 7)
2032             {
2033               log_error (_("error retrieving CHV status from card\n"));
2034               xfree (relptr);
2035               rc = gpg_error (GPG_ERR_CARD);
2036               goto leave;
2037             }
2038           remaining = value[5];
2039           xfree (relptr);
2040           if (!remaining)
2041             {
2042               log_error (_("Reset Code not or not anymore available\n"));
2043               rc = gpg_error (GPG_ERR_BAD_PIN);
2044               goto leave;
2045             }
2046
2047           if (!use_keypad)
2048             {
2049               rc = pincb (pincb_arg,
2050                           _("||Please enter the Reset Code for the card"),
2051                           &resetcode);
2052               if (rc)
2053                 {
2054                   log_info (_("PIN callback returned error: %s\n"),
2055                             gpg_strerror (rc));
2056                   goto leave;
2057                 }
2058               if (strlen (resetcode) < minlen)
2059                 {
2060                   log_info (_("Reset Code is too short; minimum length is %d\n"),
2061                             minlen);
2062                   rc = gpg_error (GPG_ERR_BAD_PIN);
2063                   goto leave;
2064                 }
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 (with_resetcode)
2097     {
2098       if (use_keypad)
2099         {
2100           rc = pincb (pincb_arg,
2101                       _("||Please enter the Reset Code for the card and New PIN"),
2102                       NULL);
2103           if (rc)
2104             {
2105               log_info (_("PIN callback returned error: %s\n"),
2106                         gpg_strerror (rc));
2107               goto leave;
2108             }
2109           rc = iso7816_reset_retry_counter_with_rc_kp (app->slot, 0x81,
2110                                                        &pininfo);
2111           pincb (pincb_arg, NULL, NULL); /* Dismiss the prompt. */
2112         }
2113       else
2114         {
2115           char *buffer;
2116
2117           buffer = xtrymalloc (strlen (resetcode) + strlen (pinvalue) + 1);
2118           if (!buffer)
2119             rc = gpg_error_from_syserror ();
2120           else
2121             {
2122               strcpy (stpcpy (buffer, resetcode), pinvalue);
2123               rc = iso7816_reset_retry_counter_with_rc (app->slot, 0x81,
2124                                                         buffer, strlen (buffer));
2125               wipememory (buffer, strlen (buffer));
2126               xfree (buffer);
2127             }
2128         }
2129     }
2130   else if (set_resetcode)
2131     {
2132       if (use_keypad)
2133         {
2134           rc = pincb (pincb_arg,  _("|RN|New Reset Code"), NULL);
2135           if (rc)
2136             {
2137               log_info (_("PIN callback returned error: %s\n"),
2138                         gpg_strerror (rc));
2139               goto leave;
2140             }
2141           rc = iso7816_put_data_kp (app->slot, 0xD3, &pininfo);
2142           pincb (pincb_arg, NULL, NULL); /* Dismiss the prompt. */
2143         }
2144       else
2145         if (strlen (pinvalue) < 8)
2146           {
2147             log_error (_("Reset Code is too short; minimum length is %d\n"), 8);
2148             rc = gpg_error (GPG_ERR_BAD_PIN);
2149           }
2150         else
2151           rc = iso7816_put_data (app->slot, 0, 0xD3,
2152                                  pinvalue, strlen (pinvalue));
2153     }
2154   else if (reset_mode)
2155     {
2156       if (use_keypad)
2157         {
2158           rc = pincb (pincb_arg, _("|N|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_reset_retry_counter_kp (app->slot, 0x81, &pininfo);
2166           pincb (pincb_arg, NULL, NULL); /* Dismiss the prompt. */
2167         }
2168       else
2169         {
2170           rc = iso7816_reset_retry_counter (app->slot, 0x81,
2171                                             pinvalue, strlen (pinvalue));
2172           if (!rc && !app->app_local->extcap.is_v2)
2173             rc = iso7816_reset_retry_counter (app->slot, 0x82,
2174                                               pinvalue, strlen (pinvalue));
2175         }
2176     }
2177   else if (!app->app_local->extcap.is_v2)
2178     {
2179       /* Version 1 cards.  */
2180       if (chvno == 1 || chvno == 2)
2181         {
2182           rc = iso7816_change_reference_data (app->slot, 0x81, NULL, 0,
2183                                               pinvalue, strlen (pinvalue));
2184           if (!rc)
2185             rc = iso7816_change_reference_data (app->slot, 0x82, NULL, 0,
2186                                                 pinvalue, strlen (pinvalue));
2187         }
2188       else /* CHVNO == 3 */
2189         {
2190           rc = iso7816_change_reference_data (app->slot, 0x80 + chvno, NULL, 0,
2191                                               pinvalue, strlen (pinvalue));
2192         }
2193     }
2194   else
2195     {
2196       /* Version 2 cards.  */
2197       assert (chvno == 1 || chvno == 3);
2198
2199       if (use_keypad)
2200         {
2201           rc = pincb (pincb_arg,
2202                       chvno == 3 ?
2203                       _("||Please enter the Admin PIN and New Admin PIN") :
2204                       _("||Please enter the PIN and New PIN"), NULL);
2205           if (rc)
2206             {
2207               log_info (_("PIN callback returned error: %s\n"),
2208                         gpg_strerror (rc));
2209               goto leave;
2210             }
2211           rc = iso7816_change_reference_data_kp (app->slot, 0x80 + chvno,
2212                                                  &pininfo);
2213           pincb (pincb_arg, NULL, NULL); /* Dismiss the prompt. */
2214         }
2215       else
2216         rc = iso7816_change_reference_data (app->slot, 0x80 + chvno,
2217                                             oldpinvalue, strlen (oldpinvalue),
2218                                             pinvalue, strlen (pinvalue));
2219     }
2220
2221   if (pinvalue)
2222     {
2223       wipememory (pinvalue, strlen (pinvalue));
2224       xfree (pinvalue);
2225     }
2226   if (rc)
2227     flush_cache_after_error (app);
2228
2229  leave:
2230   if (resetcode)
2231     {
2232       wipememory (resetcode, strlen (resetcode));
2233       xfree (resetcode);
2234     }
2235   if (oldpinvalue)
2236     {
2237       wipememory (oldpinvalue, strlen (oldpinvalue));
2238       xfree (oldpinvalue);
2239     }
2240   return rc;
2241 }
2242
2243
2244 /* Check whether a key already exists.  KEYIDX is the index of the key
2245    (0..2).  If FORCE is TRUE a diagnositic will be printed but no
2246    error returned if the key already exists.  The flag GENERATING is
2247    only used to print correct messages. */
2248 static gpg_error_t
2249 does_key_exist (app_t app, int keyidx, int generating, int force)
2250 {
2251   const unsigned char *fpr;
2252   unsigned char *buffer;
2253   size_t buflen, n;
2254   int i;
2255
2256   assert (keyidx >=0 && keyidx <= 2);
2257
2258   if (iso7816_get_data (app->slot, 0, 0x006E, &buffer, &buflen))
2259     {
2260       log_error (_("error reading application data\n"));
2261       return gpg_error (GPG_ERR_GENERAL);
2262     }
2263   fpr = find_tlv (buffer, buflen, 0x00C5, &n);
2264   if (!fpr || n < 60)
2265     {
2266       log_error (_("error reading fingerprint DO\n"));
2267       xfree (buffer);
2268       return gpg_error (GPG_ERR_GENERAL);
2269     }
2270   fpr += 20*keyidx;
2271   for (i=0; i < 20 && !fpr[i]; i++)
2272     ;
2273   xfree (buffer);
2274   if (i!=20 && !force)
2275     {
2276       log_error (_("key already exists\n"));
2277       return gpg_error (GPG_ERR_EEXIST);
2278     }
2279   else if (i!=20)
2280     log_info (_("existing key will be replaced\n"));
2281   else if (generating)
2282     log_info (_("generating new key\n"));
2283   else
2284     log_info (_("writing new key\n"));
2285   return 0;
2286 }
2287
2288
2289 /* Create a TLV tag and value and store it at BUFFER.  Return the length
2290    of tag and length.  A LENGTH greater than 65535 is truncated. */
2291 static size_t
2292 add_tlv (unsigned char *buffer, unsigned int tag, size_t length)
2293 {
2294   unsigned char *p = buffer;
2295
2296   assert (tag <= 0xffff);
2297   if ( tag > 0xff )
2298     *p++ = tag >> 8;
2299   *p++ = tag;
2300   if (length < 128)
2301     *p++ = length;
2302   else if (length < 256)
2303     {
2304       *p++ = 0x81;
2305       *p++ = length;
2306     }
2307   else
2308     {
2309       if (length > 0xffff)
2310         length = 0xffff;
2311       *p++ = 0x82;
2312       *p++ = length >> 8;
2313       *p++ = length;
2314     }
2315
2316   return p - buffer;
2317 }
2318
2319
2320 /* Build the private key template as specified in the OpenPGP specs
2321    v2.0 section 4.3.3.7.  */
2322 static gpg_error_t
2323 build_privkey_template (app_t app, int keyno,
2324                         const unsigned char *rsa_n, size_t rsa_n_len,
2325                         const unsigned char *rsa_e, size_t rsa_e_len,
2326                         const unsigned char *rsa_p, size_t rsa_p_len,
2327                         const unsigned char *rsa_q, size_t rsa_q_len,
2328                         unsigned char **result, size_t *resultlen)
2329 {
2330   size_t rsa_e_reqlen;
2331   unsigned char privkey[7*(1+3)];
2332   size_t privkey_len;
2333   unsigned char exthdr[2+2+3];
2334   size_t exthdr_len;
2335   unsigned char suffix[2+3];
2336   size_t suffix_len;
2337   unsigned char *tp;
2338   size_t datalen;
2339   unsigned char *template;
2340   size_t template_size;
2341
2342   *result = NULL;
2343   *resultlen = 0;
2344
2345   switch (app->app_local->keyattr[keyno].format)
2346     {
2347     case RSA_STD:
2348     case RSA_STD_N:
2349       break;
2350     case RSA_CRT:
2351     case RSA_CRT_N:
2352       return gpg_error (GPG_ERR_NOT_SUPPORTED);
2353
2354     default:
2355       return gpg_error (GPG_ERR_INV_VALUE);
2356     }
2357
2358   /* Get the required length for E.  */
2359   rsa_e_reqlen = app->app_local->keyattr[keyno].e_bits/8;
2360   assert (rsa_e_len <= rsa_e_reqlen);
2361
2362   /* Build the 7f48 cardholder private key template.  */
2363   datalen = 0;
2364   tp = privkey;
2365
2366   tp += add_tlv (tp, 0x91, rsa_e_reqlen);
2367   datalen += rsa_e_reqlen;
2368
2369   tp += add_tlv (tp, 0x92, rsa_p_len);
2370   datalen += rsa_p_len;
2371
2372   tp += add_tlv (tp, 0x93, rsa_q_len);
2373   datalen += rsa_q_len;
2374
2375   if (app->app_local->keyattr[keyno].format == RSA_STD_N
2376       || app->app_local->keyattr[keyno].format == RSA_CRT_N)
2377     {
2378       tp += add_tlv (tp, 0x97, rsa_n_len);
2379       datalen += rsa_n_len;
2380     }
2381   privkey_len = tp - privkey;
2382
2383   /* Build the extended header list without the private key template.  */
2384   tp = exthdr;
2385   *tp++ = keyno ==0 ? 0xb6 : keyno == 1? 0xb8 : 0xa4;
2386   *tp++ = 0;
2387   tp += add_tlv (tp, 0x7f48, privkey_len);
2388   exthdr_len = tp - exthdr;
2389
2390   /* Build the 5f48 suffix of the data.  */
2391   tp = suffix;
2392   tp += add_tlv (tp, 0x5f48, datalen);
2393   suffix_len = tp - suffix;
2394
2395   /* Now concatenate everything.  */
2396   template_size = (1 + 3   /* 0x4d and len. */
2397                    + exthdr_len
2398                    + privkey_len
2399                    + suffix_len
2400                    + datalen);
2401   tp = template = xtrymalloc_secure (template_size);
2402   if (!template)
2403     return gpg_error_from_syserror ();
2404
2405   tp += add_tlv (tp, 0x4d, exthdr_len + privkey_len + suffix_len + datalen);
2406   memcpy (tp, exthdr, exthdr_len);
2407   tp += exthdr_len;
2408   memcpy (tp, privkey, privkey_len);
2409   tp += privkey_len;
2410   memcpy (tp, suffix, suffix_len);
2411   tp += suffix_len;
2412
2413   memcpy (tp, rsa_e, rsa_e_len);
2414   if (rsa_e_len < rsa_e_reqlen)
2415     {
2416       /* Right justify E. */
2417       memmove (tp + rsa_e_reqlen - rsa_e_len, tp, rsa_e_len);
2418       memset (tp, 0, rsa_e_reqlen - rsa_e_len);
2419     }
2420   tp += rsa_e_reqlen;
2421
2422   memcpy (tp, rsa_p, rsa_p_len);
2423   tp += rsa_p_len;
2424
2425   memcpy (tp, rsa_q, rsa_q_len);
2426   tp += rsa_q_len;
2427
2428   if (app->app_local->keyattr[keyno].format == RSA_STD_N
2429       || app->app_local->keyattr[keyno].format == RSA_CRT_N)
2430     {
2431       memcpy (tp, rsa_n, rsa_n_len);
2432       tp += rsa_n_len;
2433     }
2434
2435   /* Sanity check.  We don't know the exact length because we
2436      allocated 3 bytes for the first length header.  */
2437   assert (tp - template <= template_size);
2438
2439   *result = template;
2440   *resultlen = tp - template;
2441   return 0;
2442 }
2443
2444
2445 /* Helper for do_writekley to change the size of a key.  Not ethat
2446    this deletes the entire key without asking.  */
2447 static gpg_error_t
2448 change_keyattr (app_t app, int keyno, unsigned int nbits,
2449                 gpg_error_t (*pincb)(void*, const char *, char **),
2450                 void *pincb_arg)
2451 {
2452   gpg_error_t err;
2453   unsigned char *buffer;
2454   size_t buflen;
2455   void *relptr;
2456
2457   assert (keyno >=0 && keyno <= 2);
2458
2459   if (nbits > 4096)
2460     return gpg_error (GPG_ERR_TOO_LARGE);
2461
2462   /* Read the current attributes into a buffer.  */
2463   relptr = get_one_do (app, 0xC1+keyno, &buffer, &buflen, NULL);
2464   if (!relptr)
2465     return gpg_error (GPG_ERR_CARD);
2466   if (buflen < 6 || buffer[0] != 1)
2467     {
2468       /* Attriutes too short or not an RSA key.  */
2469       xfree (relptr);
2470       return gpg_error (GPG_ERR_CARD);
2471     }
2472
2473   /* We only change n_bits and don't touch anything else.  Before we
2474      do so, we round up NBITS to a sensible way in the same way as
2475      gpg's key generation does it.  This may help to sort out problems
2476      with a few bits too short keys.  */
2477   nbits = ((nbits + 31) / 32) * 32;
2478   buffer[1] = (nbits >> 8);
2479   buffer[2] = nbits;
2480
2481   /* Prepare for storing the key.  */
2482   err = verify_chv3 (app, pincb, pincb_arg);
2483   if (err)
2484     {
2485       xfree (relptr);
2486       return err;
2487     }
2488
2489   /* Change the attribute.  */
2490   err = iso7816_put_data (app->slot, 0, 0xC1+keyno, buffer, buflen);
2491   xfree (relptr);
2492   if (err)
2493     log_error ("error changing size of key %d to %u bits\n", keyno+1, nbits);
2494   else
2495     log_info ("size of key %d changed to %u bits\n", keyno+1, nbits);
2496   flush_cache (app);
2497   parse_algorithm_attribute (app, keyno);
2498   app->did_chv1 = 0;
2499   app->did_chv2 = 0;
2500   app->did_chv3 = 0;
2501   return err;
2502 }
2503
2504
2505 /* Helper to process an setattr command for name KEY-ATTR.  It expects
2506    a string "--force <keyno> <algo> <nbits>" in (VALUE,VALUELEN).  */
2507 static gpg_error_t
2508 change_keyattr_from_string (app_t app,
2509                             gpg_error_t (*pincb)(void*, const char *, char **),
2510                             void *pincb_arg,
2511                             const void *value, size_t valuelen)
2512 {
2513   gpg_error_t err;
2514   char *string;
2515   int keyno, algo;
2516   unsigned int nbits;
2517
2518   /* VALUE is expected to be a string but not guaranteed to be
2519      terminated.  Thus copy it to an allocated buffer first. */
2520   string = xtrymalloc (valuelen+1);
2521   if (!string)
2522     return gpg_error_from_syserror ();
2523   memcpy (string, value, valuelen);
2524   string[valuelen] = 0;
2525
2526   /* Because this function deletes the key we require the string
2527      "--force" in the data to make clear that something serious might
2528      happen.  */
2529   if (sscanf (string, " --force %d %d %u", &keyno, &algo, &nbits) != 3)
2530     err = gpg_error (GPG_ERR_INV_DATA);
2531   else if (keyno < 1 || keyno > 3)
2532     err = gpg_error (GPG_ERR_INV_ID);
2533   else if (algo != 1)
2534     err = gpg_error (GPG_ERR_PUBKEY_ALGO); /* Not RSA.  */
2535   else if (nbits < 1024)
2536     err = gpg_error (GPG_ERR_TOO_SHORT);
2537   else
2538     err = change_keyattr (app, keyno-1, nbits, pincb, pincb_arg);
2539
2540   xfree (string);
2541   return err;
2542 }
2543
2544
2545 /* Handle the WRITEKEY command for OpenPGP.  This function expects a
2546    canonical encoded S-expression with the secret key in KEYDATA and
2547    its length (for assertions) in KEYDATALEN.  KEYID needs to be the
2548    usual keyid which for OpenPGP is the string "OPENPGP.n" with
2549    n=1,2,3.  Bit 0 of FLAGS indicates whether an existing key shall
2550    get overwritten.  PINCB and PINCB_ARG are the usual arguments for
2551    the pinentry callback.  */
2552 static gpg_error_t
2553 do_writekey (app_t app, ctrl_t ctrl,
2554              const char *keyid, unsigned int flags,
2555              gpg_error_t (*pincb)(void*, const char *, char **),
2556              void *pincb_arg,
2557              const unsigned char *keydata, size_t keydatalen)
2558 {
2559   gpg_error_t err;
2560   int force = (flags & 1);
2561   int keyno;
2562   const unsigned char *buf, *tok;
2563   size_t buflen, toklen;
2564   int depth, last_depth1, last_depth2;
2565   const unsigned char *rsa_n = NULL;
2566   const unsigned char *rsa_e = NULL;
2567   const unsigned char *rsa_p = NULL;
2568   const unsigned char *rsa_q = NULL;
2569   size_t rsa_n_len, rsa_e_len, rsa_p_len, rsa_q_len;
2570   unsigned int nbits;
2571   unsigned int maxbits;
2572   unsigned char *template = NULL;
2573   unsigned char *tp;
2574   size_t template_len;
2575   unsigned char fprbuf[20];
2576   u32 created_at = 0;
2577
2578   (void)ctrl;
2579
2580   if (!strcmp (keyid, "OPENPGP.1"))
2581     keyno = 0;
2582   else if (!strcmp (keyid, "OPENPGP.2"))
2583     keyno = 1;
2584   else if (!strcmp (keyid, "OPENPGP.3"))
2585     keyno = 2;
2586   else
2587     return gpg_error (GPG_ERR_INV_ID);
2588
2589   err = does_key_exist (app, keyno, 0, force);
2590   if (err)
2591     return err;
2592
2593
2594   /*
2595      Parse the S-expression
2596    */
2597   buf = keydata;
2598   buflen = keydatalen;
2599   depth = 0;
2600   if ((err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen)))
2601     goto leave;
2602   if ((err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen)))
2603     goto leave;
2604   if (!tok || toklen != 11 || memcmp ("private-key", tok, toklen))
2605     {
2606       if (!tok)
2607         ;
2608       else if (toklen == 21 && !memcmp ("protected-private-key", tok, toklen))
2609         log_info ("protected-private-key passed to writekey\n");
2610       else if (toklen == 20 && !memcmp ("shadowed-private-key", tok, toklen))
2611         log_info ("shadowed-private-key passed to writekey\n");
2612       err = gpg_error (GPG_ERR_BAD_SECKEY);
2613       goto leave;
2614     }
2615   if ((err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen)))
2616     goto leave;
2617   if ((err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen)))
2618     goto leave;
2619   if (!tok || toklen != 3 || memcmp ("rsa", tok, toklen))
2620     {
2621       err = gpg_error (GPG_ERR_WRONG_PUBKEY_ALGO);
2622       goto leave;
2623     }
2624   last_depth1 = depth;
2625   while (!(err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen))
2626          && depth && depth >= last_depth1)
2627     {
2628       if (tok)
2629         {
2630           err = gpg_error (GPG_ERR_UNKNOWN_SEXP);
2631           goto leave;
2632         }
2633       if ((err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen)))
2634         goto leave;
2635       if (tok && toklen == 1)
2636         {
2637           const unsigned char **mpi;
2638           size_t *mpi_len;
2639
2640           switch (*tok)
2641             {
2642             case 'n': mpi = &rsa_n; mpi_len = &rsa_n_len; break;
2643             case 'e': mpi = &rsa_e; mpi_len = &rsa_e_len; break;
2644             case 'p': mpi = &rsa_p; mpi_len = &rsa_p_len; break;
2645             case 'q': mpi = &rsa_q; mpi_len = &rsa_q_len;break;
2646             default: mpi = NULL;  mpi_len = NULL; break;
2647             }
2648           if (mpi && *mpi)
2649             {
2650               err = gpg_error (GPG_ERR_DUP_VALUE);
2651               goto leave;
2652             }
2653           if ((err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen)))
2654             goto leave;
2655           if (tok && mpi)
2656             {
2657               /* Strip off leading zero bytes and save. */
2658               for (;toklen && !*tok; toklen--, tok++)
2659                 ;
2660               *mpi = tok;
2661               *mpi_len = toklen;
2662             }
2663         }
2664       /* Skip until end of list. */
2665       last_depth2 = depth;
2666       while (!(err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen))
2667              && depth && depth >= last_depth2)
2668         ;
2669       if (err)
2670         goto leave;
2671     }
2672   /* Parse other attributes. */
2673   last_depth1 = depth;
2674   while (!(err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen))
2675          && depth && depth >= last_depth1)
2676     {
2677       if (tok)
2678         {
2679           err = gpg_error (GPG_ERR_UNKNOWN_SEXP);
2680           goto leave;
2681         }
2682       if ((err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen)))
2683         goto leave;
2684       if (tok && toklen == 10 && !memcmp ("created-at", tok, toklen))
2685         {
2686           if ((err = parse_sexp (&buf,&buflen,&depth,&tok,&toklen)))
2687             goto leave;
2688           if (tok)
2689             {
2690               for (created_at=0; toklen && *tok && *tok >= '0' && *tok <= '9';
2691                    tok++, toklen--)
2692                 created_at = created_at*10 + (*tok - '0');
2693             }
2694         }
2695       /* Skip until end of list. */
2696       last_depth2 = depth;
2697       while (!(err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen))
2698              && depth && depth >= last_depth2)
2699         ;
2700       if (err)
2701         goto leave;
2702     }
2703
2704
2705   /* Check that we have all parameters and that they match the card
2706      description. */
2707   if (!created_at)
2708     {
2709       log_error (_("creation timestamp missing\n"));
2710       err = gpg_error (GPG_ERR_INV_VALUE);
2711       goto leave;
2712     }
2713
2714   maxbits = app->app_local->keyattr[keyno].n_bits;
2715   nbits = rsa_n? count_bits (rsa_n, rsa_n_len) : 0;
2716   if (opt.verbose)
2717     log_info ("RSA modulus size is %u bits (%u bytes)\n",
2718               nbits, (unsigned int)rsa_n_len);
2719   if (nbits && nbits != maxbits
2720       && app->app_local->extcap.algo_attr_change)
2721     {
2722       /* Try to switch the key to a new length.  */
2723       err = change_keyattr (app, keyno, nbits, pincb, pincb_arg);
2724       if (!err)
2725         maxbits = app->app_local->keyattr[keyno].n_bits;
2726     }
2727   if (nbits != maxbits)
2728     {
2729       log_error (_("RSA modulus missing or not of size %d bits\n"),
2730                  (int)maxbits);
2731       err = gpg_error (GPG_ERR_BAD_SECKEY);
2732       goto leave;
2733     }
2734
2735   maxbits = app->app_local->keyattr[keyno].e_bits;
2736   if (maxbits > 32 && !app->app_local->extcap.is_v2)
2737     maxbits = 32; /* Our code for v1 does only support 32 bits.  */
2738   nbits = rsa_e? count_bits (rsa_e, rsa_e_len) : 0;
2739   if (nbits < 2 || nbits > maxbits)
2740     {
2741       log_error (_("RSA public exponent missing or larger than %d bits\n"),
2742                  (int)maxbits);
2743       err = gpg_error (GPG_ERR_BAD_SECKEY);
2744       goto leave;
2745     }
2746
2747   maxbits = app->app_local->keyattr[keyno].n_bits/2;
2748   nbits = rsa_p? count_bits (rsa_p, rsa_p_len) : 0;
2749   if (nbits != maxbits)
2750     {
2751       log_error (_("RSA prime %s missing or not of size %d bits\n"),
2752                  "P", (int)maxbits);
2753       err = gpg_error (GPG_ERR_BAD_SECKEY);
2754       goto leave;
2755     }
2756   nbits = rsa_q? count_bits (rsa_q, rsa_q_len) : 0;
2757   if (nbits != maxbits)
2758     {
2759       log_error (_("RSA prime %s missing or not of size %d bits\n"),
2760                  "Q", (int)maxbits);
2761       err = gpg_error (GPG_ERR_BAD_SECKEY);
2762       goto leave;
2763     }
2764
2765   /* We need to remove the cached public key.  */
2766   xfree (app->app_local->pk[keyno].key);
2767   app->app_local->pk[keyno].key = NULL;
2768   app->app_local->pk[keyno].keylen = 0;
2769   app->app_local->pk[keyno].read_done = 0;
2770
2771
2772   if (app->app_local->extcap.is_v2)
2773     {
2774       /* Build the private key template as described in section 4.3.3.7 of
2775          the OpenPGP card specs version 2.0.  */
2776       int exmode;
2777
2778       err = build_privkey_template (app, keyno,
2779                                     rsa_n, rsa_n_len,
2780                                     rsa_e, rsa_e_len,
2781                                     rsa_p, rsa_p_len,
2782                                     rsa_q, rsa_q_len,
2783                                     &template, &template_len);
2784       if (err)
2785         goto leave;
2786
2787       /* Prepare for storing the key.  */
2788       err = verify_chv3 (app, pincb, pincb_arg);
2789       if (err)
2790         goto leave;
2791
2792       /* Store the key. */
2793       if (app->app_local->cardcap.ext_lc_le && template_len > 254)
2794         exmode = 1;    /* Use extended length w/o a limit.  */
2795       else if (app->app_local->cardcap.cmd_chaining && template_len > 254)
2796         exmode = -254;
2797       else
2798         exmode = 0;
2799       err = iso7816_put_data_odd (app->slot, exmode, 0x3fff,
2800                                   template, template_len);
2801     }
2802   else
2803     {
2804       /* Build the private key template as described in section 4.3.3.6 of
2805          the OpenPGP card specs version 1.1:
2806          0xC0   <length> public exponent
2807          0xC1   <length> prime p
2808          0xC2   <length> prime q
2809       */
2810       assert (rsa_e_len <= 4);
2811       template_len = (1 + 1 + 4
2812                       + 1 + 1 + rsa_p_len
2813                       + 1 + 1 + rsa_q_len);
2814       template = tp = xtrymalloc_secure (template_len);
2815       if (!template)
2816         {
2817           err = gpg_error_from_syserror ();
2818           goto leave;
2819         }
2820       *tp++ = 0xC0;
2821       *tp++ = 4;
2822       memcpy (tp, rsa_e, rsa_e_len);
2823       if (rsa_e_len < 4)
2824         {
2825           /* Right justify E. */
2826           memmove (tp+4-rsa_e_len, tp, rsa_e_len);
2827           memset (tp, 0, 4-rsa_e_len);
2828         }
2829       tp += 4;
2830
2831       *tp++ = 0xC1;
2832       *tp++ = rsa_p_len;
2833       memcpy (tp, rsa_p, rsa_p_len);
2834       tp += rsa_p_len;
2835
2836       *tp++ = 0xC2;
2837       *tp++ = rsa_q_len;
2838       memcpy (tp, rsa_q, rsa_q_len);
2839       tp += rsa_q_len;
2840
2841       assert (tp - template == template_len);
2842
2843       /* Prepare for storing the key.  */
2844       err = verify_chv3 (app, pincb, pincb_arg);
2845       if (err)
2846         goto leave;
2847
2848       /* Store the key. */
2849       err = iso7816_put_data (app->slot, 0,
2850                               (app->card_version > 0x0007? 0xE0:0xE9)+keyno,
2851                               template, template_len);
2852     }
2853   if (err)
2854     {
2855       log_error (_("failed to store the key: %s\n"), gpg_strerror (err));
2856       goto leave;
2857     }
2858
2859   err = store_fpr (app, keyno, created_at,
2860                   rsa_n, rsa_n_len, rsa_e, rsa_e_len,
2861                   fprbuf, app->card_version);
2862   if (err)
2863     goto leave;
2864
2865
2866  leave:
2867   xfree (template);
2868   return err;
2869 }
2870
2871
2872 /* Handle the GENKEY command. */
2873 static gpg_error_t
2874 do_genkey (app_t app, ctrl_t ctrl,  const char *keynostr, unsigned int flags,
2875            time_t createtime,
2876            gpg_error_t (*pincb)(void*, const char *, char **),
2877            void *pincb_arg)
2878 {
2879   int rc;
2880   char numbuf[30];
2881   unsigned char fprbuf[20];
2882   const unsigned char *keydata, *m, *e;
2883   unsigned char *buffer = NULL;
2884   size_t buflen, keydatalen, mlen, elen;
2885   time_t created_at;
2886   int keyno = atoi (keynostr);
2887   int force = (flags & 1);
2888   time_t start_at;
2889   int exmode;
2890   int le_value;
2891   unsigned int keybits;
2892
2893   if (keyno < 1 || keyno > 3)
2894     return gpg_error (GPG_ERR_INV_ID);
2895   keyno--;
2896
2897   /* We flush the cache to increase the traffic before a key
2898      generation.  This _might_ help a card to gather more entropy. */
2899   flush_cache (app);
2900
2901   /* Obviously we need to remove the cached public key.  */
2902   xfree (app->app_local->pk[keyno].key);
2903   app->app_local->pk[keyno].key = NULL;
2904   app->app_local->pk[keyno].keylen = 0;
2905   app->app_local->pk[keyno].read_done = 0;
2906
2907   /* Check whether a key already exists.  */
2908   rc = does_key_exist (app, keyno, 1, force);
2909   if (rc)
2910     return rc;
2911
2912   /* Because we send the key parameter back via status lines we need
2913      to put a limit on the max. allowed keysize.  2048 bit will
2914      already lead to a 527 byte long status line and thus a 4096 bit
2915      key would exceed the Assuan line length limit.  */
2916   keybits = app->app_local->keyattr[keyno].n_bits;
2917   if (keybits > 4096)
2918     return gpg_error (GPG_ERR_TOO_LARGE);
2919
2920   /* Prepare for key generation by verifying the Admin PIN.  */
2921   rc = verify_chv3 (app, pincb, pincb_arg);
2922   if (rc)
2923     goto leave;
2924
2925   /* Test whether we will need extended length mode.  (1900 is an
2926      arbitrary length which for sure fits into a short apdu.)  */
2927   if (app->app_local->cardcap.ext_lc_le && keybits > 1900)
2928     {
2929       exmode = 1;    /* Use extended length w/o a limit.  */
2930       le_value = app->app_local->extcap.max_rsp_data;
2931       /* No need to check le_value because it comes from a 16 bit
2932          value and thus can't create an overflow on a 32 bit
2933          system.  */
2934     }
2935   else
2936     {
2937       exmode = 0;
2938       le_value = 256; /* Use legacy value. */
2939     }
2940
2941   log_info (_("please wait while key is being generated ...\n"));
2942   start_at = time (NULL);
2943   rc = iso7816_generate_keypair
2944 /* # warning key generation temporary replaced by reading an existing key. */
2945 /*   rc = iso7816_read_public_key */
2946     (app->slot, exmode,
2947      (const unsigned char*)(keyno == 0? "\xB6" :
2948                             keyno == 1? "\xB8" : "\xA4"), 2,
2949      le_value,
2950      &buffer, &buflen);
2951   if (rc)
2952     {
2953       rc = gpg_error (GPG_ERR_CARD);
2954       log_error (_("generating key failed\n"));
2955       goto leave;
2956     }
2957   log_info (_("key generation completed (%d seconds)\n"),
2958             (int)(time (NULL) - start_at));
2959
2960   keydata = find_tlv (buffer, buflen, 0x7F49, &keydatalen);
2961   if (!keydata)
2962     {
2963       rc = gpg_error (GPG_ERR_CARD);
2964       log_error (_("response does not contain the public key data\n"));
2965       goto leave;
2966     }
2967
2968   m = find_tlv (keydata, keydatalen, 0x0081, &mlen);
2969   if (!m)
2970     {
2971       rc = gpg_error (GPG_ERR_CARD);
2972       log_error (_("response does not contain the RSA modulus\n"));
2973       goto leave;
2974     }
2975   /* log_printhex ("RSA n:", m, mlen); */
2976   send_key_data (ctrl, "n", m, mlen);
2977
2978   e = find_tlv (keydata, keydatalen, 0x0082, &elen);
2979   if (!e)
2980     {
2981       rc = gpg_error (GPG_ERR_CARD);
2982       log_error (_("response does not contain the RSA public exponent\n"));
2983       goto leave;
2984     }
2985   /* log_printhex ("RSA e:", e, elen); */
2986   send_key_data (ctrl, "e", e, elen);
2987
2988   created_at = createtime? createtime : gnupg_get_time ();
2989   sprintf (numbuf, "%lu", (unsigned long)created_at);
2990   send_status_info (ctrl, "KEY-CREATED-AT",
2991                     numbuf, (size_t)strlen(numbuf), NULL, 0);
2992
2993   rc = store_fpr (app, keyno, (u32)created_at,
2994                   m, mlen, e, elen, fprbuf, app->card_version);
2995   if (rc)
2996     goto leave;
2997   send_fpr_if_not_null (ctrl, "KEY-FPR", -1, fprbuf);
2998
2999
3000  leave:
3001   xfree (buffer);
3002   return rc;
3003 }
3004
3005
3006 static unsigned long
3007 convert_sig_counter_value (const unsigned char *value, size_t valuelen)
3008 {
3009   unsigned long ul;
3010
3011   if (valuelen == 3 )
3012     ul = (value[0] << 16) | (value[1] << 8) | value[2];
3013   else
3014     {
3015       log_error (_("invalid structure of OpenPGP card (DO 0x93)\n"));
3016       ul = 0;
3017     }
3018   return ul;
3019 }
3020
3021 static unsigned long
3022 get_sig_counter (app_t app)
3023 {
3024   void *relptr;
3025   unsigned char *value;
3026   size_t valuelen;
3027   unsigned long ul;
3028
3029   relptr = get_one_do (app, 0x0093, &value, &valuelen, NULL);
3030   if (!relptr)
3031     return 0;
3032   ul = convert_sig_counter_value (value, valuelen);
3033   xfree (relptr);
3034   return ul;
3035 }
3036
3037 static gpg_error_t
3038 compare_fingerprint (app_t app, int keyno, unsigned char *sha1fpr)
3039 {
3040   const unsigned char *fpr;
3041   unsigned char *buffer;
3042   size_t buflen, n;
3043   int rc, i;
3044
3045   assert (keyno >= 1 && keyno <= 3);
3046
3047   rc = get_cached_data (app, 0x006E, &buffer, &buflen, 0, 0);
3048   if (rc)
3049     {
3050       log_error (_("error reading application data\n"));
3051       return gpg_error (GPG_ERR_GENERAL);
3052     }
3053   fpr = find_tlv (buffer, buflen, 0x00C5, &n);
3054   if (!fpr || n != 60)
3055     {
3056       xfree (buffer);
3057       log_error (_("error reading fingerprint DO\n"));
3058       return gpg_error (GPG_ERR_GENERAL);
3059     }
3060   fpr += (keyno-1)*20;
3061   for (i=0; i < 20; i++)
3062     if (sha1fpr[i] != fpr[i])
3063       {
3064         xfree (buffer);
3065         log_info (_("fingerprint on card does not match requested one\n"));
3066         return gpg_error (GPG_ERR_WRONG_SECKEY);
3067       }
3068   xfree (buffer);
3069   return 0;
3070 }
3071
3072
3073 /* If a fingerprint has been specified check it against the one on the
3074    card.  This allows for a meaningful error message in case the key
3075    on the card has been replaced but the shadow information known to
3076    gpg has not been updated.  If there is no fingerprint we assume
3077    that this is okay. */
3078 static gpg_error_t
3079 check_against_given_fingerprint (app_t app, const char *fpr, int keyno)
3080 {
3081   unsigned char tmp[20];
3082   const char *s;
3083   int n;
3084
3085   for (s=fpr, n=0; hexdigitp (s); s++, n++)
3086     ;
3087   if (n != 40)
3088     return gpg_error (GPG_ERR_INV_ID);
3089   else if (!*s)
3090     ; /* okay */
3091   else
3092     return gpg_error (GPG_ERR_INV_ID);
3093
3094   for (s=fpr, n=0; n < 20; s += 2, n++)
3095         tmp[n] = xtoi_2 (s);
3096   return compare_fingerprint (app, keyno, tmp);
3097 }
3098
3099
3100
3101 /* Compute a digital signature on INDATA which is expected to be the
3102    raw message digest. For this application the KEYIDSTR consists of
3103    the serialnumber and the fingerprint delimited by a slash.
3104
3105    Note that this function may return the error code
3106    GPG_ERR_WRONG_CARD to indicate that the card currently present does
3107    not match the one required for the requested action (e.g. the
3108    serial number does not match).
3109
3110    As a special feature a KEYIDSTR of "OPENPGP.3" redirects the
3111    operation to the auth command.
3112 */
3113 static gpg_error_t
3114 do_sign (app_t app, const char *keyidstr, int hashalgo,
3115          gpg_error_t (*pincb)(void*, const char *, char **),
3116          void *pincb_arg,
3117          const void *indata, size_t indatalen,
3118          unsigned char **outdata, size_t *outdatalen )
3119 {
3120   static unsigned char rmd160_prefix[15] = /* Object ID is 1.3.36.3.2.1 */
3121     { 0x30, 0x21, 0x30, 0x09, 0x06, 0x05, 0x2b, 0x24, 0x03,
3122       0x02, 0x01, 0x05, 0x00, 0x04, 0x14  };
3123   static unsigned char sha1_prefix[15] =   /* (1.3.14.3.2.26) */
3124     { 0x30, 0x21, 0x30, 0x09, 0x06, 0x05, 0x2b, 0x0e, 0x03,
3125       0x02, 0x1a, 0x05, 0x00, 0x04, 0x14  };
3126   static unsigned char sha224_prefix[19] = /* (2.16.840.1.101.3.4.2.4) */
3127     { 0x30, 0x2D, 0x30, 0x0d, 0x06, 0x09, 0x60, 0x86, 0x48,
3128       0x01, 0x65, 0x03, 0x04, 0x02, 0x04, 0x05, 0x00, 0x04,
3129       0x1C  };
3130   static unsigned char sha256_prefix[19] = /* (2.16.840.1.101.3.4.2.1) */
3131     { 0x30, 0x31, 0x30, 0x0d, 0x06, 0x09, 0x60, 0x86,
3132       0x48, 0x01, 0x65, 0x03, 0x04, 0x02, 0x01, 0x05,
3133       0x00, 0x04, 0x20  };
3134   static unsigned char sha384_prefix[19] = /* (2.16.840.1.101.3.4.2.2) */
3135     { 0x30, 0x41, 0x30, 0x0d, 0x06, 0x09, 0x60, 0x86,
3136       0x48, 0x01, 0x65, 0x03, 0x04, 0x02, 0x02, 0x05,
3137       0x00, 0x04, 0x30  };
3138   static unsigned char sha512_prefix[19] = /* (2.16.840.1.101.3.4.2.3) */
3139     { 0x30, 0x51, 0x30, 0x0d, 0x06, 0x09, 0x60, 0x86,
3140       0x48, 0x01, 0x65, 0x03, 0x04, 0x02, 0x03, 0x05,
3141       0x00, 0x04, 0x40  };
3142   int rc;
3143   unsigned char data[19+64];
3144   size_t datalen;
3145   unsigned char tmp_sn[20]; /* Actually 16 bytes but also for the fpr. */
3146   const char *s;
3147   int n;
3148   const char *fpr = NULL;
3149   unsigned long sigcount;
3150   int use_auth = 0;
3151   int exmode, le_value;
3152
3153   if (!keyidstr || !*keyidstr)
3154     return gpg_error (GPG_ERR_INV_VALUE);
3155
3156   /* Strip off known prefixes.  */
3157 #define X(a,b,c,d) \
3158   if (hashalgo == GCRY_MD_ ## a                               \
3159       && (d)                                                  \
3160       && indatalen == sizeof b ## _prefix + (c)               \
3161       && !memcmp (indata, b ## _prefix, sizeof b ## _prefix)) \
3162     {                                                         \
3163       indata = (const char*)indata + sizeof b ## _prefix;     \
3164       indatalen -= sizeof b ## _prefix;                       \
3165     }
3166
3167   if (indatalen == 20)
3168     ;  /* Assume a plain SHA-1 or RMD160 digest has been given.  */
3169   else X(SHA1,   sha1,   20, 1)
3170   else X(RMD160, rmd160, 20, 1)
3171   else X(SHA224, sha224, 28, app->app_local->extcap.is_v2)
3172   else X(SHA256, sha256, 32, app->app_local->extcap.is_v2)
3173   else X(SHA384, sha384, 48, app->app_local->extcap.is_v2)
3174   else X(SHA512, sha512, 64, app->app_local->extcap.is_v2)
3175   else if ((indatalen == 28 || indatalen == 32
3176             || indatalen == 48 || indatalen ==64)
3177            && app->app_local->extcap.is_v2)
3178     ;  /* Assume a plain SHA-3 digest has been given.  */
3179   else
3180     {
3181       log_error (_("card does not support digest algorithm %s\n"),
3182                  gcry_md_algo_name (hashalgo));
3183       /* Or the supplied digest length does not match an algorithm.  */
3184       return gpg_error (GPG_ERR_INV_VALUE);
3185     }
3186 #undef X
3187
3188   /* Check whether an OpenPGP card of any version has been requested. */
3189   if (!strcmp (keyidstr, "OPENPGP.1"))
3190     ;
3191   else if (!strcmp (keyidstr, "OPENPGP.3"))
3192     use_auth = 1;
3193   else if (strlen (keyidstr) < 32 || strncmp (keyidstr, "D27600012401", 12))
3194     return gpg_error (GPG_ERR_INV_ID);
3195   else
3196     {
3197       for (s=keyidstr, n=0; hexdigitp (s); s++, n++)
3198         ;
3199       if (n != 32)
3200         return gpg_error (GPG_ERR_INV_ID);
3201       else if (!*s)
3202         ; /* no fingerprint given: we allow this for now. */
3203       else if (*s == '/')
3204         fpr = s + 1;
3205       else
3206         return gpg_error (GPG_ERR_INV_ID);
3207
3208       for (s=keyidstr, n=0; n < 16; s += 2, n++)
3209         tmp_sn[n] = xtoi_2 (s);
3210
3211       if (app->serialnolen != 16)
3212         return gpg_error (GPG_ERR_INV_CARD);
3213       if (memcmp (app->serialno, tmp_sn, 16))
3214         return gpg_error (GPG_ERR_WRONG_CARD);
3215     }
3216
3217   /* If a fingerprint has been specified check it against the one on
3218      the card.  This is allows for a meaningful error message in case
3219      the key on the card has been replaced but the shadow information
3220      known to gpg was not updated.  If there is no fingerprint, gpg
3221      will detect a bogus signature anyway due to the
3222      verify-after-signing feature. */
3223   rc = fpr? check_against_given_fingerprint (app, fpr, 1) : 0;
3224   if (rc)
3225     return rc;
3226
3227   /* Concatenate prefix and digest.  */
3228 #define X(a,b,d) \
3229   if (hashalgo == GCRY_MD_ ## a && (d) )                      \
3230     {                                                         \
3231       datalen = sizeof b ## _prefix + indatalen;              \
3232       assert (datalen <= sizeof data);                        \
3233       memcpy (data, b ## _prefix, sizeof b ## _prefix);       \
3234       memcpy (data + sizeof b ## _prefix, indata, indatalen); \
3235     }
3236
3237   X(SHA1,   sha1,   1)
3238   else X(RMD160, rmd160, 1)
3239   else X(SHA224, sha224, app->app_local->extcap.is_v2)
3240   else X(SHA256, sha256, app->app_local->extcap.is_v2)
3241   else X(SHA384, sha384, app->app_local->extcap.is_v2)
3242   else X(SHA512, sha512, app->app_local->extcap.is_v2)
3243   else
3244     return gpg_error (GPG_ERR_UNSUPPORTED_ALGORITHM);
3245 #undef X
3246
3247   /* Redirect to the AUTH command if asked to. */
3248   if (use_auth)
3249     {
3250       return do_auth (app, "OPENPGP.3", pincb, pincb_arg,
3251                       data, datalen,
3252                       outdata, outdatalen);
3253     }
3254
3255   /* Show the number of signature done using this key.  */
3256   sigcount = get_sig_counter (app);
3257   log_info (_("signatures created so far: %lu\n"), sigcount);
3258
3259   /* Check CHV if needed.  */
3260   if (!app->did_chv1 || app->force_chv1 )
3261     {
3262       char *pinvalue;
3263
3264       rc = verify_a_chv (app, pincb, pincb_arg, 1, sigcount, &pinvalue);
3265       if (rc)
3266         return rc;
3267
3268       app->did_chv1 = 1;
3269
3270       /* For cards with versions < 2 we want to keep CHV1 and CHV2 in
3271          sync, thus we verify CHV2 here using the given PIN.  Cards
3272          with version2 to not have the need for a separate CHV2 and
3273          internally use just one.  Obviously we can't do that if the
3274          keypad has been used. */
3275       if (!app->did_chv2 && pinvalue && !app->app_local->extcap.is_v2)
3276         {
3277           rc = iso7816_verify (app->slot, 0x82, pinvalue, strlen (pinvalue));
3278           if (gpg_err_code (rc) == GPG_ERR_BAD_PIN)
3279             rc = gpg_error (GPG_ERR_PIN_NOT_SYNCED);
3280           if (rc)
3281             {
3282               log_error (_("verify CHV%d failed: %s\n"), 2, gpg_strerror (rc));
3283               xfree (pinvalue);
3284               flush_cache_after_error (app);
3285               return rc;
3286             }
3287           app->did_chv2 = 1;
3288         }
3289       xfree (pinvalue);
3290     }
3291
3292
3293   if (app->app_local->cardcap.ext_lc_le)
3294     {
3295       exmode = 1;    /* Use extended length.  */
3296       le_value = app->app_local->extcap.max_rsp_data;
3297     }
3298   else
3299     {
3300       exmode = 0;
3301       le_value = 0;
3302     }
3303   rc = iso7816_compute_ds (app->slot, exmode, data, datalen, le_value,
3304                            outdata, outdatalen);
3305   return rc;
3306 }
3307
3308 /* Compute a digital signature using the INTERNAL AUTHENTICATE command
3309    on INDATA which is expected to be the raw message digest. For this
3310    application the KEYIDSTR consists of the serialnumber and the
3311    fingerprint delimited by a slash.  Optionally the id OPENPGP.3 may
3312    be given.
3313
3314    Note that this function may return the error code
3315    GPG_ERR_WRONG_CARD to indicate that the card currently present does
3316    not match the one required for the requested action (e.g. the
3317    serial number does not match). */
3318 static gpg_error_t
3319 do_auth (app_t app, const char *keyidstr,
3320          gpg_error_t (*pincb)(void*, const char *, char **),
3321          void *pincb_arg,
3322          const void *indata, size_t indatalen,
3323          unsigned char **outdata, size_t *outdatalen )
3324 {
3325   int rc;
3326   unsigned char tmp_sn[20]; /* Actually 16 but we use it also for the fpr. */
3327   const char *s;
3328   int n;
3329   const char *fpr = NULL;
3330
3331   if (!keyidstr || !*keyidstr)
3332     return gpg_error (GPG_ERR_INV_VALUE);
3333   if (indatalen > 101) /* For a 2048 bit key. */
3334     return gpg_error (GPG_ERR_INV_VALUE);
3335
3336   /* Check whether an OpenPGP card of any version has been requested. */
3337   if (!strcmp (keyidstr, "OPENPGP.3"))
3338     ;
3339   else if (strlen (keyidstr) < 32 || strncmp (keyidstr, "D27600012401", 12))
3340     return gpg_error (GPG_ERR_INV_ID);
3341   else
3342     {
3343       for (s=keyidstr, n=0; hexdigitp (s); s++, n++)
3344         ;
3345       if (n != 32)
3346         return gpg_error (GPG_ERR_INV_ID);
3347       else if (!*s)
3348         ; /* no fingerprint given: we allow this for now. */
3349       else if (*s == '/')
3350         fpr = s + 1;
3351       else
3352         return gpg_error (GPG_ERR_INV_ID);
3353
3354       for (s=keyidstr, n=0; n < 16; s += 2, n++)
3355         tmp_sn[n] = xtoi_2 (s);
3356
3357       if (app->serialnolen != 16)
3358         return gpg_error (GPG_ERR_INV_CARD);
3359       if (memcmp (app->serialno, tmp_sn, 16))
3360         return gpg_error (GPG_ERR_WRONG_CARD);
3361     }
3362
3363   /* If a fingerprint has been specified check it against the one on
3364      the card.  This is allows for a meaningful error message in case
3365      the key on the card has been replaced but the shadow information
3366      known to gpg was not updated.  If there is no fingerprint, gpg
3367      will detect a bogus signature anyway due to the
3368      verify-after-signing feature. */
3369   rc = fpr? check_against_given_fingerprint (app, fpr, 3) : 0;
3370   if (rc)
3371     return rc;
3372
3373   rc = verify_chv2 (app, pincb, pincb_arg);
3374   if (!rc)
3375     {
3376       int exmode, le_value;
3377
3378       if (app->app_local->cardcap.ext_lc_le)
3379         {
3380           exmode = 1;    /* Use extended length.  */
3381           le_value = app->app_local->extcap.max_rsp_data;
3382         }
3383       else
3384         {
3385           exmode = 0;
3386           le_value = 0;
3387         }
3388       rc = iso7816_internal_authenticate (app->slot, exmode,
3389                                           indata, indatalen, le_value,
3390                                           outdata, outdatalen);
3391     }
3392   return rc;
3393 }
3394
3395
3396 static gpg_error_t
3397 do_decipher (app_t app, const char *keyidstr,
3398              gpg_error_t (*pincb)(void*, const char *, char **),
3399              void *pincb_arg,
3400              const void *indata, size_t indatalen,
3401              unsigned char **outdata, size_t *outdatalen )
3402 {
3403   int rc;
3404   unsigned char tmp_sn[20]; /* actually 16 but we use it also for the fpr. */
3405   const char *s;
3406   int n;
3407   const char *fpr = NULL;
3408   int exmode, le_value;
3409
3410   if (!keyidstr || !*keyidstr || !indatalen)
3411     return gpg_error (GPG_ERR_INV_VALUE);
3412
3413   /* Check whether an OpenPGP card of any version has been requested. */
3414   if (!strcmp (keyidstr, "OPENPGP.2"))
3415     ;
3416   else if (strlen (keyidstr) < 32 || strncmp (keyidstr, "D27600012401", 12))
3417     return gpg_error (GPG_ERR_INV_ID);
3418   else
3419     {
3420       for (s=keyidstr, n=0; hexdigitp (s); s++, n++)
3421         ;
3422       if (n != 32)
3423         return gpg_error (GPG_ERR_INV_ID);
3424       else if (!*s)
3425         ; /* no fingerprint given: we allow this for now. */
3426       else if (*s == '/')
3427         fpr = s + 1;
3428       else
3429         return gpg_error (GPG_ERR_INV_ID);
3430
3431       for (s=keyidstr, n=0; n < 16; s += 2, n++)
3432         tmp_sn[n] = xtoi_2 (s);
3433
3434       if (app->serialnolen != 16)
3435         return gpg_error (GPG_ERR_INV_CARD);
3436       if (memcmp (app->serialno, tmp_sn, 16))
3437         return gpg_error (GPG_ERR_WRONG_CARD);
3438     }
3439
3440   /* If a fingerprint has been specified check it against the one on
3441      the card.  This is allows for a meaningful error message in case
3442      the key on the card has been replaced but the shadow information
3443      known to gpg was not updated.  If there is no fingerprint, the
3444      decryption won't produce the right plaintext anyway. */
3445   rc = fpr? check_against_given_fingerprint (app, fpr, 2) : 0;
3446   if (rc)
3447     return rc;
3448
3449   rc = verify_chv2 (app, pincb, pincb_arg);
3450   if (!rc)
3451     {
3452       int fixuplen;
3453       unsigned char *fixbuf = NULL;
3454       int padind = 0;
3455
3456       /* We might encounter a couple of leading zeroes in the
3457          cryptogram.  Due to internal use of MPIs these leading zeroes
3458          are stripped.  However the OpenPGP card expects exactly 128
3459          bytes for the cryptogram (for a 1k key).  Thus we need to fix
3460          it up.  We do this for up to 16 leading zero bytes; a
3461          cryptogram with more than this is with a very high
3462          probability anyway broken.  If a signed conversion was used
3463          we may also encounter one leading zero followed by the correct
3464          length.  We fix that as well.  */
3465       if (indatalen >= (128-16) && indatalen < 128)      /* 1024 bit key.  */
3466         fixuplen = 128 - indatalen;
3467       else if (indatalen >= (192-16) && indatalen < 192) /* 1536 bit key.  */
3468         fixuplen = 192 - indatalen;
3469       else if (indatalen >= (256-16) && indatalen < 256) /* 2048 bit key.  */
3470         fixuplen = 256 - indatalen;
3471       else if (indatalen >= (384-16) && indatalen < 384) /* 3072 bit key.  */
3472         fixuplen = 384 - indatalen;
3473       else if (indatalen >= (512-16) && indatalen < 512) /* 4096 bit key.  */
3474         fixuplen = 512 - indatalen;
3475       else if (!*(const char *)indata && (indatalen == 129
3476                                           || indatalen == 193
3477                                           || indatalen == 257
3478                                           || indatalen == 385
3479                                           || indatalen == 513))
3480         fixuplen = -1;
3481       else
3482         fixuplen = 0;
3483
3484       if (fixuplen > 0)
3485         {
3486           /* While we have to prepend stuff anyway, we can also
3487              include the padding byte here so that iso1816_decipher
3488              does not need to do another data mangling.  */
3489           fixuplen++;
3490
3491           fixbuf = xtrymalloc (fixuplen + indatalen);
3492           if (!fixbuf)
3493             return gpg_error_from_syserror ();
3494
3495           memset (fixbuf, 0, fixuplen);
3496           memcpy (fixbuf+fixuplen, indata, indatalen);
3497           indata = fixbuf;
3498           indatalen = fixuplen + indatalen;
3499           padind = -1; /* Already padded.  */
3500         }
3501       else if (fixuplen < 0)
3502         {
3503           /* We use the extra leading zero as the padding byte.  */
3504           padind = -1;
3505         }
3506
3507       if (app->app_local->cardcap.ext_lc_le && indatalen > 254 )
3508         {
3509           exmode = 1;    /* Extended length w/o a limit.  */
3510           le_value = app->app_local->extcap.max_rsp_data;
3511         }
3512       else if (app->app_local->cardcap.cmd_chaining && indatalen > 254)
3513         {
3514           exmode = -254; /* Command chaining with max. 254 bytes.  */
3515           le_value = 0;
3516         }
3517       else
3518         exmode = le_value = 0;
3519
3520       rc = iso7816_decipher (app->slot, exmode,
3521                              indata, indatalen, le_value, padind,
3522                              outdata, outdatalen);
3523       xfree (fixbuf);
3524     }
3525
3526   return rc;
3527 }
3528
3529
3530 /* Perform a simple verify operation for CHV1 and CHV2, so that
3531    further operations won't ask for CHV2 and it is possible to do a
3532    cheap check on the PIN: If there is something wrong with the PIN
3533    entry system, only the regular CHV will get blocked and not the
3534    dangerous CHV3.  KEYIDSTR is the usual card's serial number; an
3535    optional fingerprint part will be ignored.
3536
3537    There is a special mode if the keyidstr is "<serialno>[CHV3]" with
3538    the "[CHV3]" being a literal string:  The Admin Pin is checked if
3539    and only if the retry counter is still at 3. */
3540 static gpg_error_t
3541 do_check_pin (app_t app, const char *keyidstr,
3542               gpg_error_t (*pincb)(void*, const char *, char **),
3543               void *pincb_arg)
3544 {
3545   unsigned char tmp_sn[20];
3546   const char *s;
3547   int n;
3548   int admin_pin = 0;
3549
3550   if (!keyidstr || !*keyidstr)
3551     return gpg_error (GPG_ERR_INV_VALUE);
3552
3553   /* Check whether an OpenPGP card of any version has been requested. */
3554   if (strlen (keyidstr) < 32 || strncmp (keyidstr, "D27600012401", 12))
3555     return gpg_error (GPG_ERR_INV_ID);
3556
3557   for (s=keyidstr, n=0; hexdigitp (s); s++, n++)
3558     ;
3559   if (n != 32)
3560     return gpg_error (GPG_ERR_INV_ID);
3561   else if (!*s)
3562     ; /* No fingerprint given: we allow this for now. */
3563   else if (*s == '/')
3564     ; /* We ignore a fingerprint. */
3565   else if (!strcmp (s, "[CHV3]") )
3566     admin_pin = 1;
3567   else
3568     return gpg_error (GPG_ERR_INV_ID);
3569
3570   for (s=keyidstr, n=0; n < 16; s += 2, n++)
3571     tmp_sn[n] = xtoi_2 (s);
3572
3573   if (app->serialnolen != 16)
3574     return gpg_error (GPG_ERR_INV_CARD);
3575   if (memcmp (app->serialno, tmp_sn, 16))
3576     return gpg_error (GPG_ERR_WRONG_CARD);
3577
3578   /* Yes, there is a race conditions: The user might pull the card
3579      right here and we won't notice that.  However this is not a
3580      problem and the check above is merely for a graceful failure
3581      between operations. */
3582
3583   if (admin_pin)
3584     {
3585       void *relptr;
3586       unsigned char *value;
3587       size_t valuelen;
3588       int count;
3589
3590       relptr = get_one_do (app, 0x00C4, &value, &valuelen, NULL);
3591       if (!relptr || valuelen < 7)
3592         {
3593           log_error (_("error retrieving CHV status from card\n"));
3594           xfree (relptr);
3595           return gpg_error (GPG_ERR_CARD);
3596         }
3597       count = value[6];
3598       xfree (relptr);
3599
3600       if (!count)
3601         {
3602           log_info (_("card is permanently locked!\n"));
3603           return gpg_error (GPG_ERR_BAD_PIN);
3604         }
3605       else if (value[6] < 3)
3606         {
3607           log_info (_("verification of Admin PIN is currently prohibited "
3608                       "through this command\n"));
3609           return gpg_error (GPG_ERR_GENERAL);
3610         }
3611
3612       app->did_chv3 = 0; /* Force verification.  */
3613       return verify_chv3 (app, pincb, pincb_arg);
3614     }
3615   else
3616     return verify_chv2 (app, pincb, pincb_arg);
3617 }
3618
3619
3620 /* Show information about card capabilities.  */
3621 static void
3622 show_caps (struct app_local_s *s)
3623 {
3624   log_info ("Version-2 ......: %s\n", s->extcap.is_v2? "yes":"no");
3625   log_info ("Get-Challenge ..: %s", s->extcap.get_challenge? "yes":"no");
3626   if (s->extcap.get_challenge)
3627     log_printf (" (%u bytes max)", s->extcap.max_get_challenge);
3628   log_info ("Key-Import .....: %s\n", s->extcap.key_import? "yes":"no");
3629   log_info ("Change-Force-PW1: %s\n", s->extcap.change_force_chv? "yes":"no");
3630   log_info ("Private-DOs ....: %s\n", s->extcap.private_dos? "yes":"no");
3631   log_info ("Algo-Attr-Change: %s\n", s->extcap.algo_attr_change? "yes":"no");
3632   log_info ("SM-Support .....: %s", s->extcap.sm_supported? "yes":"no");
3633   if (s->extcap.sm_supported)
3634     log_printf (" (%s)", s->extcap.sm_aes128? "AES-128":"3DES");
3635   log_info ("Max-Cert3-Len ..: %u\n", s->extcap.max_certlen_3);
3636   log_info ("Max-Cmd-Data ...: %u\n", s->extcap.max_cmd_data);
3637   log_info ("Max-Rsp-Data ...: %u\n", s->extcap.max_rsp_data);
3638   log_info ("Cmd-Chaining ...: %s\n", s->cardcap.cmd_chaining?"yes":"no");
3639   log_info ("Ext-Lc-Le ......: %s\n", s->cardcap.ext_lc_le?"yes":"no");
3640   log_info ("Status Indicator: %02X\n", s->status_indicator);
3641
3642   log_info ("GnuPG-No-Sync ..: %s\n",  s->flags.no_sync? "yes":"no");
3643   log_info ("GnuPG-Def-PW2 ..: %s\n",  s->flags.def_chv2? "yes":"no");
3644 }
3645
3646
3647 /* Parse the historical bytes in BUFFER of BUFLEN and store them in
3648    APPLOC.  */
3649 static void
3650 parse_historical (struct app_local_s *apploc,
3651                   const unsigned char * buffer, size_t buflen)
3652 {
3653   /* Example buffer: 00 31 C5 73 C0 01 80 00 90 00  */
3654   if (buflen < 4)
3655     {
3656       log_error ("warning: historical bytes are too short\n");
3657       return; /* Too short.  */
3658     }
3659   if (*buffer)
3660     {
3661       log_error ("warning: bad category indicator in historical bytes\n");
3662       return;
3663     }
3664
3665   /* Skip category indicator.  */
3666   buffer++;
3667   buflen--;
3668
3669   /* Get the status indicator.  */
3670   apploc->status_indicator = buffer[buflen-3];
3671   buflen -= 3;
3672
3673   /* Parse the compact TLV.  */
3674   while (buflen)
3675     {
3676       unsigned int tag = (*buffer & 0xf0) >> 4;
3677       unsigned int len = (*buffer & 0x0f);
3678       if (len+1 > buflen)
3679         {
3680           log_error ("warning: bad Compact-TLV in historical bytes\n");
3681           return; /* Error.  */
3682         }
3683       buffer++;
3684       buflen--;
3685       if (tag == 7 && len == 3)
3686         {
3687           /* Card capabilities.  */
3688           apploc->cardcap.cmd_chaining = !!(buffer[2] & 0x80);
3689           apploc->cardcap.ext_lc_le    = !!(buffer[2] & 0x40);
3690         }
3691       buffer += len;
3692       buflen -= len;
3693     }
3694 }
3695
3696
3697 /* Parse and optionally show the algorithm attributes for KEYNO.
3698    KEYNO must be in the range 0..2.  */
3699 static void
3700 parse_algorithm_attribute (app_t app, int keyno)
3701 {
3702   unsigned char *buffer;
3703   size_t buflen;
3704   void *relptr;
3705   const char desc[3][5] = {"sign", "encr", "auth"};
3706
3707   assert (keyno >=0 && keyno <= 2);
3708
3709   app->app_local->keyattr[keyno].n_bits = 0;
3710
3711   relptr = get_one_do (app, 0xC1+keyno, &buffer, &buflen, NULL);
3712   if (!relptr)
3713     {
3714       log_error ("error reading DO 0x%02X\n", 0xc1+keyno);
3715       return;
3716     }
3717   if (buflen < 1)
3718     {
3719       log_error ("error reading DO 0x%02X\n", 0xc1+keyno);
3720       xfree (relptr);
3721       return;
3722     }
3723
3724   if (opt.verbose)
3725     log_info ("Key-Attr-%s ..: ", desc[keyno]);
3726   if (*buffer == 1 && (buflen == 5 || buflen == 6))
3727     {
3728       app->app_local->keyattr[keyno].n_bits = (buffer[1]<<8 | buffer[2]);
3729       app->app_local->keyattr[keyno].e_bits = (buffer[3]<<8 | buffer[4]);
3730       app->app_local->keyattr[keyno].format = 0;
3731       if (buflen < 6)
3732         app->app_local->keyattr[keyno].format = RSA_STD;
3733       else
3734         app->app_local->keyattr[keyno].format = (buffer[5] == 0? RSA_STD   :
3735                                                  buffer[5] == 1? RSA_STD_N :
3736                                                  buffer[5] == 2? RSA_CRT   :
3737                                                  buffer[5] == 3? RSA_CRT_N :
3738                                                  RSA_UNKNOWN_FMT);
3739
3740       if (opt.verbose)
3741         log_printf
3742           ("RSA, n=%u, e=%u, fmt=%s\n",
3743            app->app_local->keyattr[keyno].n_bits,
3744            app->app_local->keyattr[keyno].e_bits,
3745            app->app_local->keyattr[keyno].format == RSA_STD?  "std"  :
3746            app->app_local->keyattr[keyno].format == RSA_STD_N?"std+n":
3747            app->app_local->keyattr[keyno].format == RSA_CRT?  "crt"  :
3748            app->app_local->keyattr[keyno].format == RSA_CRT_N?"crt+n":"?");
3749     }
3750   else if (opt.verbose)
3751     log_printhex ("", buffer, buflen);
3752
3753   xfree (relptr);
3754 }
3755
3756 /* Select the OpenPGP application on the card in SLOT.  This function
3757    must be used before any other OpenPGP application functions. */
3758 gpg_error_t
3759 app_select_openpgp (app_t app)
3760 {
3761   static char const aid[] = { 0xD2, 0x76, 0x00, 0x01, 0x24, 0x01 };
3762   int slot = app->slot;
3763   int rc;
3764   unsigned char *buffer;
3765   size_t buflen;
3766   void *relptr;
3767
3768   /* Note that the card can't cope with P2=0xCO, thus we need to pass a
3769      special flag value. */
3770   rc = iso7816_select_application (slot, aid, sizeof aid, 0x0001);
3771   if (!rc)
3772     {
3773       unsigned int manufacturer;
3774
3775       app->apptype = "OPENPGP";
3776
3777       app->did_chv1 = 0;
3778       app->did_chv2 = 0;
3779       app->did_chv3 = 0;
3780       app->app_local = NULL;
3781
3782       /* The OpenPGP card returns the serial number as part of the
3783          AID; because we prefer to use OpenPGP serial numbers, we
3784          replace a possibly already set one from a EF.GDO with this
3785          one.  Note, that for current OpenPGP cards, no EF.GDO exists
3786          and thus it won't matter at all. */
3787       rc = iso7816_get_data (slot, 0, 0x004F, &buffer, &buflen);
3788       if (rc)
3789         goto leave;
3790       if (opt.verbose)
3791         {
3792           log_info ("AID: ");
3793           log_printhex ("", buffer, buflen);
3794         }
3795
3796       app->card_version = buffer[6] << 8;
3797       app->card_version |= buffer[7];
3798       manufacturer = (buffer[8]<<8 | buffer[9]);
3799
3800       xfree (app->serialno);
3801       app->serialno = buffer;
3802       app->serialnolen = buflen;
3803       buffer = NULL;
3804       app->app_local = xtrycalloc (1, sizeof *app->app_local);
3805       if (!app->app_local)
3806         {
3807           rc = gpg_error (gpg_err_code_from_errno (errno));
3808           goto leave;
3809         }
3810
3811       if (app->card_version >= 0x0200)
3812         app->app_local->extcap.is_v2 = 1;
3813
3814
3815       /* Read the historical bytes.  */
3816       relptr = get_one_do (app, 0x5f52, &buffer, &buflen, NULL);
3817       if (relptr)
3818         {
3819           if (opt.verbose)
3820             {
3821               log_info ("Historical Bytes: ");
3822               log_printhex ("", buffer, buflen);
3823             }
3824           parse_historical (app->app_local, buffer, buflen);
3825           xfree (relptr);
3826         }
3827
3828       /* Read the force-chv1 flag.  */
3829       relptr = get_one_do (app, 0x00C4, &buffer, &buflen, NULL);
3830       if (!relptr)
3831         {
3832           log_error (_("can't access %s - invalid OpenPGP card?\n"),
3833                      "CHV Status Bytes");
3834           goto leave;
3835         }
3836       app->force_chv1 = (buflen && *buffer == 0);
3837       xfree (relptr);
3838
3839       /* Read the extended capabilities.  */
3840       relptr = get_one_do (app, 0x00C0, &buffer, &buflen, NULL);
3841       if (!relptr)
3842         {
3843           log_error (_("can't access %s - invalid OpenPGP card?\n"),
3844                      "Extended Capability Flags" );
3845           goto leave;
3846         }
3847       if (buflen)
3848         {
3849           app->app_local->extcap.sm_supported     = !!(*buffer & 0x80);
3850           app->app_local->extcap.get_challenge    = !!(*buffer & 0x40);
3851           app->app_local->extcap.key_import       = !!(*buffer & 0x20);
3852           app->app_local->extcap.change_force_chv = !!(*buffer & 0x10);
3853           app->app_local->extcap.private_dos      = !!(*buffer & 0x08);
3854           app->app_local->extcap.algo_attr_change = !!(*buffer & 0x04);
3855         }
3856       if (buflen >= 10)
3857         {
3858           /* Available with v2 cards.  */
3859           app->app_local->extcap.sm_aes128     = (buffer[1] == 1);
3860           app->app_local->extcap.max_get_challenge
3861                                                = (buffer[2] << 8 | buffer[3]);
3862           app->app_local->extcap.max_certlen_3 = (buffer[4] << 8 | buffer[5]);
3863           app->app_local->extcap.max_cmd_data  = (buffer[6] << 8 | buffer[7]);
3864           app->app_local->extcap.max_rsp_data  = (buffer[8] << 8 | buffer[9]);
3865         }
3866       xfree (relptr);
3867
3868       /* Some of the first cards accidently don't set the
3869          CHANGE_FORCE_CHV bit but allow it anyway. */
3870       if (app->card_version <= 0x0100 && manufacturer == 1)
3871         app->app_local->extcap.change_force_chv = 1;
3872
3873       parse_login_data (app);
3874
3875       if (opt.verbose)
3876         show_caps (app->app_local);
3877
3878       parse_algorithm_attribute (app, 0);
3879       parse_algorithm_attribute (app, 1);
3880       parse_algorithm_attribute (app, 2);
3881
3882       if (opt.verbose > 1)
3883         dump_all_do (slot);
3884
3885       app->fnc.deinit = do_deinit;
3886       app->fnc.learn_status = do_learn_status;
3887       app->fnc.readcert = do_readcert;
3888       app->fnc.readkey = do_readkey;
3889       app->fnc.getattr = do_getattr;
3890       app->fnc.setattr = do_setattr;
3891       app->fnc.writecert = do_writecert;
3892       app->fnc.writekey = do_writekey;
3893       app->fnc.genkey = do_genkey;
3894       app->fnc.sign = do_sign;
3895       app->fnc.auth = do_auth;
3896       app->fnc.decipher = do_decipher;
3897       app->fnc.change_pin = do_change_pin;
3898       app->fnc.check_pin = do_check_pin;
3899    }
3900
3901 leave:
3902   if (rc)
3903     do_deinit (app);
3904   return rc;
3905 }