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