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