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