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