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