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