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