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