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