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