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