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