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