d3c309eeea8a80813bce57bcd256a60368132540
[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   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.fixedlen = -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       pininfo_t pininfo;
1711       int minlen = 8;
1712       char *prompt;
1713
1714       memset (&pininfo, 0, sizeof pininfo);
1715       pininfo.fixedlen = -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   pininfo_t pininfo;
1921   int use_keypad = 0;
1922   int minlen = 6;
1923
1924   (void)ctrl;
1925   memset (&pininfo, 0, sizeof pininfo);
1926   pininfo.fixedlen = -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           /* Dismiss the prompt. */
2169           pincb (pincb_arg, NULL, NULL);
2170         }
2171       else
2172         rc = iso7816_change_reference_data (app->slot, 0x80 + chvno,
2173                                             oldpinvalue, strlen (oldpinvalue),
2174                                             pinvalue, strlen (pinvalue));
2175     }
2176
2177   if (pinvalue)
2178     {
2179       wipememory (pinvalue, strlen (pinvalue));
2180       xfree (pinvalue);
2181     }
2182   if (rc)
2183     flush_cache_after_error (app);
2184
2185  leave:
2186   if (resetcode)
2187     {
2188       wipememory (resetcode, strlen (resetcode));
2189       xfree (resetcode);
2190     }
2191   if (oldpinvalue)
2192     {
2193       wipememory (oldpinvalue, strlen (oldpinvalue));
2194       xfree (oldpinvalue);
2195     }
2196   return rc;
2197 }
2198
2199
2200 /* Check whether a key already exists.  KEYIDX is the index of the key
2201    (0..2).  If FORCE is TRUE a diagnositic will be printed but no
2202    error returned if the key already exists.  The flag GENERATING is
2203    only used to print correct messages. */
2204 static gpg_error_t
2205 does_key_exist (app_t app, int keyidx, int generating, int force)
2206 {
2207   const unsigned char *fpr;
2208   unsigned char *buffer;
2209   size_t buflen, n;
2210   int i;
2211
2212   assert (keyidx >=0 && keyidx <= 2);
2213
2214   if (iso7816_get_data (app->slot, 0, 0x006E, &buffer, &buflen))
2215     {
2216       log_error (_("error reading application data\n"));
2217       return gpg_error (GPG_ERR_GENERAL);
2218     }
2219   fpr = find_tlv (buffer, buflen, 0x00C5, &n);
2220   if (!fpr || n < 60)
2221     {
2222       log_error (_("error reading fingerprint DO\n"));
2223       xfree (buffer);
2224       return gpg_error (GPG_ERR_GENERAL);
2225     }
2226   fpr += 20*keyidx;
2227   for (i=0; i < 20 && !fpr[i]; i++)
2228     ;
2229   xfree (buffer);
2230   if (i!=20 && !force)
2231     {
2232       log_error (_("key already exists\n"));
2233       return gpg_error (GPG_ERR_EEXIST);
2234     }
2235   else if (i!=20)
2236     log_info (_("existing key will be replaced\n"));
2237   else if (generating)
2238     log_info (_("generating new key\n"));
2239   else
2240     log_info (_("writing new key\n"));
2241   return 0;
2242 }
2243
2244
2245 /* Create a TLV tag and value and store it at BUFFER.  Return the length
2246    of tag and length.  A LENGTH greater than 65535 is truncated. */
2247 static size_t
2248 add_tlv (unsigned char *buffer, unsigned int tag, size_t length)
2249 {
2250   unsigned char *p = buffer;
2251
2252   assert (tag <= 0xffff);
2253   if ( tag > 0xff )
2254     *p++ = tag >> 8;
2255   *p++ = tag;
2256   if (length < 128)
2257     *p++ = length;
2258   else if (length < 256)
2259     {
2260       *p++ = 0x81;
2261       *p++ = length;
2262     }
2263   else
2264     {
2265       if (length > 0xffff)
2266         length = 0xffff;
2267       *p++ = 0x82;
2268       *p++ = length >> 8;
2269       *p++ = length;
2270     }
2271
2272   return p - buffer;
2273 }
2274
2275
2276 /* Build the private key template as specified in the OpenPGP specs
2277    v2.0 section 4.3.3.7.  */
2278 static gpg_error_t
2279 build_privkey_template (app_t app, int keyno,
2280                         const unsigned char *rsa_n, size_t rsa_n_len,
2281                         const unsigned char *rsa_e, size_t rsa_e_len,
2282                         const unsigned char *rsa_p, size_t rsa_p_len,
2283                         const unsigned char *rsa_q, size_t rsa_q_len,
2284                         unsigned char **result, size_t *resultlen)
2285 {
2286   size_t rsa_e_reqlen;
2287   unsigned char privkey[7*(1+3)];
2288   size_t privkey_len;
2289   unsigned char exthdr[2+2+3];
2290   size_t exthdr_len;
2291   unsigned char suffix[2+3];
2292   size_t suffix_len;
2293   unsigned char *tp;
2294   size_t datalen;
2295   unsigned char *template;
2296   size_t template_size;
2297
2298   *result = NULL;
2299   *resultlen = 0;
2300
2301   switch (app->app_local->keyattr[keyno].format)
2302     {
2303     case RSA_STD:
2304     case RSA_STD_N:
2305       break;
2306     case RSA_CRT:
2307     case RSA_CRT_N:
2308       return gpg_error (GPG_ERR_NOT_SUPPORTED);
2309
2310     default:
2311       return gpg_error (GPG_ERR_INV_VALUE);
2312     }
2313
2314   /* Get the required length for E.  */
2315   rsa_e_reqlen = app->app_local->keyattr[keyno].e_bits/8;
2316   assert (rsa_e_len <= rsa_e_reqlen);
2317
2318   /* Build the 7f48 cardholder private key template.  */
2319   datalen = 0;
2320   tp = privkey;
2321
2322   tp += add_tlv (tp, 0x91, rsa_e_reqlen);
2323   datalen += rsa_e_reqlen;
2324
2325   tp += add_tlv (tp, 0x92, rsa_p_len);
2326   datalen += rsa_p_len;
2327
2328   tp += add_tlv (tp, 0x93, rsa_q_len);
2329   datalen += rsa_q_len;
2330
2331   if (app->app_local->keyattr[keyno].format == RSA_STD_N
2332       || app->app_local->keyattr[keyno].format == RSA_CRT_N)
2333     {
2334       tp += add_tlv (tp, 0x97, rsa_n_len);
2335       datalen += rsa_n_len;
2336     }
2337   privkey_len = tp - privkey;
2338
2339   /* Build the extended header list without the private key template.  */
2340   tp = exthdr;
2341   *tp++ = keyno ==0 ? 0xb6 : keyno == 1? 0xb8 : 0xa4;
2342   *tp++ = 0;
2343   tp += add_tlv (tp, 0x7f48, privkey_len);
2344   exthdr_len = tp - exthdr;
2345
2346   /* Build the 5f48 suffix of the data.  */
2347   tp = suffix;
2348   tp += add_tlv (tp, 0x5f48, datalen);
2349   suffix_len = tp - suffix;
2350
2351   /* Now concatenate everything.  */
2352   template_size = (1 + 3   /* 0x4d and len. */
2353                    + exthdr_len
2354                    + privkey_len
2355                    + suffix_len
2356                    + datalen);
2357   tp = template = xtrymalloc_secure (template_size);
2358   if (!template)
2359     return gpg_error_from_syserror ();
2360
2361   tp += add_tlv (tp, 0x4d, exthdr_len + privkey_len + suffix_len + datalen);
2362   memcpy (tp, exthdr, exthdr_len);
2363   tp += exthdr_len;
2364   memcpy (tp, privkey, privkey_len);
2365   tp += privkey_len;
2366   memcpy (tp, suffix, suffix_len);
2367   tp += suffix_len;
2368
2369   memcpy (tp, rsa_e, rsa_e_len);
2370   if (rsa_e_len < rsa_e_reqlen)
2371     {
2372       /* Right justify E. */
2373       memmove (tp + rsa_e_reqlen - rsa_e_len, tp, rsa_e_len);
2374       memset (tp, 0, rsa_e_reqlen - rsa_e_len);
2375     }
2376   tp += rsa_e_reqlen;
2377
2378   memcpy (tp, rsa_p, rsa_p_len);
2379   tp += rsa_p_len;
2380
2381   memcpy (tp, rsa_q, rsa_q_len);
2382   tp += rsa_q_len;
2383
2384   if (app->app_local->keyattr[keyno].format == RSA_STD_N
2385       || app->app_local->keyattr[keyno].format == RSA_CRT_N)
2386     {
2387       memcpy (tp, rsa_n, rsa_n_len);
2388       tp += rsa_n_len;
2389     }
2390
2391   /* Sanity check.  We don't know the exact length because we
2392      allocated 3 bytes for the first length header.  */
2393   assert (tp - template <= template_size);
2394
2395   *result = template;
2396   *resultlen = tp - template;
2397   return 0;
2398 }
2399
2400
2401 /* Helper for do_writekley to change the size of a key.  Not ethat
2402    this deletes the entire key without asking.  */
2403 static gpg_error_t
2404 change_keyattr (app_t app, int keyno, unsigned int nbits,
2405                 gpg_error_t (*pincb)(void*, const char *, char **),
2406                 void *pincb_arg)
2407 {
2408   gpg_error_t err;
2409   unsigned char *buffer;
2410   size_t buflen;
2411   void *relptr;
2412
2413   assert (keyno >=0 && keyno <= 2);
2414
2415   if (nbits > 4096)
2416     return gpg_error (GPG_ERR_TOO_LARGE);
2417
2418   /* Read the current attributes into a buffer.  */
2419   relptr = get_one_do (app, 0xC1+keyno, &buffer, &buflen, NULL);
2420   if (!relptr)
2421     return gpg_error (GPG_ERR_CARD);
2422   if (buflen < 6 || buffer[0] != 1)
2423     {
2424       /* Attriutes too short or not an RSA key.  */
2425       xfree (relptr);
2426       return gpg_error (GPG_ERR_CARD);
2427     }
2428
2429   /* We only change n_bits and don't touch anything else.  Before we
2430      do so, we round up NBITS to a sensible way in the same way as
2431      gpg's key generation does it.  This may help to sort out problems
2432      with a few bits too short keys.  */
2433   nbits = ((nbits + 31) / 32) * 32;
2434   buffer[1] = (nbits >> 8);
2435   buffer[2] = nbits;
2436
2437   /* Prepare for storing the key.  */
2438   err = verify_chv3 (app, pincb, pincb_arg);
2439   if (err)
2440     {
2441       xfree (relptr);
2442       return err;
2443     }
2444
2445   /* Change the attribute.  */
2446   err = iso7816_put_data (app->slot, 0, 0xC1+keyno, buffer, buflen);
2447   xfree (relptr);
2448   if (err)
2449     log_error ("error changing size of key %d to %u bits\n", keyno+1, nbits);
2450   else
2451     log_info ("size of key %d changed to %u bits\n", keyno+1, nbits);
2452   flush_cache (app);
2453   parse_algorithm_attribute (app, keyno);
2454   app->did_chv1 = 0;
2455   app->did_chv2 = 0;
2456   app->did_chv3 = 0;
2457   return err;
2458 }
2459
2460
2461 /* Helper to process an setattr command for name KEY-ATTR.  It expects
2462    a string "--force <keyno> <algo> <nbits>" in (VALUE,VALUELEN).  */
2463 static gpg_error_t
2464 change_keyattr_from_string (app_t app,
2465                             gpg_error_t (*pincb)(void*, const char *, char **),
2466                             void *pincb_arg,
2467                             const void *value, size_t valuelen)
2468 {
2469   gpg_error_t err;
2470   char *string;
2471   int keyno, algo;
2472   unsigned int nbits;
2473
2474   /* VALUE is expected to be a string but not guaranteed to be
2475      terminated.  Thus copy it to an allocated buffer first. */
2476   string = xtrymalloc (valuelen+1);
2477   if (!string)
2478     return gpg_error_from_syserror ();
2479   memcpy (string, value, valuelen);
2480   string[valuelen] = 0;
2481
2482   /* Because this function deletes the key we require the string
2483      "--force" in the data to make clear that something serious might
2484      happen.  */
2485   if (sscanf (string, " --force %d %d %u", &keyno, &algo, &nbits) != 3)
2486     err = gpg_error (GPG_ERR_INV_DATA);
2487   else if (keyno < 1 || keyno > 3)
2488     err = gpg_error (GPG_ERR_INV_ID);
2489   else if (algo != 1)
2490     err = gpg_error (GPG_ERR_PUBKEY_ALGO); /* Not RSA.  */
2491   else if (nbits < 1024)
2492     err = gpg_error (GPG_ERR_TOO_SHORT);
2493   else
2494     err = change_keyattr (app, keyno-1, nbits, pincb, pincb_arg);
2495
2496   xfree (string);
2497   return err;
2498 }
2499
2500
2501 /* Handle the WRITEKEY command for OpenPGP.  This function expects a
2502    canonical encoded S-expression with the secret key in KEYDATA and
2503    its length (for assertions) in KEYDATALEN.  KEYID needs to be the
2504    usual keyid which for OpenPGP is the string "OPENPGP.n" with
2505    n=1,2,3.  Bit 0 of FLAGS indicates whether an existing key shall
2506    get overwritten.  PINCB and PINCB_ARG are the usual arguments for
2507    the pinentry callback.  */
2508 static gpg_error_t
2509 do_writekey (app_t app, ctrl_t ctrl,
2510              const char *keyid, unsigned int flags,
2511              gpg_error_t (*pincb)(void*, const char *, char **),
2512              void *pincb_arg,
2513              const unsigned char *keydata, size_t keydatalen)
2514 {
2515   gpg_error_t err;
2516   int force = (flags & 1);
2517   int keyno;
2518   const unsigned char *buf, *tok;
2519   size_t buflen, toklen;
2520   int depth, last_depth1, last_depth2;
2521   const unsigned char *rsa_n = NULL;
2522   const unsigned char *rsa_e = NULL;
2523   const unsigned char *rsa_p = NULL;
2524   const unsigned char *rsa_q = NULL;
2525   size_t rsa_n_len, rsa_e_len, rsa_p_len, rsa_q_len;
2526   unsigned int nbits;
2527   unsigned int maxbits;
2528   unsigned char *template = NULL;
2529   unsigned char *tp;
2530   size_t template_len;
2531   unsigned char fprbuf[20];
2532   u32 created_at = 0;
2533
2534   (void)ctrl;
2535
2536   if (!strcmp (keyid, "OPENPGP.1"))
2537     keyno = 0;
2538   else if (!strcmp (keyid, "OPENPGP.2"))
2539     keyno = 1;
2540   else if (!strcmp (keyid, "OPENPGP.3"))
2541     keyno = 2;
2542   else
2543     return gpg_error (GPG_ERR_INV_ID);
2544
2545   err = does_key_exist (app, keyno, 0, force);
2546   if (err)
2547     return err;
2548
2549
2550   /*
2551      Parse the S-expression
2552    */
2553   buf = keydata;
2554   buflen = keydatalen;
2555   depth = 0;
2556   if ((err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen)))
2557     goto leave;
2558   if ((err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen)))
2559     goto leave;
2560   if (!tok || toklen != 11 || memcmp ("private-key", tok, toklen))
2561     {
2562       if (!tok)
2563         ;
2564       else if (toklen == 21 && !memcmp ("protected-private-key", tok, toklen))
2565         log_info ("protected-private-key passed to writekey\n");
2566       else if (toklen == 20 && !memcmp ("shadowed-private-key", tok, toklen))
2567         log_info ("shadowed-private-key passed to writekey\n");
2568       err = gpg_error (GPG_ERR_BAD_SECKEY);
2569       goto leave;
2570     }
2571   if ((err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen)))
2572     goto leave;
2573   if ((err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen)))
2574     goto leave;
2575   if (!tok || toklen != 3 || memcmp ("rsa", tok, toklen))
2576     {
2577       err = gpg_error (GPG_ERR_WRONG_PUBKEY_ALGO);
2578       goto leave;
2579     }
2580   last_depth1 = depth;
2581   while (!(err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen))
2582          && depth && depth >= last_depth1)
2583     {
2584       if (tok)
2585         {
2586           err = gpg_error (GPG_ERR_UNKNOWN_SEXP);
2587           goto leave;
2588         }
2589       if ((err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen)))
2590         goto leave;
2591       if (tok && toklen == 1)
2592         {
2593           const unsigned char **mpi;
2594           size_t *mpi_len;
2595
2596           switch (*tok)
2597             {
2598             case 'n': mpi = &rsa_n; mpi_len = &rsa_n_len; break;
2599             case 'e': mpi = &rsa_e; mpi_len = &rsa_e_len; break;
2600             case 'p': mpi = &rsa_p; mpi_len = &rsa_p_len; break;
2601             case 'q': mpi = &rsa_q; mpi_len = &rsa_q_len;break;
2602             default: mpi = NULL;  mpi_len = NULL; break;
2603             }
2604           if (mpi && *mpi)
2605             {
2606               err = gpg_error (GPG_ERR_DUP_VALUE);
2607               goto leave;
2608             }
2609           if ((err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen)))
2610             goto leave;
2611           if (tok && mpi)
2612             {
2613               /* Strip off leading zero bytes and save. */
2614               for (;toklen && !*tok; toklen--, tok++)
2615                 ;
2616               *mpi = tok;
2617               *mpi_len = toklen;
2618             }
2619         }
2620       /* Skip until end of list. */
2621       last_depth2 = depth;
2622       while (!(err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen))
2623              && depth && depth >= last_depth2)
2624         ;
2625       if (err)
2626         goto leave;
2627     }
2628   /* Parse other attributes. */
2629   last_depth1 = depth;
2630   while (!(err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen))
2631          && depth && depth >= last_depth1)
2632     {
2633       if (tok)
2634         {
2635           err = gpg_error (GPG_ERR_UNKNOWN_SEXP);
2636           goto leave;
2637         }
2638       if ((err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen)))
2639         goto leave;
2640       if (tok && toklen == 10 && !memcmp ("created-at", tok, toklen))
2641         {
2642           if ((err = parse_sexp (&buf,&buflen,&depth,&tok,&toklen)))
2643             goto leave;
2644           if (tok)
2645             {
2646               for (created_at=0; toklen && *tok && *tok >= '0' && *tok <= '9';
2647                    tok++, toklen--)
2648                 created_at = created_at*10 + (*tok - '0');
2649             }
2650         }
2651       /* Skip until end of list. */
2652       last_depth2 = depth;
2653       while (!(err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen))
2654              && depth && depth >= last_depth2)
2655         ;
2656       if (err)
2657         goto leave;
2658     }
2659
2660
2661   /* Check that we have all parameters and that they match the card
2662      description. */
2663   if (!created_at)
2664     {
2665       log_error (_("creation timestamp missing\n"));
2666       err = gpg_error (GPG_ERR_INV_VALUE);
2667       goto leave;
2668     }
2669
2670   maxbits = app->app_local->keyattr[keyno].n_bits;
2671   nbits = rsa_n? count_bits (rsa_n, rsa_n_len) : 0;
2672   if (opt.verbose)
2673     log_info ("RSA modulus size is %u bits (%u bytes)\n",
2674               nbits, (unsigned int)rsa_n_len);
2675   if (nbits && nbits != maxbits
2676       && app->app_local->extcap.algo_attr_change)
2677     {
2678       /* Try to switch the key to a new length.  */
2679       err = change_keyattr (app, keyno, nbits, pincb, pincb_arg);
2680       if (!err)
2681         maxbits = app->app_local->keyattr[keyno].n_bits;
2682     }
2683   if (nbits != maxbits)
2684     {
2685       log_error (_("RSA modulus missing or not of size %d bits\n"),
2686                  (int)maxbits);
2687       err = gpg_error (GPG_ERR_BAD_SECKEY);
2688       goto leave;
2689     }
2690
2691   maxbits = app->app_local->keyattr[keyno].e_bits;
2692   if (maxbits > 32 && !app->app_local->extcap.is_v2)
2693     maxbits = 32; /* Our code for v1 does only support 32 bits.  */
2694   nbits = rsa_e? count_bits (rsa_e, rsa_e_len) : 0;
2695   if (nbits < 2 || nbits > maxbits)
2696     {
2697       log_error (_("RSA public exponent missing or larger than %d bits\n"),
2698                  (int)maxbits);
2699       err = gpg_error (GPG_ERR_BAD_SECKEY);
2700       goto leave;
2701     }
2702
2703   maxbits = app->app_local->keyattr[keyno].n_bits/2;
2704   nbits = rsa_p? count_bits (rsa_p, rsa_p_len) : 0;
2705   if (nbits != maxbits)
2706     {
2707       log_error (_("RSA prime %s missing or not of size %d bits\n"),
2708                  "P", (int)maxbits);
2709       err = gpg_error (GPG_ERR_BAD_SECKEY);
2710       goto leave;
2711     }
2712   nbits = rsa_q? count_bits (rsa_q, rsa_q_len) : 0;
2713   if (nbits != maxbits)
2714     {
2715       log_error (_("RSA prime %s missing or not of size %d bits\n"),
2716                  "Q", (int)maxbits);
2717       err = gpg_error (GPG_ERR_BAD_SECKEY);
2718       goto leave;
2719     }
2720
2721   /* We need to remove the cached public key.  */
2722   xfree (app->app_local->pk[keyno].key);
2723   app->app_local->pk[keyno].key = NULL;
2724   app->app_local->pk[keyno].keylen = 0;
2725   app->app_local->pk[keyno].read_done = 0;
2726
2727
2728   if (app->app_local->extcap.is_v2)
2729     {
2730       /* Build the private key template as described in section 4.3.3.7 of
2731          the OpenPGP card specs version 2.0.  */
2732       int exmode;
2733
2734       err = build_privkey_template (app, keyno,
2735                                     rsa_n, rsa_n_len,
2736                                     rsa_e, rsa_e_len,
2737                                     rsa_p, rsa_p_len,
2738                                     rsa_q, rsa_q_len,
2739                                     &template, &template_len);
2740       if (err)
2741         goto leave;
2742
2743       /* Prepare for storing the key.  */
2744       err = verify_chv3 (app, pincb, pincb_arg);
2745       if (err)
2746         goto leave;
2747
2748       /* Store the key. */
2749       if (app->app_local->cardcap.ext_lc_le && template_len > 254)
2750         exmode = 1;    /* Use extended length w/o a limit.  */
2751       else if (app->app_local->cardcap.cmd_chaining && template_len > 254)
2752         exmode = -254;
2753       else
2754         exmode = 0;
2755       err = iso7816_put_data_odd (app->slot, exmode, 0x3fff,
2756                                   template, template_len);
2757     }
2758   else
2759     {
2760       /* Build the private key template as described in section 4.3.3.6 of
2761          the OpenPGP card specs version 1.1:
2762          0xC0   <length> public exponent
2763          0xC1   <length> prime p
2764          0xC2   <length> prime q
2765       */
2766       assert (rsa_e_len <= 4);
2767       template_len = (1 + 1 + 4
2768                       + 1 + 1 + rsa_p_len
2769                       + 1 + 1 + rsa_q_len);
2770       template = tp = xtrymalloc_secure (template_len);
2771       if (!template)
2772         {
2773           err = gpg_error_from_syserror ();
2774           goto leave;
2775         }
2776       *tp++ = 0xC0;
2777       *tp++ = 4;
2778       memcpy (tp, rsa_e, rsa_e_len);
2779       if (rsa_e_len < 4)
2780         {
2781           /* Right justify E. */
2782           memmove (tp+4-rsa_e_len, tp, rsa_e_len);
2783           memset (tp, 0, 4-rsa_e_len);
2784         }
2785       tp += 4;
2786
2787       *tp++ = 0xC1;
2788       *tp++ = rsa_p_len;
2789       memcpy (tp, rsa_p, rsa_p_len);
2790       tp += rsa_p_len;
2791
2792       *tp++ = 0xC2;
2793       *tp++ = rsa_q_len;
2794       memcpy (tp, rsa_q, rsa_q_len);
2795       tp += rsa_q_len;
2796
2797       assert (tp - template == template_len);
2798
2799       /* Prepare for storing the key.  */
2800       err = verify_chv3 (app, pincb, pincb_arg);
2801       if (err)
2802         goto leave;
2803
2804       /* Store the key. */
2805       err = iso7816_put_data (app->slot, 0,
2806                               (app->card_version > 0x0007? 0xE0:0xE9)+keyno,
2807                               template, template_len);
2808     }
2809   if (err)
2810     {
2811       log_error (_("failed to store the key: %s\n"), gpg_strerror (err));
2812       goto leave;
2813     }
2814
2815   err = store_fpr (app, keyno, created_at,
2816                   rsa_n, rsa_n_len, rsa_e, rsa_e_len,
2817                   fprbuf, app->card_version);
2818   if (err)
2819     goto leave;
2820
2821
2822  leave:
2823   xfree (template);
2824   return err;
2825 }
2826
2827
2828 /* Handle the GENKEY command. */
2829 static gpg_error_t
2830 do_genkey (app_t app, ctrl_t ctrl,  const char *keynostr, unsigned int flags,
2831            time_t createtime,
2832            gpg_error_t (*pincb)(void*, const char *, char **),
2833            void *pincb_arg)
2834 {
2835   int rc;
2836   char numbuf[30];
2837   unsigned char fprbuf[20];
2838   const unsigned char *keydata, *m, *e;
2839   unsigned char *buffer = NULL;
2840   size_t buflen, keydatalen, mlen, elen;
2841   time_t created_at;
2842   int keyno = atoi (keynostr);
2843   int force = (flags & 1);
2844   time_t start_at;
2845   int exmode;
2846   int le_value;
2847   unsigned int keybits;
2848
2849   if (keyno < 1 || keyno > 3)
2850     return gpg_error (GPG_ERR_INV_ID);
2851   keyno--;
2852
2853   /* We flush the cache to increase the traffic before a key
2854      generation.  This _might_ help a card to gather more entropy. */
2855   flush_cache (app);
2856
2857   /* Obviously we need to remove the cached public key.  */
2858   xfree (app->app_local->pk[keyno].key);
2859   app->app_local->pk[keyno].key = NULL;
2860   app->app_local->pk[keyno].keylen = 0;
2861   app->app_local->pk[keyno].read_done = 0;
2862
2863   /* Check whether a key already exists.  */
2864   rc = does_key_exist (app, keyno, 1, force);
2865   if (rc)
2866     return rc;
2867
2868   /* Because we send the key parameter back via status lines we need
2869      to put a limit on the max. allowed keysize.  2048 bit will
2870      already lead to a 527 byte long status line and thus a 4096 bit
2871      key would exceed the Assuan line length limit.  */
2872   keybits = app->app_local->keyattr[keyno].n_bits;
2873   if (keybits > 4096)
2874     return gpg_error (GPG_ERR_TOO_LARGE);
2875
2876   /* Prepare for key generation by verifying the Admin PIN.  */
2877   rc = verify_chv3 (app, pincb, pincb_arg);
2878   if (rc)
2879     goto leave;
2880
2881   /* Test whether we will need extended length mode.  (1900 is an
2882      arbitrary length which for sure fits into a short apdu.)  */
2883   if (app->app_local->cardcap.ext_lc_le && keybits > 1900)
2884     {
2885       exmode = 1;    /* Use extended length w/o a limit.  */
2886       le_value = app->app_local->extcap.max_rsp_data;
2887       /* No need to check le_value because it comes from a 16 bit
2888          value and thus can't create an overflow on a 32 bit
2889          system.  */
2890     }
2891   else
2892     {
2893       exmode = 0;
2894       le_value = 256; /* Use legacy value. */
2895     }
2896
2897   log_info (_("please wait while key is being generated ...\n"));
2898   start_at = time (NULL);
2899   rc = iso7816_generate_keypair
2900 /* # warning key generation temporary replaced by reading an existing key. */
2901 /*   rc = iso7816_read_public_key */
2902     (app->slot, exmode,
2903      (const unsigned char*)(keyno == 0? "\xB6" :
2904                             keyno == 1? "\xB8" : "\xA4"), 2,
2905      le_value,
2906      &buffer, &buflen);
2907   if (rc)
2908     {
2909       rc = gpg_error (GPG_ERR_CARD);
2910       log_error (_("generating key failed\n"));
2911       goto leave;
2912     }
2913   log_info (_("key generation completed (%d seconds)\n"),
2914             (int)(time (NULL) - start_at));
2915
2916   keydata = find_tlv (buffer, buflen, 0x7F49, &keydatalen);
2917   if (!keydata)
2918     {
2919       rc = gpg_error (GPG_ERR_CARD);
2920       log_error (_("response does not contain the public key data\n"));
2921       goto leave;
2922     }
2923
2924   m = find_tlv (keydata, keydatalen, 0x0081, &mlen);
2925   if (!m)
2926     {
2927       rc = gpg_error (GPG_ERR_CARD);
2928       log_error (_("response does not contain the RSA modulus\n"));
2929       goto leave;
2930     }
2931   /* log_printhex ("RSA n:", m, mlen); */
2932   send_key_data (ctrl, "n", m, mlen);
2933
2934   e = find_tlv (keydata, keydatalen, 0x0082, &elen);
2935   if (!e)
2936     {
2937       rc = gpg_error (GPG_ERR_CARD);
2938       log_error (_("response does not contain the RSA public exponent\n"));
2939       goto leave;
2940     }
2941   /* log_printhex ("RSA e:", e, elen); */
2942   send_key_data (ctrl, "e", e, elen);
2943
2944   created_at = createtime? createtime : gnupg_get_time ();
2945   sprintf (numbuf, "%lu", (unsigned long)created_at);
2946   send_status_info (ctrl, "KEY-CREATED-AT",
2947                     numbuf, (size_t)strlen(numbuf), NULL, 0);
2948
2949   rc = store_fpr (app, keyno, (u32)created_at,
2950                   m, mlen, e, elen, fprbuf, app->card_version);
2951   if (rc)
2952     goto leave;
2953   send_fpr_if_not_null (ctrl, "KEY-FPR", -1, fprbuf);
2954
2955
2956  leave:
2957   xfree (buffer);
2958   return rc;
2959 }
2960
2961
2962 static unsigned long
2963 convert_sig_counter_value (const unsigned char *value, size_t valuelen)
2964 {
2965   unsigned long ul;
2966
2967   if (valuelen == 3 )
2968     ul = (value[0] << 16) | (value[1] << 8) | value[2];
2969   else
2970     {
2971       log_error (_("invalid structure of OpenPGP card (DO 0x93)\n"));
2972       ul = 0;
2973     }
2974   return ul;
2975 }
2976
2977 static unsigned long
2978 get_sig_counter (app_t app)
2979 {
2980   void *relptr;
2981   unsigned char *value;
2982   size_t valuelen;
2983   unsigned long ul;
2984
2985   relptr = get_one_do (app, 0x0093, &value, &valuelen, NULL);
2986   if (!relptr)
2987     return 0;
2988   ul = convert_sig_counter_value (value, valuelen);
2989   xfree (relptr);
2990   return ul;
2991 }
2992
2993 static gpg_error_t
2994 compare_fingerprint (app_t app, int keyno, unsigned char *sha1fpr)
2995 {
2996   const unsigned char *fpr;
2997   unsigned char *buffer;
2998   size_t buflen, n;
2999   int rc, i;
3000
3001   assert (keyno >= 1 && keyno <= 3);
3002
3003   rc = get_cached_data (app, 0x006E, &buffer, &buflen, 0, 0);
3004   if (rc)
3005     {
3006       log_error (_("error reading application data\n"));
3007       return gpg_error (GPG_ERR_GENERAL);
3008     }
3009   fpr = find_tlv (buffer, buflen, 0x00C5, &n);
3010   if (!fpr || n != 60)
3011     {
3012       xfree (buffer);
3013       log_error (_("error reading fingerprint DO\n"));
3014       return gpg_error (GPG_ERR_GENERAL);
3015     }
3016   fpr += (keyno-1)*20;
3017   for (i=0; i < 20; i++)
3018     if (sha1fpr[i] != fpr[i])
3019       {
3020         xfree (buffer);
3021         log_info (_("fingerprint on card does not match requested one\n"));
3022         return gpg_error (GPG_ERR_WRONG_SECKEY);
3023       }
3024   xfree (buffer);
3025   return 0;
3026 }
3027
3028
3029 /* If a fingerprint has been specified check it against the one on the
3030    card.  This allows for a meaningful error message in case the key
3031    on the card has been replaced but the shadow information known to
3032    gpg has not been updated.  If there is no fingerprint we assume
3033    that this is okay. */
3034 static gpg_error_t
3035 check_against_given_fingerprint (app_t app, const char *fpr, int keyno)
3036 {
3037   unsigned char tmp[20];
3038   const char *s;
3039   int n;
3040
3041   for (s=fpr, n=0; hexdigitp (s); s++, n++)
3042     ;
3043   if (n != 40)
3044     return gpg_error (GPG_ERR_INV_ID);
3045   else if (!*s)
3046     ; /* okay */
3047   else
3048     return gpg_error (GPG_ERR_INV_ID);
3049
3050   for (s=fpr, n=0; n < 20; s += 2, n++)
3051         tmp[n] = xtoi_2 (s);
3052   return compare_fingerprint (app, keyno, tmp);
3053 }
3054
3055
3056
3057 /* Compute a digital signature on INDATA which is expected to be the
3058    raw message digest. For this application the KEYIDSTR consists of
3059    the serialnumber and the fingerprint delimited by a slash.
3060
3061    Note that this function may return the error code
3062    GPG_ERR_WRONG_CARD to indicate that the card currently present does
3063    not match the one required for the requested action (e.g. the
3064    serial number does not match).
3065
3066    As a special feature a KEYIDSTR of "OPENPGP.3" redirects the
3067    operation to the auth command.
3068 */
3069 static gpg_error_t
3070 do_sign (app_t app, const char *keyidstr, int hashalgo,
3071          gpg_error_t (*pincb)(void*, const char *, char **),
3072          void *pincb_arg,
3073          const void *indata, size_t indatalen,
3074          unsigned char **outdata, size_t *outdatalen )
3075 {
3076   static unsigned char rmd160_prefix[15] = /* Object ID is 1.3.36.3.2.1 */
3077     { 0x30, 0x21, 0x30, 0x09, 0x06, 0x05, 0x2b, 0x24, 0x03,
3078       0x02, 0x01, 0x05, 0x00, 0x04, 0x14  };
3079   static unsigned char sha1_prefix[15] =   /* (1.3.14.3.2.26) */
3080     { 0x30, 0x21, 0x30, 0x09, 0x06, 0x05, 0x2b, 0x0e, 0x03,
3081       0x02, 0x1a, 0x05, 0x00, 0x04, 0x14  };
3082   static unsigned char sha224_prefix[19] = /* (2.16.840.1.101.3.4.2.4) */
3083     { 0x30, 0x2D, 0x30, 0x0d, 0x06, 0x09, 0x60, 0x86, 0x48,
3084       0x01, 0x65, 0x03, 0x04, 0x02, 0x04, 0x05, 0x00, 0x04,
3085       0x1C  };
3086   static unsigned char sha256_prefix[19] = /* (2.16.840.1.101.3.4.2.1) */
3087     { 0x30, 0x31, 0x30, 0x0d, 0x06, 0x09, 0x60, 0x86,
3088       0x48, 0x01, 0x65, 0x03, 0x04, 0x02, 0x01, 0x05,
3089       0x00, 0x04, 0x20  };
3090   static unsigned char sha384_prefix[19] = /* (2.16.840.1.101.3.4.2.2) */
3091     { 0x30, 0x41, 0x30, 0x0d, 0x06, 0x09, 0x60, 0x86,
3092       0x48, 0x01, 0x65, 0x03, 0x04, 0x02, 0x02, 0x05,
3093       0x00, 0x04, 0x30  };
3094   static unsigned char sha512_prefix[19] = /* (2.16.840.1.101.3.4.2.3) */
3095     { 0x30, 0x51, 0x30, 0x0d, 0x06, 0x09, 0x60, 0x86,
3096       0x48, 0x01, 0x65, 0x03, 0x04, 0x02, 0x03, 0x05,
3097       0x00, 0x04, 0x40  };
3098   int rc;
3099   unsigned char data[19+64];
3100   size_t datalen;
3101   unsigned char tmp_sn[20]; /* Actually 16 bytes but also for the fpr. */
3102   const char *s;
3103   int n;
3104   const char *fpr = NULL;
3105   unsigned long sigcount;
3106   int use_auth = 0;
3107   int exmode, le_value;
3108
3109   if (!keyidstr || !*keyidstr)
3110     return gpg_error (GPG_ERR_INV_VALUE);
3111
3112   /* Strip off known prefixes.  */
3113 #define X(a,b,c,d) \
3114   if (hashalgo == GCRY_MD_ ## a                               \
3115       && (d)                                                  \
3116       && indatalen == sizeof b ## _prefix + (c)               \
3117       && !memcmp (indata, b ## _prefix, sizeof b ## _prefix)) \
3118     {                                                         \
3119       indata = (const char*)indata + sizeof b ## _prefix;     \
3120       indatalen -= sizeof b ## _prefix;                       \
3121     }
3122
3123   if (indatalen == 20)
3124     ;  /* Assume a plain SHA-1 or RMD160 digest has been given.  */
3125   else X(SHA1,   sha1,   20, 1)
3126   else X(RMD160, rmd160, 20, 1)
3127   else X(SHA224, sha224, 28, app->app_local->extcap.is_v2)
3128   else X(SHA256, sha256, 32, app->app_local->extcap.is_v2)
3129   else X(SHA384, sha384, 48, app->app_local->extcap.is_v2)
3130   else X(SHA512, sha512, 64, app->app_local->extcap.is_v2)
3131   else if ((indatalen == 28 || indatalen == 32
3132             || indatalen == 48 || indatalen ==64)
3133            && app->app_local->extcap.is_v2)
3134     ;  /* Assume a plain SHA-3 digest has been given.  */
3135   else
3136     {
3137       log_error (_("card does not support digest algorithm %s\n"),
3138                  gcry_md_algo_name (hashalgo));
3139       /* Or the supplied digest length does not match an algorithm.  */
3140       return gpg_error (GPG_ERR_INV_VALUE);
3141     }
3142 #undef X
3143
3144   /* Check whether an OpenPGP card of any version has been requested. */
3145   if (!strcmp (keyidstr, "OPENPGP.1"))
3146     ;
3147   else if (!strcmp (keyidstr, "OPENPGP.3"))
3148     use_auth = 1;
3149   else if (strlen (keyidstr) < 32 || strncmp (keyidstr, "D27600012401", 12))
3150     return gpg_error (GPG_ERR_INV_ID);
3151   else
3152     {
3153       for (s=keyidstr, n=0; hexdigitp (s); s++, n++)
3154         ;
3155       if (n != 32)
3156         return gpg_error (GPG_ERR_INV_ID);
3157       else if (!*s)
3158         ; /* no fingerprint given: we allow this for now. */
3159       else if (*s == '/')
3160         fpr = s + 1;
3161       else
3162         return gpg_error (GPG_ERR_INV_ID);
3163
3164       for (s=keyidstr, n=0; n < 16; s += 2, n++)
3165         tmp_sn[n] = xtoi_2 (s);
3166
3167       if (app->serialnolen != 16)
3168         return gpg_error (GPG_ERR_INV_CARD);
3169       if (memcmp (app->serialno, tmp_sn, 16))
3170         return gpg_error (GPG_ERR_WRONG_CARD);
3171     }
3172
3173   /* If a fingerprint has been specified check it against the one on
3174      the card.  This is allows for a meaningful error message in case
3175      the key on the card has been replaced but the shadow information
3176      known to gpg was not updated.  If there is no fingerprint, gpg
3177      will detect a bogus signature anyway due to the
3178      verify-after-signing feature. */
3179   rc = fpr? check_against_given_fingerprint (app, fpr, 1) : 0;
3180   if (rc)
3181     return rc;
3182
3183   /* Concatenate prefix and digest.  */
3184 #define X(a,b,d) \
3185   if (hashalgo == GCRY_MD_ ## a && (d) )                      \
3186     {                                                         \
3187       datalen = sizeof b ## _prefix + indatalen;              \
3188       assert (datalen <= sizeof data);                        \
3189       memcpy (data, b ## _prefix, sizeof b ## _prefix);       \
3190       memcpy (data + sizeof b ## _prefix, indata, indatalen); \
3191     }
3192
3193   X(SHA1,   sha1,   1)
3194   else X(RMD160, rmd160, 1)
3195   else X(SHA224, sha224, app->app_local->extcap.is_v2)
3196   else X(SHA256, sha256, app->app_local->extcap.is_v2)
3197   else X(SHA384, sha384, app->app_local->extcap.is_v2)
3198   else X(SHA512, sha512, app->app_local->extcap.is_v2)
3199   else
3200     return gpg_error (GPG_ERR_UNSUPPORTED_ALGORITHM);
3201 #undef X
3202
3203   /* Redirect to the AUTH command if asked to. */
3204   if (use_auth)
3205     {
3206       return do_auth (app, "OPENPGP.3", pincb, pincb_arg,
3207                       data, datalen,
3208                       outdata, outdatalen);
3209     }
3210
3211   /* Show the number of signature done using this key.  */
3212   sigcount = get_sig_counter (app);
3213   log_info (_("signatures created so far: %lu\n"), sigcount);
3214
3215   /* Check CHV if needed.  */
3216   if (!app->did_chv1 || app->force_chv1 )
3217     {
3218       char *pinvalue;
3219
3220       rc = verify_a_chv (app, pincb, pincb_arg, 1, sigcount, &pinvalue);
3221       if (rc)
3222         return rc;
3223
3224       app->did_chv1 = 1;
3225
3226       /* For cards with versions < 2 we want to keep CHV1 and CHV2 in
3227          sync, thus we verify CHV2 here using the given PIN.  Cards
3228          with version2 to not have the need for a separate CHV2 and
3229          internally use just one.  Obviously we can't do that if the
3230          keypad has been used. */
3231       if (!app->did_chv2 && pinvalue && !app->app_local->extcap.is_v2)
3232         {
3233           rc = iso7816_verify (app->slot, 0x82, pinvalue, strlen (pinvalue));
3234           if (gpg_err_code (rc) == GPG_ERR_BAD_PIN)
3235             rc = gpg_error (GPG_ERR_PIN_NOT_SYNCED);
3236           if (rc)
3237             {
3238               log_error (_("verify CHV%d failed: %s\n"), 2, gpg_strerror (rc));
3239               xfree (pinvalue);
3240               flush_cache_after_error (app);
3241               return rc;
3242             }
3243           app->did_chv2 = 1;
3244         }
3245       xfree (pinvalue);
3246     }
3247
3248
3249   if (app->app_local->cardcap.ext_lc_le)
3250     {
3251       exmode = 1;    /* Use extended length.  */
3252       le_value = app->app_local->extcap.max_rsp_data;
3253     }
3254   else
3255     {
3256       exmode = 0;
3257       le_value = 0;
3258     }
3259   rc = iso7816_compute_ds (app->slot, exmode, data, datalen, le_value,
3260                            outdata, outdatalen);
3261   return rc;
3262 }
3263
3264 /* Compute a digital signature using the INTERNAL AUTHENTICATE command
3265    on INDATA which is expected to be the raw message digest. For this
3266    application the KEYIDSTR consists of the serialnumber and the
3267    fingerprint delimited by a slash.  Optionally the id OPENPGP.3 may
3268    be given.
3269
3270    Note that this function may return the error code
3271    GPG_ERR_WRONG_CARD to indicate that the card currently present does
3272    not match the one required for the requested action (e.g. the
3273    serial number does not match). */
3274 static gpg_error_t
3275 do_auth (app_t app, const char *keyidstr,
3276          gpg_error_t (*pincb)(void*, const char *, char **),
3277          void *pincb_arg,
3278          const void *indata, size_t indatalen,
3279          unsigned char **outdata, size_t *outdatalen )
3280 {
3281   int rc;
3282   unsigned char tmp_sn[20]; /* Actually 16 but we use it also for the fpr. */
3283   const char *s;
3284   int n;
3285   const char *fpr = NULL;
3286
3287   if (!keyidstr || !*keyidstr)
3288     return gpg_error (GPG_ERR_INV_VALUE);
3289   if (indatalen > 101) /* For a 2048 bit key. */
3290     return gpg_error (GPG_ERR_INV_VALUE);
3291
3292   /* Check whether an OpenPGP card of any version has been requested. */
3293   if (!strcmp (keyidstr, "OPENPGP.3"))
3294     ;
3295   else if (strlen (keyidstr) < 32 || strncmp (keyidstr, "D27600012401", 12))
3296     return gpg_error (GPG_ERR_INV_ID);
3297   else
3298     {
3299       for (s=keyidstr, n=0; hexdigitp (s); s++, n++)
3300         ;
3301       if (n != 32)
3302         return gpg_error (GPG_ERR_INV_ID);
3303       else if (!*s)
3304         ; /* no fingerprint given: we allow this for now. */
3305       else if (*s == '/')
3306         fpr = s + 1;
3307       else
3308         return gpg_error (GPG_ERR_INV_ID);
3309
3310       for (s=keyidstr, n=0; n < 16; s += 2, n++)
3311         tmp_sn[n] = xtoi_2 (s);
3312
3313       if (app->serialnolen != 16)
3314         return gpg_error (GPG_ERR_INV_CARD);
3315       if (memcmp (app->serialno, tmp_sn, 16))
3316         return gpg_error (GPG_ERR_WRONG_CARD);
3317     }
3318
3319   /* If a fingerprint has been specified check it against the one on
3320      the card.  This is allows for a meaningful error message in case
3321      the key on the card has been replaced but the shadow information
3322      known to gpg was not updated.  If there is no fingerprint, gpg
3323      will detect a bogus signature anyway due to the
3324      verify-after-signing feature. */
3325   rc = fpr? check_against_given_fingerprint (app, fpr, 3) : 0;
3326   if (rc)
3327     return rc;
3328
3329   rc = verify_chv2 (app, pincb, pincb_arg);
3330   if (!rc)
3331     {
3332       int exmode, le_value;
3333
3334       if (app->app_local->cardcap.ext_lc_le)
3335         {
3336           exmode = 1;    /* Use extended length.  */
3337           le_value = app->app_local->extcap.max_rsp_data;
3338         }
3339       else
3340         {
3341           exmode = 0;
3342           le_value = 0;
3343         }
3344       rc = iso7816_internal_authenticate (app->slot, exmode,
3345                                           indata, indatalen, le_value,
3346                                           outdata, outdatalen);
3347     }
3348   return rc;
3349 }
3350
3351
3352 static gpg_error_t
3353 do_decipher (app_t app, const char *keyidstr,
3354              gpg_error_t (*pincb)(void*, const char *, char **),
3355              void *pincb_arg,
3356              const void *indata, size_t indatalen,
3357              unsigned char **outdata, size_t *outdatalen )
3358 {
3359   int rc;
3360   unsigned char tmp_sn[20]; /* actually 16 but we use it also for the fpr. */
3361   const char *s;
3362   int n;
3363   const char *fpr = NULL;
3364   int exmode, le_value;
3365
3366   if (!keyidstr || !*keyidstr || !indatalen)
3367     return gpg_error (GPG_ERR_INV_VALUE);
3368
3369   /* Check whether an OpenPGP card of any version has been requested. */
3370   if (!strcmp (keyidstr, "OPENPGP.2"))
3371     ;
3372   else if (strlen (keyidstr) < 32 || strncmp (keyidstr, "D27600012401", 12))
3373     return gpg_error (GPG_ERR_INV_ID);
3374   else
3375     {
3376       for (s=keyidstr, n=0; hexdigitp (s); s++, n++)
3377         ;
3378       if (n != 32)
3379         return gpg_error (GPG_ERR_INV_ID);
3380       else if (!*s)
3381         ; /* no fingerprint given: we allow this for now. */
3382       else if (*s == '/')
3383         fpr = s + 1;
3384       else
3385         return gpg_error (GPG_ERR_INV_ID);
3386
3387       for (s=keyidstr, n=0; n < 16; s += 2, n++)
3388         tmp_sn[n] = xtoi_2 (s);
3389
3390       if (app->serialnolen != 16)
3391         return gpg_error (GPG_ERR_INV_CARD);
3392       if (memcmp (app->serialno, tmp_sn, 16))
3393         return gpg_error (GPG_ERR_WRONG_CARD);
3394     }
3395
3396   /* If a fingerprint has been specified check it against the one on
3397      the card.  This is allows for a meaningful error message in case
3398      the key on the card has been replaced but the shadow information
3399      known to gpg was not updated.  If there is no fingerprint, the
3400      decryption won't produce the right plaintext anyway. */
3401   rc = fpr? check_against_given_fingerprint (app, fpr, 2) : 0;
3402   if (rc)
3403     return rc;
3404
3405   rc = verify_chv2 (app, pincb, pincb_arg);
3406   if (!rc)
3407     {
3408       size_t fixuplen;
3409       unsigned char *fixbuf = NULL;
3410       int padind = 0;
3411
3412       /* We might encounter a couple of leading zeroes in the
3413          cryptogram.  Due to internal use of MPIs thease leading
3414          zeroes are stripped.  However the OpenPGP card expects
3415          exactly 128 bytes for the cryptogram (for a 1k key).  Thus we
3416          need to fix it up.  We do this for up to 16 leading zero
3417          bytes; a cryptogram with more than this is with a very high
3418          probability anyway broken.  */
3419       if (indatalen >= (128-16) && indatalen < 128)      /* 1024 bit key.  */
3420         fixuplen = 128 - indatalen;
3421       else if (indatalen >= (192-16) && indatalen < 192) /* 1536 bit key.  */
3422         fixuplen = 192 - indatalen;
3423       else if (indatalen >= (256-16) && indatalen < 256) /* 2048 bit key.  */
3424         fixuplen = 256 - indatalen;
3425       else if (indatalen >= (384-16) && indatalen < 384) /* 3072 bit key.  */
3426         fixuplen = 384 - indatalen;
3427       else if (indatalen >= (512-16) && indatalen < 512) /* 4096 bit key.  */
3428         fixuplen = 512 - indatalen;
3429       else
3430         fixuplen = 0;
3431
3432       if (fixuplen)
3433         {
3434           /* While we have to prepend stuff anyway, we can also
3435              include the padding byte here so that iso1816_decipher
3436              does not need to do another data mangling.  */
3437           fixuplen++;
3438
3439           fixbuf = xtrymalloc (fixuplen + indatalen);
3440           if (!fixbuf)
3441             return gpg_error_from_syserror ();
3442
3443           memset (fixbuf, 0, fixuplen);
3444           memcpy (fixbuf+fixuplen, indata, indatalen);
3445           indata = fixbuf;
3446           indatalen = fixuplen + indatalen;
3447           padind = -1; /* Already padded.  */
3448         }
3449
3450       if (app->app_local->cardcap.ext_lc_le && indatalen > 254 )
3451         {
3452           exmode = 1;    /* Extended length w/o a limit.  */
3453           le_value = app->app_local->extcap.max_rsp_data;
3454         }
3455       else if (app->app_local->cardcap.cmd_chaining && indatalen > 254)
3456         {
3457           exmode = -254; /* Command chaining with max. 254 bytes.  */
3458           le_value = 0;
3459         }
3460       else
3461         exmode = le_value = 0;
3462
3463       rc = iso7816_decipher (app->slot, exmode,
3464                              indata, indatalen, le_value, padind,
3465                              outdata, outdatalen);
3466       xfree (fixbuf);
3467
3468       if (gpg_err_code (rc) == GPG_ERR_CARD /* actual SW is 0x640a */
3469           && app->app_local->manufacturer == 5
3470           && app->card_version == 0x0200)
3471         log_info ("NOTE: Cards with manufacturer id 5 and s/n <= 346 (0x15a)"
3472                   " do not work with encryption keys > 2048 bits\n");
3473     }
3474
3475   return rc;
3476 }
3477
3478
3479 /* Perform a simple verify operation for CHV1 and CHV2, so that
3480    further operations won't ask for CHV2 and it is possible to do a
3481    cheap check on the PIN: If there is something wrong with the PIN
3482    entry system, only the regular CHV will get blocked and not the
3483    dangerous CHV3.  KEYIDSTR is the usual card's serial number; an
3484    optional fingerprint part will be ignored.
3485
3486    There is a special mode if the keyidstr is "<serialno>[CHV3]" with
3487    the "[CHV3]" being a literal string:  The Admin Pin is checked if
3488    and only if the retry counter is still at 3. */
3489 static gpg_error_t
3490 do_check_pin (app_t app, const char *keyidstr,
3491               gpg_error_t (*pincb)(void*, const char *, char **),
3492               void *pincb_arg)
3493 {
3494   unsigned char tmp_sn[20];
3495   const char *s;
3496   int n;
3497   int admin_pin = 0;
3498
3499   if (!keyidstr || !*keyidstr)
3500     return gpg_error (GPG_ERR_INV_VALUE);
3501
3502   /* Check whether an OpenPGP card of any version has been requested. */
3503   if (strlen (keyidstr) < 32 || strncmp (keyidstr, "D27600012401", 12))
3504     return gpg_error (GPG_ERR_INV_ID);
3505
3506   for (s=keyidstr, n=0; hexdigitp (s); s++, n++)
3507     ;
3508   if (n != 32)
3509     return gpg_error (GPG_ERR_INV_ID);
3510   else if (!*s)
3511     ; /* No fingerprint given: we allow this for now. */
3512   else if (*s == '/')
3513     ; /* We ignore a fingerprint. */
3514   else if (!strcmp (s, "[CHV3]") )
3515     admin_pin = 1;
3516   else
3517     return gpg_error (GPG_ERR_INV_ID);
3518
3519   for (s=keyidstr, n=0; n < 16; s += 2, n++)
3520     tmp_sn[n] = xtoi_2 (s);
3521
3522   if (app->serialnolen != 16)
3523     return gpg_error (GPG_ERR_INV_CARD);
3524   if (memcmp (app->serialno, tmp_sn, 16))
3525     return gpg_error (GPG_ERR_WRONG_CARD);
3526
3527   /* Yes, there is a race conditions: The user might pull the card
3528      right here and we won't notice that.  However this is not a
3529      problem and the check above is merely for a graceful failure
3530      between operations. */
3531
3532   if (admin_pin)
3533     {
3534       void *relptr;
3535       unsigned char *value;
3536       size_t valuelen;
3537       int count;
3538
3539       relptr = get_one_do (app, 0x00C4, &value, &valuelen, NULL);
3540       if (!relptr || valuelen < 7)
3541         {
3542           log_error (_("error retrieving CHV status from card\n"));
3543           xfree (relptr);
3544           return gpg_error (GPG_ERR_CARD);
3545         }
3546       count = value[6];
3547       xfree (relptr);
3548
3549       if (!count)
3550         {
3551           log_info (_("card is permanently locked!\n"));
3552           return gpg_error (GPG_ERR_BAD_PIN);
3553         }
3554       else if (value[6] < 3)
3555         {
3556           log_info (_("verification of Admin PIN is currently prohibited "
3557                       "through this command\n"));
3558           return gpg_error (GPG_ERR_GENERAL);
3559         }
3560
3561       app->did_chv3 = 0; /* Force verification.  */
3562       return verify_chv3 (app, pincb, pincb_arg);
3563     }
3564   else
3565     return verify_chv2 (app, pincb, pincb_arg);
3566 }
3567
3568
3569 /* Show information about card capabilities.  */
3570 static void
3571 show_caps (struct app_local_s *s)
3572 {
3573   log_info ("Version-2 ......: %s\n", s->extcap.is_v2? "yes":"no");
3574   log_info ("Get-Challenge ..: %s", s->extcap.get_challenge? "yes":"no");
3575   if (s->extcap.get_challenge)
3576     log_printf (" (%u bytes max)", s->extcap.max_get_challenge);
3577   log_info ("Key-Import .....: %s\n", s->extcap.key_import? "yes":"no");
3578   log_info ("Change-Force-PW1: %s\n", s->extcap.change_force_chv? "yes":"no");
3579   log_info ("Private-DOs ....: %s\n", s->extcap.private_dos? "yes":"no");
3580   log_info ("Algo-Attr-Change: %s\n", s->extcap.algo_attr_change? "yes":"no");
3581   log_info ("SM-Support .....: %s", s->extcap.sm_supported? "yes":"no");
3582   if (s->extcap.sm_supported)
3583     log_printf (" (%s)", s->extcap.sm_aes128? "AES-128":"3DES");
3584   log_info ("Max-Cert3-Len ..: %u\n", s->extcap.max_certlen_3);
3585   log_info ("Max-Cmd-Data ...: %u\n", s->extcap.max_cmd_data);
3586   log_info ("Max-Rsp-Data ...: %u\n", s->extcap.max_rsp_data);
3587   log_info ("Cmd-Chaining ...: %s\n", s->cardcap.cmd_chaining?"yes":"no");
3588   log_info ("Ext-Lc-Le ......: %s\n", s->cardcap.ext_lc_le?"yes":"no");
3589   log_info ("Status Indicator: %02X\n", s->status_indicator);
3590
3591   log_info ("GnuPG-No-Sync ..: %s\n",  s->flags.no_sync? "yes":"no");
3592   log_info ("GnuPG-Def-PW2 ..: %s\n",  s->flags.def_chv2? "yes":"no");
3593 }
3594
3595
3596 /* Parse the historical bytes in BUFFER of BUFLEN and store them in
3597    APPLOC.  */
3598 static void
3599 parse_historical (struct app_local_s *apploc,
3600                   const unsigned char * buffer, size_t buflen)
3601 {
3602   /* Example buffer: 00 31 C5 73 C0 01 80 00 90 00  */
3603   if (buflen < 4)
3604     {
3605       log_error ("warning: historical bytes are too short\n");
3606       return; /* Too short.  */
3607     }
3608   if (*buffer)
3609     {
3610       log_error ("warning: bad category indicator in historical bytes\n");
3611       return;
3612     }
3613
3614   /* Skip category indicator.  */
3615   buffer++;
3616   buflen--;
3617
3618   /* Get the status indicator.  */
3619   apploc->status_indicator = buffer[buflen-3];
3620   buflen -= 3;
3621
3622   /* Parse the compact TLV.  */
3623   while (buflen)
3624     {
3625       unsigned int tag = (*buffer & 0xf0) >> 4;
3626       unsigned int len = (*buffer & 0x0f);
3627       if (len+1 > buflen)
3628         {
3629           log_error ("warning: bad Compact-TLV in historical bytes\n");
3630           return; /* Error.  */
3631         }
3632       buffer++;
3633       buflen--;
3634       if (tag == 7 && len == 3)
3635         {
3636           /* Card capabilities.  */
3637           apploc->cardcap.cmd_chaining = !!(buffer[2] & 0x80);
3638           apploc->cardcap.ext_lc_le    = !!(buffer[2] & 0x40);
3639         }
3640       buffer += len;
3641       buflen -= len;
3642     }
3643 }
3644
3645
3646 /* Parse and optionally show the algorithm attributes for KEYNO.
3647    KEYNO must be in the range 0..2.  */
3648 static void
3649 parse_algorithm_attribute (app_t app, int keyno)
3650 {
3651   unsigned char *buffer;
3652   size_t buflen;
3653   void *relptr;
3654   const char const desc[3][5] = {"sign", "encr", "auth"};
3655
3656   assert (keyno >=0 && keyno <= 2);
3657
3658   app->app_local->keyattr[keyno].n_bits = 0;
3659
3660   relptr = get_one_do (app, 0xC1+keyno, &buffer, &buflen, NULL);
3661   if (!relptr)
3662     {
3663       log_error ("error reading DO 0x%02X\n", 0xc1+keyno);
3664       return;
3665     }
3666   if (buflen < 1)
3667     {
3668       log_error ("error reading DO 0x%02X\n", 0xc1+keyno);
3669       xfree (relptr);
3670       return;
3671     }
3672
3673   if (opt.verbose)
3674     log_info ("Key-Attr-%s ..: ", desc[keyno]);
3675   if (*buffer == 1 && (buflen == 5 || buflen == 6))
3676     {
3677       app->app_local->keyattr[keyno].n_bits = (buffer[1]<<8 | buffer[2]);
3678       app->app_local->keyattr[keyno].e_bits = (buffer[3]<<8 | buffer[4]);
3679       app->app_local->keyattr[keyno].format = 0;
3680       if (buflen < 6)
3681         app->app_local->keyattr[keyno].format = RSA_STD;
3682       else
3683         app->app_local->keyattr[keyno].format = (buffer[5] == 0? RSA_STD   :
3684                                                  buffer[5] == 1? RSA_STD_N :
3685                                                  buffer[5] == 2? RSA_CRT   :
3686                                                  buffer[5] == 3? RSA_CRT_N :
3687                                                  RSA_UNKNOWN_FMT);
3688
3689       if (opt.verbose)
3690         log_printf
3691           ("RSA, n=%u, e=%u, fmt=%s\n",
3692            app->app_local->keyattr[keyno].n_bits,
3693            app->app_local->keyattr[keyno].e_bits,
3694            app->app_local->keyattr[keyno].format == RSA_STD?  "std"  :
3695            app->app_local->keyattr[keyno].format == RSA_STD_N?"std+n":
3696            app->app_local->keyattr[keyno].format == RSA_CRT?  "crt"  :
3697            app->app_local->keyattr[keyno].format == RSA_CRT_N?"crt+n":"?");
3698     }
3699   else if (opt.verbose)
3700     log_printhex ("", buffer, buflen);
3701
3702   xfree (relptr);
3703 }
3704
3705 /* Select the OpenPGP application on the card in SLOT.  This function
3706    must be used before any other OpenPGP application functions. */
3707 gpg_error_t
3708 app_select_openpgp (app_t app)
3709 {
3710   static char const aid[] = { 0xD2, 0x76, 0x00, 0x01, 0x24, 0x01 };
3711   int slot = app->slot;
3712   int rc;
3713   unsigned char *buffer;
3714   size_t buflen;
3715   void *relptr;
3716
3717   /* Note that the card can't cope with P2=0xCO, thus we need to pass a
3718      special flag value. */
3719   rc = iso7816_select_application (slot, aid, sizeof aid, 0x0001);
3720   if (!rc)
3721     {
3722       unsigned int manufacturer;
3723
3724       app->apptype = "OPENPGP";
3725
3726       app->did_chv1 = 0;
3727       app->did_chv2 = 0;
3728       app->did_chv3 = 0;
3729       app->app_local = NULL;
3730
3731       /* The OpenPGP card returns the serial number as part of the
3732          AID; because we prefer to use OpenPGP serial numbers, we
3733          replace a possibly already set one from a EF.GDO with this
3734          one.  Note, that for current OpenPGP cards, no EF.GDO exists
3735          and thus it won't matter at all. */
3736       rc = iso7816_get_data (slot, 0, 0x004F, &buffer, &buflen);
3737       if (rc)
3738         goto leave;
3739       if (opt.verbose)
3740         {
3741           log_info ("AID: ");
3742           log_printhex ("", buffer, buflen);
3743         }
3744
3745       app->card_version = buffer[6] << 8;
3746       app->card_version |= buffer[7];
3747       manufacturer = (buffer[8]<<8 | buffer[9]);
3748
3749       xfree (app->serialno);
3750       app->serialno = buffer;
3751       app->serialnolen = buflen;
3752       buffer = NULL;
3753       app->app_local = xtrycalloc (1, sizeof *app->app_local);
3754       if (!app->app_local)
3755         {
3756           rc = gpg_error (gpg_err_code_from_errno (errno));
3757           goto leave;
3758         }
3759
3760       app->app_local->manufacturer = manufacturer;
3761
3762       if (app->card_version >= 0x0200)
3763         app->app_local->extcap.is_v2 = 1;
3764
3765
3766       /* Read the historical bytes.  */
3767       relptr = get_one_do (app, 0x5f52, &buffer, &buflen, NULL);
3768       if (relptr)
3769         {
3770           if (opt.verbose)
3771             {
3772               log_info ("Historical Bytes: ");
3773               log_printhex ("", buffer, buflen);
3774             }
3775           parse_historical (app->app_local, buffer, buflen);
3776           xfree (relptr);
3777         }
3778
3779       /* Read the force-chv1 flag.  */
3780       relptr = get_one_do (app, 0x00C4, &buffer, &buflen, NULL);
3781       if (!relptr)
3782         {
3783           log_error (_("can't access %s - invalid OpenPGP card?\n"),
3784                      "CHV Status Bytes");
3785           goto leave;
3786         }
3787       app->force_chv1 = (buflen && *buffer == 0);
3788       xfree (relptr);
3789
3790       /* Read the extended capabilities.  */
3791       relptr = get_one_do (app, 0x00C0, &buffer, &buflen, NULL);
3792       if (!relptr)
3793         {
3794           log_error (_("can't access %s - invalid OpenPGP card?\n"),
3795                      "Extended Capability Flags" );
3796           goto leave;
3797         }
3798       if (buflen)
3799         {
3800           app->app_local->extcap.sm_supported     = !!(*buffer & 0x80);
3801           app->app_local->extcap.get_challenge    = !!(*buffer & 0x40);
3802           app->app_local->extcap.key_import       = !!(*buffer & 0x20);
3803           app->app_local->extcap.change_force_chv = !!(*buffer & 0x10);
3804           app->app_local->extcap.private_dos      = !!(*buffer & 0x08);
3805           app->app_local->extcap.algo_attr_change = !!(*buffer & 0x04);
3806         }
3807       if (buflen >= 10)
3808         {
3809           /* Available with v2 cards.  */
3810           app->app_local->extcap.sm_aes128     = (buffer[1] == 1);
3811           app->app_local->extcap.max_get_challenge
3812                                                = (buffer[2] << 8 | buffer[3]);
3813           app->app_local->extcap.max_certlen_3 = (buffer[4] << 8 | buffer[5]);
3814           app->app_local->extcap.max_cmd_data  = (buffer[6] << 8 | buffer[7]);
3815           app->app_local->extcap.max_rsp_data  = (buffer[8] << 8 | buffer[9]);
3816         }
3817       xfree (relptr);
3818
3819       /* Some of the first cards accidently don't set the
3820          CHANGE_FORCE_CHV bit but allow it anyway. */
3821       if (app->card_version <= 0x0100 && manufacturer == 1)
3822         app->app_local->extcap.change_force_chv = 1;
3823
3824       parse_login_data (app);
3825
3826       if (opt.verbose)
3827         show_caps (app->app_local);
3828
3829       parse_algorithm_attribute (app, 0);
3830       parse_algorithm_attribute (app, 1);
3831       parse_algorithm_attribute (app, 2);
3832
3833       if (opt.verbose > 1)
3834         dump_all_do (slot);
3835
3836       app->fnc.deinit = do_deinit;
3837       app->fnc.learn_status = do_learn_status;
3838       app->fnc.readcert = do_readcert;
3839       app->fnc.readkey = do_readkey;
3840       app->fnc.getattr = do_getattr;
3841       app->fnc.setattr = do_setattr;
3842       app->fnc.writecert = do_writecert;
3843       app->fnc.writekey = do_writekey;
3844       app->fnc.genkey = do_genkey;
3845       app->fnc.sign = do_sign;
3846       app->fnc.auth = do_auth;
3847       app->fnc.decipher = do_decipher;
3848       app->fnc.change_pin = do_change_pin;
3849       app->fnc.check_pin = do_check_pin;
3850    }
3851
3852 leave:
3853   if (rc)
3854     do_deinit (app);
3855   return rc;
3856 }
3857
3858
3859