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