Add new attribute KEY-ATTR.
[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, (const unsigned char*)(keyno == 0? "\xB6" :
1099                                            keyno == 1? "\xB8" : "\xA4"),
1100          2,  
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)
1299 {
1300   do_getattr (app, ctrl, "EXTCAP");
1301   do_getattr (app, ctrl, "DISP-NAME");
1302   do_getattr (app, ctrl, "DISP-LANG");
1303   do_getattr (app, ctrl, "DISP-SEX");
1304   do_getattr (app, ctrl, "PUBKEY-URL");
1305   do_getattr (app, ctrl, "LOGIN-DATA");
1306   do_getattr (app, ctrl, "KEY-FPR");
1307   if (app->card_version > 0x0100)
1308     do_getattr (app, ctrl, "KEY-TIME");
1309   do_getattr (app, ctrl, "CA-FPR");
1310   do_getattr (app, ctrl, "CHV-STATUS");
1311   do_getattr (app, ctrl, "SIG-COUNTER");
1312   if (app->app_local->extcap.private_dos)
1313     {
1314       do_getattr (app, ctrl, "PRIVATE-DO-1");
1315       do_getattr (app, ctrl, "PRIVATE-DO-2");
1316       if (app->did_chv2)
1317         do_getattr (app, ctrl, "PRIVATE-DO-3");
1318       if (app->did_chv3)
1319         do_getattr (app, ctrl, "PRIVATE-DO-4");
1320     }
1321   send_keypair_info (app, ctrl, 1);
1322   send_keypair_info (app, ctrl, 2);
1323   send_keypair_info (app, ctrl, 3);
1324   /* Note: We do not send the Cardholder Certificate, because that is
1325      relativly long and for OpenPGP applications not really needed.  */
1326   return 0;
1327 }
1328
1329
1330 /* Handle the READKEY command for OpenPGP.  On success a canonical
1331    encoded S-expression with the public key will get stored at PK and
1332    its length (for assertions) at PKLEN; the caller must release that
1333    buffer. On error PK and PKLEN are not changed and an error code is
1334    returned.  */
1335 static gpg_error_t
1336 do_readkey (app_t app, const char *keyid, unsigned char **pk, size_t *pklen)
1337 {
1338 #if GNUPG_MAJOR_VERSION > 1
1339   gpg_error_t err;
1340   int keyno;
1341   unsigned char *buf;
1342
1343   if (!strcmp (keyid, "OPENPGP.1"))
1344     keyno = 1;
1345   else if (!strcmp (keyid, "OPENPGP.2"))
1346     keyno = 2;
1347   else if (!strcmp (keyid, "OPENPGP.3"))
1348     keyno = 3;
1349   else
1350     return gpg_error (GPG_ERR_INV_ID);
1351
1352   err = get_public_key (app, keyno);
1353   if (err)
1354     return err;
1355
1356   buf = app->app_local->pk[keyno-1].key;
1357   if (!buf)
1358     return gpg_error (GPG_ERR_NO_PUBKEY);
1359   *pklen = app->app_local->pk[keyno-1].keylen;;
1360   *pk = xtrymalloc (*pklen);
1361   if (!*pk)
1362     {
1363       err = gpg_error_from_syserror ();
1364       *pklen = 0;
1365       return err;
1366     }
1367   memcpy (*pk, buf, *pklen);
1368   return 0;
1369 #else
1370   return gpg_error (GPG_ERR_NOT_IMPLEMENTED);
1371 #endif
1372 }
1373
1374 /* Read the standard certificate of an OpenPGP v2 card.  It is
1375    returned in a freshly allocated buffer with that address stored at
1376    CERT and the length of the certificate stored at CERTLEN.  CERTID
1377    needs to be set to "OPENPGP.3".  */
1378 static gpg_error_t
1379 do_readcert (app_t app, const char *certid,
1380              unsigned char **cert, size_t *certlen)
1381 {
1382 #if GNUPG_MAJOR_VERSION > 1
1383   gpg_error_t err;
1384   unsigned char *buffer;
1385   size_t buflen;
1386   void *relptr;
1387
1388   *cert = NULL;
1389   *certlen = 0;
1390   if (strcmp (certid, "OPENPGP.3"))
1391     return gpg_error (GPG_ERR_INV_ID);
1392   if (!app->app_local->extcap.is_v2)
1393     return gpg_error (GPG_ERR_NOT_FOUND);
1394
1395   relptr = get_one_do (app, 0x7F21, &buffer, &buflen, NULL);
1396   if (!relptr)
1397     return gpg_error (GPG_ERR_NOT_FOUND);
1398
1399   *cert = xtrymalloc (buflen);
1400   if (!*cert)
1401     err = gpg_error_from_syserror ();
1402   else
1403     {
1404       memcpy (*cert, buffer, buflen);
1405       *certlen = buflen;
1406       err  = 0;
1407     }
1408   xfree (relptr);
1409   return err;
1410 #else
1411   return gpg_error (GPG_ERR_NOT_IMPLEMENTED);
1412 #endif
1413 }
1414
1415
1416 /* Verify a CHV either using using the pinentry or if possibile by
1417    using a keypad.  PINCB and PINCB_ARG describe the usual callback
1418    for the pinentry.  CHVNO must be either 1 or 2. SIGCOUNT is only
1419    used with CHV1.  PINVALUE is the address of a pointer which will
1420    receive a newly allocated block with the actual PIN (this is useful
1421    in case that PIN shall be used for another verifiy operation).  The
1422    caller needs to free this value.  If the function returns with
1423    success and NULL is stored at PINVALUE, the caller should take this
1424    as an indication that the keypad has been used.
1425    */
1426 static gpg_error_t
1427 verify_a_chv (app_t app,
1428               gpg_error_t (*pincb)(void*, const char *, char **),
1429               void *pincb_arg,
1430               int chvno, unsigned long sigcount, char **pinvalue)
1431 {
1432   int rc = 0;
1433   char *prompt_buffer = NULL;
1434   const char *prompt;
1435   iso7816_pininfo_t pininfo;
1436   int minlen = 6;
1437
1438   assert (chvno == 1 || chvno == 2);
1439
1440   *pinvalue = NULL;
1441
1442   if (chvno == 2 && app->app_local->flags.def_chv2)
1443     {
1444       /* Special case for def_chv2 mechanism. */
1445       if (opt.verbose)
1446         log_info (_("using default PIN as %s\n"), "CHV2");
1447       rc = iso7816_verify (app->slot, 0x82, "123456", 6);
1448       if (rc)
1449         {
1450           /* Verification of CHV2 with the default PIN failed,
1451              although the card pretends to have the default PIN set as
1452              CHV2.  We better disable the def_chv2 flag now. */
1453           log_info (_("failed to use default PIN as %s: %s"
1454                       " - disabling further default use\n"),
1455                     "CHV2", gpg_strerror (rc));
1456           app->app_local->flags.def_chv2 = 0;
1457         }
1458       return rc;
1459     }
1460
1461   memset (&pininfo, 0, sizeof pininfo);
1462   pininfo.mode = 1;
1463   pininfo.minlen = minlen;
1464
1465
1466   if (chvno == 1)
1467     {
1468 #define PROMPTSTRING  _("||Please enter the PIN%%0A[sigs done: %lu]")
1469       size_t promptsize = strlen (PROMPTSTRING) + 50;
1470
1471       prompt_buffer = xtrymalloc (promptsize);
1472       if (!prompt_buffer)
1473         return gpg_error_from_syserror ();
1474       snprintf (prompt_buffer, promptsize-1, PROMPTSTRING, sigcount);
1475       prompt = prompt_buffer;
1476 #undef PROMPTSTRING
1477     }
1478   else
1479     prompt = _("||Please enter the PIN");
1480
1481   
1482   if (!opt.disable_keypad
1483       && !iso7816_check_keypad (app->slot, ISO7816_VERIFY, &pininfo) )
1484     {
1485       /* The reader supports the verify command through the keypad.
1486          Note that the pincb appends a text to the prompt telling the
1487          user to use the keypad. */
1488       rc = pincb (pincb_arg, prompt, NULL); 
1489       prompt = NULL;
1490       xfree (prompt_buffer); 
1491       prompt_buffer = NULL;
1492       if (rc)
1493         {
1494           log_info (_("PIN callback returned error: %s\n"),
1495                     gpg_strerror (rc));
1496           return rc;
1497         }
1498       rc = iso7816_verify_kp (app->slot, 0x80+chvno, "", 0, &pininfo); 
1499       /* Dismiss the prompt. */
1500       pincb (pincb_arg, NULL, NULL);
1501
1502       assert (!*pinvalue);
1503     }
1504   else
1505     {
1506       /* The reader has no keypad or we don't want to use it. */
1507       rc = pincb (pincb_arg, prompt, pinvalue); 
1508       prompt = NULL;
1509       xfree (prompt_buffer); 
1510       prompt_buffer = NULL;
1511       if (rc)
1512         {
1513           log_info (_("PIN callback returned error: %s\n"),
1514                     gpg_strerror (rc));
1515           return rc;
1516         }
1517       
1518       if (strlen (*pinvalue) < minlen)
1519         {
1520           log_error (_("PIN for CHV%d is too short;"
1521                        " minimum length is %d\n"), chvno, minlen);
1522           xfree (*pinvalue);
1523           *pinvalue = NULL;
1524           return gpg_error (GPG_ERR_BAD_PIN);
1525         }
1526
1527       rc = iso7816_verify (app->slot, 0x80+chvno,
1528                            *pinvalue, strlen (*pinvalue));
1529     }
1530   
1531   if (rc)
1532     {
1533       log_error (_("verify CHV%d failed: %s\n"), chvno, gpg_strerror (rc));
1534       xfree (*pinvalue);
1535       *pinvalue = NULL;
1536       flush_cache_after_error (app);
1537     }
1538
1539   return rc;
1540 }
1541
1542
1543 /* Verify CHV2 if required.  Depending on the configuration of the
1544    card CHV1 will also be verified. */
1545 static gpg_error_t
1546 verify_chv2 (app_t app,
1547              gpg_error_t (*pincb)(void*, const char *, char **),
1548              void *pincb_arg)
1549 {
1550   int rc;
1551   char *pinvalue;
1552
1553   if (app->did_chv2) 
1554     return 0;  /* We already verified CHV2.  */
1555
1556   rc = verify_a_chv (app, pincb, pincb_arg, 2, 0, &pinvalue);
1557   if (rc)
1558     return rc;
1559
1560   app->did_chv2 = 1;
1561   
1562   if (!app->did_chv1 && !app->force_chv1 && pinvalue)
1563     {
1564       /* For convenience we verify CHV1 here too.  We do this only if
1565          the card is not configured to require a verification before
1566          each CHV1 controlled operation (force_chv1) and if we are not
1567          using the keypad (PINVALUE == NULL). */
1568       rc = iso7816_verify (app->slot, 0x81, pinvalue, strlen (pinvalue));
1569       if (gpg_err_code (rc) == GPG_ERR_BAD_PIN)
1570         rc = gpg_error (GPG_ERR_PIN_NOT_SYNCED);
1571       if (rc)
1572         {
1573           log_error (_("verify CHV%d failed: %s\n"), 1, gpg_strerror (rc));
1574           flush_cache_after_error (app);
1575         }
1576       else
1577         app->did_chv1 = 1;
1578     }
1579   xfree (pinvalue);
1580
1581   return rc;
1582 }
1583
1584
1585 /* Verify CHV3 if required. */
1586 static gpg_error_t
1587 verify_chv3 (app_t app,
1588              gpg_error_t (*pincb)(void*, const char *, char **),
1589              void *pincb_arg)
1590 {
1591   int rc = 0;
1592
1593 #if GNUPG_MAJOR_VERSION != 1
1594   if (!opt.allow_admin)
1595     {
1596       log_info (_("access to admin commands is not configured\n"));
1597       return gpg_error (GPG_ERR_EACCES);
1598     }
1599 #endif
1600       
1601   if (!app->did_chv3) 
1602     {
1603       void *relptr;
1604       unsigned char *value;
1605       size_t valuelen;
1606       iso7816_pininfo_t pininfo;
1607       int minlen = 8;
1608       int remaining;
1609       char *prompt_buffer = NULL;
1610       const char *prompt;
1611
1612       memset (&pininfo, 0, sizeof pininfo);
1613       pininfo.mode = 1;
1614       pininfo.minlen = minlen;
1615
1616       relptr = get_one_do (app, 0x00C4, &value, &valuelen, NULL);
1617       if (!relptr || valuelen < 7)
1618         {
1619           log_error (_("error retrieving CHV status from card\n"));
1620           xfree (relptr);
1621           return gpg_error (GPG_ERR_CARD);
1622         }
1623       if (value[6] == 0)
1624         {
1625           log_info (_("card is permanently locked!\n"));
1626           xfree (relptr);
1627           return gpg_error (GPG_ERR_BAD_PIN);
1628         }
1629       remaining = value[6];
1630       xfree (relptr);
1631
1632       log_info(_("%d Admin PIN attempts remaining before card"
1633                  " is permanently locked\n"), remaining);
1634
1635       if (remaining < 3)
1636         {
1637           /* TRANSLATORS: Do not translate the "|A|" prefix but keep
1638              it at the start of the string.  Use %%0A to force a
1639              lienfeed.  */
1640 #define PROMPTSTRING  _("|A|Please enter the Admin PIN%%0A" \
1641                         "[remaining attempts: %d]")
1642           size_t promptsize = strlen (PROMPTSTRING) + 50;
1643           
1644           prompt_buffer = xtrymalloc (promptsize);
1645           if (!prompt_buffer)
1646             return gpg_error_from_syserror ();
1647           snprintf (prompt_buffer, promptsize-1, PROMPTSTRING, remaining);
1648           prompt = prompt_buffer;
1649 #undef PROMPTSTRING
1650         }
1651       else
1652         prompt = _("|A|Please enter the Admin PIN");
1653
1654       if (!opt.disable_keypad
1655           && !iso7816_check_keypad (app->slot, ISO7816_VERIFY, &pininfo) )
1656         {
1657           /* The reader supports the verify command through the keypad. */
1658           rc = pincb (pincb_arg, prompt, NULL); 
1659           prompt = NULL;
1660           xfree (prompt_buffer);
1661           prompt_buffer = NULL;
1662           if (rc)
1663             {
1664               log_info (_("PIN callback returned error: %s\n"),
1665                         gpg_strerror (rc));
1666               return rc;
1667             }
1668           rc = iso7816_verify_kp (app->slot, 0x83, "", 0, &pininfo); 
1669           /* Dismiss the prompt. */
1670           pincb (pincb_arg, NULL, NULL);
1671         }
1672       else
1673         {
1674           char *pinvalue;
1675
1676           rc = pincb (pincb_arg, prompt, &pinvalue); 
1677           prompt = NULL;
1678           xfree (prompt_buffer);
1679           prompt_buffer = NULL;
1680           if (rc)
1681             {
1682               log_info (_("PIN callback returned error: %s\n"),
1683                         gpg_strerror (rc));
1684               return rc;
1685             }
1686           
1687           if (strlen (pinvalue) < minlen)
1688             {
1689               log_error (_("PIN for CHV%d is too short;"
1690                            " minimum length is %d\n"), 3, minlen);
1691               xfree (pinvalue);
1692               return gpg_error (GPG_ERR_BAD_PIN);
1693             }
1694           
1695           rc = iso7816_verify (app->slot, 0x83, pinvalue, strlen (pinvalue));
1696           xfree (pinvalue);
1697         }
1698       
1699       if (rc)
1700         {
1701           log_error (_("verify CHV%d failed: %s\n"), 3, gpg_strerror (rc));
1702           flush_cache_after_error (app);
1703           return rc;
1704         }
1705       app->did_chv3 = 1;
1706     }
1707   return rc;
1708 }
1709
1710
1711 /* Handle the SETATTR operation. All arguments are already basically
1712    checked. */
1713 static gpg_error_t 
1714 do_setattr (app_t app, const char *name,
1715             gpg_error_t (*pincb)(void*, const char *, char **),
1716             void *pincb_arg,
1717             const unsigned char *value, size_t valuelen)
1718 {
1719   gpg_error_t rc;
1720   int idx;
1721   static struct {
1722     const char *name;
1723     int tag;
1724     int need_chv;
1725     int special;
1726     unsigned int need_v2:1;
1727   } table[] = {
1728     { "DISP-NAME",    0x005B, 3 },
1729     { "LOGIN-DATA",   0x005E, 3, 2 },
1730     { "DISP-LANG",    0x5F2D, 3 },
1731     { "DISP-SEX",     0x5F35, 3 },
1732     { "PUBKEY-URL",   0x5F50, 3 },
1733     { "CHV-STATUS-1", 0x00C4, 3, 1 },
1734     { "CA-FPR-1",     0x00CA, 3 },
1735     { "CA-FPR-2",     0x00CB, 3 },
1736     { "CA-FPR-3",     0x00CC, 3 },
1737     { "PRIVATE-DO-1", 0x0101, 2 },
1738     { "PRIVATE-DO-2", 0x0102, 3 },
1739     { "PRIVATE-DO-3", 0x0103, 2 },
1740     { "PRIVATE-DO-4", 0x0104, 3 },
1741     { "CERT-3",       0x7F21, 3, 0, 1 },
1742     { "SM-KEY-ENC",   0x00D1, 3, 0, 1 },
1743     { "SM-KEY-MAC",   0x00D2, 3, 0, 1 },
1744     { NULL, 0 }
1745   };
1746   int exmode;
1747
1748   for (idx=0; table[idx].name && strcmp (table[idx].name, name); idx++)
1749     ;
1750   if (!table[idx].name)
1751     return gpg_error (GPG_ERR_INV_NAME); 
1752   if (table[idx].need_v2 && !app->app_local->extcap.is_v2)
1753     return gpg_error (GPG_ERR_NOT_SUPPORTED); /* Not yet supported.  */
1754
1755   switch (table[idx].need_chv)
1756     {
1757     case 2:
1758       rc = verify_chv2 (app, pincb, pincb_arg);
1759       break;
1760     case 3:
1761       rc = verify_chv3 (app, pincb, pincb_arg);
1762       break;
1763     default:
1764       rc = 0;
1765     }
1766   if (rc)
1767     return rc;
1768
1769   /* Flush the cache before writing it, so that the next get operation
1770      will reread the data from the card and thus get synced in case of
1771      errors (e.g. data truncated by the card). */
1772   flush_cache_item (app, table[idx].tag);
1773   /* For command chaining we use a value of 254 for this card.  */
1774   if (app->app_local->cardcap.cmd_chaining && valuelen > 254)
1775     exmode = -254;
1776   else
1777     exmode = 0;
1778   rc = iso7816_put_data (app->slot, exmode, table[idx].tag, value, valuelen);
1779   if (rc)
1780     log_error ("failed to set `%s': %s\n", table[idx].name, gpg_strerror (rc));
1781
1782   if (table[idx].special == 1)
1783     app->force_chv1 = (valuelen && *value == 0);
1784   else if (table[idx].special == 2)
1785     parse_login_data (app);
1786
1787   return rc;
1788 }
1789
1790
1791 /* Handle the WRITECERT command for OpenPGP.  This rites the standard
1792    certifciate to the card; CERTID needs to be set to "OPENPGP.3".
1793    PINCB and PINCB_ARG are the usual arguments for the pinentry
1794    callback.  */
1795 static gpg_error_t
1796 do_writecert (app_t app, ctrl_t ctrl,
1797               const char *certidstr, 
1798               gpg_error_t (*pincb)(void*, const char *, char **),
1799               void *pincb_arg,
1800               const unsigned char *certdata, size_t certdatalen)
1801 {
1802   (void)ctrl;
1803 #if GNUPG_MAJOR_VERSION > 1
1804   if (strcmp (certidstr, "OPENPGP.3"))
1805     return gpg_error (GPG_ERR_INV_ID);
1806   if (!certdata || !certdatalen)
1807     return gpg_error (GPG_ERR_INV_ARG);
1808   if (!app->app_local->extcap.is_v2)
1809     return gpg_error (GPG_ERR_NOT_SUPPORTED);
1810   if (certdatalen > app->app_local->extcap.max_certlen_3)
1811     return gpg_error (GPG_ERR_TOO_LARGE);
1812   return do_setattr (app, "CERT-3", pincb, pincb_arg, certdata, certdatalen);
1813 #else
1814   return gpg_error (GPG_ERR_NOT_IMPLEMENTED);
1815 #endif
1816 }
1817
1818
1819
1820 /* Handle the PASSWD command. */
1821 static gpg_error_t 
1822 do_change_pin (app_t app, ctrl_t ctrl,  const char *chvnostr, 
1823                unsigned int flags,
1824                gpg_error_t (*pincb)(void*, const char *, char **),
1825                void *pincb_arg)
1826 {
1827   int rc = 0;
1828   int chvno = atoi (chvnostr);
1829   char *resetcode = NULL;
1830   char *pinvalue;
1831   int reset_mode = !!(flags & APP_CHANGE_FLAG_RESET);
1832   int set_resetcode = 0;
1833
1834   (void)ctrl;
1835
1836   if (reset_mode && chvno == 3)
1837     {
1838       rc = gpg_error (GPG_ERR_INV_ID);
1839       goto leave;
1840     }
1841   else if (reset_mode || chvno == 3)
1842     {
1843       /* We always require that the PIN is entered. */
1844       app->did_chv3 = 0;
1845       rc = verify_chv3 (app, pincb, pincb_arg);
1846       if (rc)
1847         goto leave;
1848   
1849       if (chvno == 2 && app->app_local->extcap.is_v2)
1850         set_resetcode = 1;
1851     }
1852   else if (chvno == 2 && app->app_local->extcap.is_v2)
1853     {
1854       /* There is no PW2 for v2 cards.  We use this condition to allow
1855          a PW reset using the Reset Code.  */
1856       void *relptr;
1857       unsigned char *value;
1858       size_t valuelen;
1859       int remaining;
1860
1861       relptr = get_one_do (app, 0x00C4, &value, &valuelen, NULL);
1862       if (!relptr || valuelen < 7)
1863         {
1864           log_error (_("error retrieving CHV status from card\n"));
1865           xfree (relptr);
1866           rc = gpg_error (GPG_ERR_CARD);
1867           goto leave;
1868         }
1869       remaining = value[5];
1870       xfree (relptr);
1871       if (!remaining)
1872         {
1873           log_error (_("Reset Code not or not anymore available\n"));
1874           rc = gpg_error (GPG_ERR_BAD_PIN);
1875           goto leave;
1876         }          
1877
1878       rc = pincb (pincb_arg, _("||Please enter the Reset Code for the card"),
1879                   &resetcode); 
1880       if (rc)
1881         {
1882           log_info (_("PIN callback returned error: %s\n"), gpg_strerror (rc));
1883           goto leave;
1884         }
1885       if (strlen (resetcode) < 8)
1886         {
1887           log_error (_("Reset Code is too short; minimum length is %d\n"), 8);
1888           rc = gpg_error (GPG_ERR_BAD_PIN);
1889           goto leave;
1890         }
1891     }
1892   else if (chvno == 1 || chvno == 2)
1893     {
1894       /* CHV1 and CVH2 should always have the same value, thus we
1895          enforce it here.  */
1896       int save_force = app->force_chv1;
1897
1898       app->force_chv1 = 0;
1899       app->did_chv1 = 0;
1900       app->did_chv2 = 0;
1901       rc = verify_chv2 (app, pincb, pincb_arg);
1902       app->force_chv1 = save_force;
1903       if (rc)
1904         goto leave;
1905     }
1906   else
1907     {
1908       rc = gpg_error (GPG_ERR_INV_ID);
1909       goto leave;
1910     }
1911
1912   if (chvno == 3)
1913     app->did_chv3 = 0;
1914   else
1915     app->did_chv1 = app->did_chv2 = 0;
1916
1917   /* TRANSLATORS: Do not translate the "|*|" prefixes but
1918      keep it at the start of the string.  We need this elsewhere
1919      to get some infos on the string. */
1920   rc = pincb (pincb_arg, 
1921               set_resetcode? _("|RN|New Reset Code") :
1922               chvno == 3? _("|AN|New Admin PIN") : _("|N|New PIN"), 
1923               &pinvalue); 
1924   if (rc)
1925     {
1926       log_error (_("error getting new PIN: %s\n"), gpg_strerror (rc));
1927       goto leave;
1928     }
1929
1930   if (resetcode)
1931     {
1932       char *buffer;
1933
1934       buffer = xtrymalloc (strlen (resetcode) + strlen (pinvalue) + 1);
1935       if (!buffer)
1936         rc = gpg_error_from_syserror ();
1937       else
1938         {
1939           strcpy (stpcpy (buffer, resetcode), pinvalue);
1940           rc = iso7816_reset_retry_counter_with_rc (app->slot, 0x81,
1941                                                     buffer, strlen (buffer));
1942           wipememory (buffer, strlen (buffer));
1943           xfree (buffer);
1944         }
1945     }
1946   else if (set_resetcode)
1947     {
1948       if (strlen (pinvalue) < 8)
1949         {
1950           log_error (_("Reset Code is too short; minimum length is %d\n"), 8);
1951           rc = gpg_error (GPG_ERR_BAD_PIN);
1952         }
1953       else
1954         rc = iso7816_put_data (app->slot, 0, 0xD3,
1955                                pinvalue, strlen (pinvalue));
1956     }
1957   else if (reset_mode)
1958     {
1959       rc = iso7816_reset_retry_counter (app->slot, 0x81,
1960                                         pinvalue, strlen (pinvalue));
1961       if (!rc && !app->app_local->extcap.is_v2)
1962         rc = iso7816_reset_retry_counter (app->slot, 0x82,
1963                                           pinvalue, strlen (pinvalue));
1964     }
1965   else
1966     {
1967       if (chvno == 1 || chvno == 2)
1968         {
1969           rc = iso7816_change_reference_data (app->slot, 0x81, NULL, 0,
1970                                               pinvalue, strlen (pinvalue));
1971           if (!rc && !app->app_local->extcap.is_v2)
1972             rc = iso7816_change_reference_data (app->slot, 0x82, NULL, 0,
1973                                                 pinvalue, strlen (pinvalue));
1974         }
1975       else
1976         rc = iso7816_change_reference_data (app->slot, 0x80 + chvno, NULL, 0,
1977                                             pinvalue, strlen (pinvalue));
1978     }
1979   if (pinvalue)
1980     {
1981       wipememory (pinvalue, strlen (pinvalue));
1982       xfree (pinvalue);
1983     }
1984   if (rc)
1985     flush_cache_after_error (app);
1986
1987  leave:
1988   if (resetcode)
1989     {
1990       wipememory (resetcode, strlen (resetcode));
1991       xfree (resetcode);
1992     }
1993   return rc;
1994 }
1995
1996
1997 /* Check whether a key already exists.  KEYIDX is the index of the key
1998    (0..2).  If FORCE is TRUE a diagnositic will be printed but no
1999    error returned if the key already exists. */
2000 static gpg_error_t
2001 does_key_exist (app_t app, int keyidx, int force)
2002 {
2003   const unsigned char *fpr;
2004   unsigned char *buffer;
2005   size_t buflen, n;
2006   int i;
2007
2008   assert (keyidx >=0 && keyidx <= 2);
2009
2010   if (iso7816_get_data (app->slot, 0x006E, &buffer, &buflen))
2011     {
2012       log_error (_("error reading application data\n"));
2013       return gpg_error (GPG_ERR_GENERAL);
2014     }
2015   fpr = find_tlv (buffer, buflen, 0x00C5, &n);
2016   if (!fpr || n < 60)
2017     {
2018       log_error (_("error reading fingerprint DO\n"));
2019       xfree (buffer);
2020       return gpg_error (GPG_ERR_GENERAL);
2021     }
2022   fpr += 20*keyidx;
2023   for (i=0; i < 20 && !fpr[i]; i++)
2024     ;
2025   xfree (buffer);
2026   if (i!=20 && !force)
2027     {
2028       log_error (_("key already exists\n"));
2029       return gpg_error (GPG_ERR_EEXIST);
2030     }
2031   else if (i!=20)
2032     log_info (_("existing key will be replaced\n"));
2033   else
2034     log_info (_("generating new key\n"));
2035   return 0;
2036 }
2037
2038
2039 /* Create a TLV tag and value and store it at BUFFER.  Return the length
2040    of tag and length.  A LENGTH greater than 65535 is truncated. */
2041 static size_t
2042 add_tlv (unsigned char *buffer, unsigned int tag, size_t length)
2043
2044   unsigned char *p = buffer;
2045
2046   assert (tag <= 0xffff);
2047   if ( tag > 0xff )
2048     *p++ = tag >> 8;
2049   *p++ = tag;
2050   if (length < 128)
2051     *p++ = length;
2052   else if (length < 256)
2053     {
2054       *p++ = 0x81;
2055       *p++ = length;
2056     }
2057   else
2058     {
2059       if (length > 0xffff)
2060         length = 0xffff;
2061       *p++ = 0x82;
2062       *p++ = length >> 8;
2063       *p++ = length;
2064     }
2065
2066   return p - buffer;
2067 }
2068
2069
2070 /* Build the private key template as specified in the OpenPGP specs
2071    v2.0 section 4.3.3.7.  */
2072 static gpg_error_t
2073 build_privkey_template (app_t app, int keyno,
2074                         const unsigned char *rsa_n, size_t rsa_n_len,
2075                         const unsigned char *rsa_e, size_t rsa_e_len,
2076                         const unsigned char *rsa_p, size_t rsa_p_len,
2077                         const unsigned char *rsa_q, size_t rsa_q_len,
2078                         unsigned char **result, size_t *resultlen)
2079 {
2080   size_t rsa_e_reqlen;
2081   unsigned char privkey[7*(1+3)];
2082   size_t privkey_len;
2083   unsigned char exthdr[2+2+3];
2084   size_t exthdr_len;
2085   unsigned char suffix[2+3];
2086   size_t suffix_len;
2087   unsigned char *tp;
2088   size_t datalen;
2089   unsigned char *template;
2090   size_t template_size;
2091
2092   *result = NULL;
2093   *resultlen = 0;
2094
2095   switch (app->app_local->keyattr[keyno].format)
2096     {
2097     case RSA_STD:
2098     case RSA_STD_N:
2099       break;
2100     case RSA_CRT:
2101     case RSA_CRT_N:
2102       return gpg_error (GPG_ERR_NOT_SUPPORTED);
2103
2104     default:
2105       return gpg_error (GPG_ERR_INV_VALUE);
2106     }
2107
2108   /* Get the required length for E.  */
2109   rsa_e_reqlen = app->app_local->keyattr[keyno].e_bits/8;
2110   assert (rsa_e_len <= rsa_e_reqlen);
2111
2112   /* Build the 7f48 cardholder private key template.  */
2113   datalen = 0;
2114   tp = privkey;
2115
2116   tp += add_tlv (tp, 0x91, rsa_e_reqlen);
2117   datalen += rsa_e_reqlen;
2118
2119   tp += add_tlv (tp, 0x92, rsa_p_len);
2120   datalen += rsa_p_len;
2121
2122   tp += add_tlv (tp, 0x93, rsa_q_len);
2123   datalen += rsa_q_len;
2124
2125   if (app->app_local->keyattr[keyno].format == RSA_STD_N
2126       || app->app_local->keyattr[keyno].format == RSA_CRT_N)
2127     {
2128       tp += add_tlv (tp, 0x97, rsa_n_len);
2129       datalen += rsa_n_len;
2130     }
2131   privkey_len = tp - privkey;
2132
2133   /* Build the extended header list without the private key template.  */
2134   tp = exthdr;
2135   *tp++ = keyno ==0 ? 0xb6 : keyno == 1? 0xb8 : 0xa4;
2136   *tp++ = 0;
2137   tp += add_tlv (tp, 0x7f48, privkey_len);
2138   exthdr_len = tp - exthdr;
2139
2140   /* Build the 5f48 suffix of the data.  */
2141   tp = suffix;
2142   tp += add_tlv (tp, 0x5f48, datalen);
2143   suffix_len = tp - suffix;
2144
2145   /* Now concatenate everything.  */
2146   template_size = (1 + 3   /* 0x4d and len. */
2147                    + exthdr_len
2148                    + privkey_len
2149                    + suffix_len
2150                    + datalen);
2151   tp = template = xtrymalloc_secure (template_size);
2152   if (!template)
2153     return gpg_error_from_syserror ();
2154
2155   tp += add_tlv (tp, 0x4d, exthdr_len + privkey_len + suffix_len + datalen);
2156   memcpy (tp, exthdr, exthdr_len);
2157   tp += exthdr_len;
2158   memcpy (tp, privkey, privkey_len);
2159   tp += privkey_len;
2160   memcpy (tp, suffix, suffix_len);
2161   tp += suffix_len;
2162
2163   memcpy (tp, rsa_e, rsa_e_len);
2164   if (rsa_e_len < rsa_e_reqlen)
2165     {
2166       /* Right justify E. */
2167       memmove (tp + rsa_e_reqlen - rsa_e_len, tp, rsa_e_len);
2168       memset (tp, 0, rsa_e_reqlen - rsa_e_len);
2169     }                 
2170   tp += rsa_e_reqlen;
2171       
2172   memcpy (tp, rsa_p, rsa_p_len);
2173   tp += rsa_p_len;
2174       
2175   memcpy (tp, rsa_q, rsa_q_len);
2176   tp += rsa_q_len;
2177   
2178   if (app->app_local->keyattr[keyno].format == RSA_STD_N
2179       || app->app_local->keyattr[keyno].format == RSA_CRT_N)
2180     {
2181       memcpy (tp, rsa_n, rsa_n_len);
2182       tp += rsa_n_len;
2183     }
2184
2185   /* Sanity check.  We don't know the exact length because we
2186      allocated 3 bytes for the first length header.  */
2187   assert (tp - template <= template_size);
2188
2189   *result = template;
2190   *resultlen = tp - template;
2191   return 0;
2192 }
2193
2194
2195
2196 /* Handle the WRITEKEY command for OpenPGP.  This function expects a
2197    canonical encoded S-expression with the secret key in KEYDATA and
2198    its length (for assertions) in KEYDATALEN.  KEYID needs to be the
2199    usual keyid which for OpenPGP is the string "OPENPGP.n" with
2200    n=1,2,3.  Bit 0 of FLAGS indicates whether an existing key shall
2201    get overwritten.  PINCB and PINCB_ARG are the usual arguments for
2202    the pinentry callback.  */
2203 static gpg_error_t
2204 do_writekey (app_t app, ctrl_t ctrl,
2205              const char *keyid, unsigned int flags,
2206              gpg_error_t (*pincb)(void*, const char *, char **),
2207              void *pincb_arg,
2208              const unsigned char *keydata, size_t keydatalen)
2209 {
2210   gpg_error_t err;
2211   int force = (flags & 1);
2212   int keyno;
2213   const unsigned char *buf, *tok;
2214   size_t buflen, toklen;
2215   int depth, last_depth1, last_depth2;
2216   const unsigned char *rsa_n = NULL;
2217   const unsigned char *rsa_e = NULL;
2218   const unsigned char *rsa_p = NULL;
2219   const unsigned char *rsa_q = NULL;
2220   size_t rsa_n_len, rsa_e_len, rsa_p_len, rsa_q_len;
2221   unsigned int nbits;
2222   unsigned int maxbits;
2223   unsigned char *template = NULL;
2224   unsigned char *tp;
2225   size_t template_len;
2226   unsigned char fprbuf[20];
2227   u32 created_at = 0;
2228
2229   (void)ctrl;
2230
2231   if (!strcmp (keyid, "OPENPGP.1"))
2232     keyno = 0;
2233   else if (!strcmp (keyid, "OPENPGP.2"))
2234     keyno = 1;
2235   else if (!strcmp (keyid, "OPENPGP.3"))
2236     keyno = 2;
2237   else
2238     return gpg_error (GPG_ERR_INV_ID);
2239   
2240   err = does_key_exist (app, keyno, force);
2241   if (err)
2242     return err;
2243
2244
2245   /* 
2246      Parse the S-expression
2247    */
2248   buf = keydata;
2249   buflen = keydatalen;
2250   depth = 0;
2251   if ((err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen)))
2252     goto leave;
2253   if ((err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen)))
2254     goto leave;
2255   if (!tok || toklen != 11 || memcmp ("private-key", tok, toklen))
2256     {
2257       if (!tok)
2258         ;
2259       else if (toklen == 21 && !memcmp ("protected-private-key", tok, toklen))
2260         log_info ("protected-private-key passed to writekey\n");
2261       else if (toklen == 20 && !memcmp ("shadowed-private-key", tok, toklen))
2262         log_info ("shadowed-private-key passed to writekey\n");
2263       err = gpg_error (GPG_ERR_BAD_SECKEY);
2264       goto leave;
2265     }
2266   if ((err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen)))
2267     goto leave;
2268   if ((err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen)))
2269     goto leave;
2270   if (!tok || toklen != 3 || memcmp ("rsa", tok, toklen))
2271     {
2272       err = gpg_error (GPG_ERR_WRONG_PUBKEY_ALGO);
2273       goto leave;
2274     }
2275   last_depth1 = depth;
2276   while (!(err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen))
2277          && depth && depth >= last_depth1)
2278     {
2279       if (tok)
2280         {
2281           err = gpg_error (GPG_ERR_UNKNOWN_SEXP);
2282           goto leave;
2283         }
2284       if ((err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen)))
2285         goto leave;
2286       if (tok && toklen == 1)
2287         {
2288           const unsigned char **mpi;
2289           size_t *mpi_len;
2290
2291           switch (*tok)
2292             {
2293             case 'n': mpi = &rsa_n; mpi_len = &rsa_n_len; break; 
2294             case 'e': mpi = &rsa_e; mpi_len = &rsa_e_len; break; 
2295             case 'p': mpi = &rsa_p; mpi_len = &rsa_p_len; break; 
2296             case 'q': mpi = &rsa_q; mpi_len = &rsa_q_len;break; 
2297             default: mpi = NULL;  mpi_len = NULL; break;
2298             }
2299           if (mpi && *mpi)
2300             {
2301               err = gpg_error (GPG_ERR_DUP_VALUE);
2302               goto leave;
2303             }
2304           if ((err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen)))
2305             goto leave;
2306           if (tok && mpi)
2307             {
2308               /* Strip off leading zero bytes and save. */
2309               for (;toklen && !*tok; toklen--, tok++)
2310                 ;
2311               *mpi = tok;
2312               *mpi_len = toklen;
2313             }
2314         }
2315       /* Skip until end of list. */
2316       last_depth2 = depth;
2317       while (!(err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen))
2318              && depth && depth >= last_depth2)
2319         ;
2320       if (err)
2321         goto leave;
2322     }
2323   /* Parse other attributes. */
2324   last_depth1 = depth;
2325   while (!(err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen))
2326          && depth && depth >= last_depth1)
2327     {
2328       if (tok)
2329         {
2330           err = gpg_error (GPG_ERR_UNKNOWN_SEXP);
2331           goto leave;
2332         }
2333       if ((err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen)))
2334         goto leave;
2335       if (tok && toklen == 10 && !memcmp ("created-at", tok, toklen))
2336         {
2337           if ((err = parse_sexp (&buf,&buflen,&depth,&tok,&toklen)))
2338             goto leave;
2339           if (tok)
2340             {
2341               for (created_at=0; toklen && *tok && *tok >= '0' && *tok <= '9';
2342                    tok++, toklen--)
2343                 created_at = created_at*10 + (*tok - '0');
2344             }
2345         }
2346       /* Skip until end of list. */
2347       last_depth2 = depth;
2348       while (!(err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen))
2349              && depth && depth >= last_depth2)
2350         ;
2351       if (err)
2352         goto leave;
2353     }
2354
2355
2356   /* Check that we have all parameters and that they match the card
2357      description. */
2358   if (!created_at)
2359     {
2360       log_error (_("creation timestamp missing\n"));
2361       err = gpg_error (GPG_ERR_INV_VALUE);
2362       goto leave;
2363     }
2364
2365   maxbits = app->app_local->keyattr[keyno].n_bits;
2366   nbits = rsa_n? count_bits (rsa_n, rsa_n_len) : 0;
2367   if (nbits != maxbits)
2368     {
2369       log_error (_("RSA modulus missing or not of size %d bits\n"), 
2370                  (int)maxbits);
2371       err = gpg_error (GPG_ERR_BAD_SECKEY);
2372       goto leave;
2373     }
2374
2375   maxbits = app->app_local->keyattr[keyno].e_bits;
2376   if (maxbits > 32 && !app->app_local->extcap.is_v2)
2377     maxbits = 32; /* Our code for v1 does only support 32 bits.  */
2378   nbits = rsa_e? count_bits (rsa_e, rsa_e_len) : 0;
2379   if (nbits < 2 || nbits > maxbits)
2380     {
2381       log_error (_("RSA public exponent missing or larger than %d bits\n"),
2382                  (int)maxbits);
2383       err = gpg_error (GPG_ERR_BAD_SECKEY);
2384       goto leave;
2385     }
2386
2387   maxbits = app->app_local->keyattr[keyno].n_bits/2;
2388   nbits = rsa_p? count_bits (rsa_p, rsa_p_len) : 0;
2389   if (nbits != maxbits)
2390     {
2391       log_error (_("RSA prime %s missing or not of size %d bits\n"), 
2392                  "P", (int)maxbits);
2393       err = gpg_error (GPG_ERR_BAD_SECKEY);
2394       goto leave;
2395     }
2396   nbits = rsa_q? count_bits (rsa_q, rsa_q_len) : 0;
2397   if (nbits != maxbits)
2398     {
2399       log_error (_("RSA prime %s missing or not of size %d bits\n"), 
2400                  "Q", (int)maxbits);
2401       err = gpg_error (GPG_ERR_BAD_SECKEY);
2402       goto leave;
2403     }
2404   
2405   /* We need to remove the cached public key.  */
2406   xfree (app->app_local->pk[keyno].key);
2407   app->app_local->pk[keyno].key = NULL;
2408   app->app_local->pk[keyno].keylen = 0;
2409   app->app_local->pk[keyno].read_done = 0;
2410
2411
2412   if (app->app_local->extcap.is_v2)
2413     {
2414       /* Build the private key template as described in section 4.3.3.7 of
2415          the OpenPGP card specs version 2.0.  */
2416       int exmode;
2417  
2418       err = build_privkey_template (app, keyno,
2419                                     rsa_n, rsa_n_len,
2420                                     rsa_e, rsa_e_len,
2421                                     rsa_p, rsa_p_len,
2422                                     rsa_q, rsa_q_len,
2423                                     &template, &template_len);
2424       if (err)
2425         goto leave;
2426
2427       /* Prepare for storing the key.  */
2428       err = verify_chv3 (app, pincb, pincb_arg);
2429       if (err)
2430         goto leave;
2431
2432       /* Store the key. */
2433       if (app->app_local->cardcap.cmd_chaining && template_len > 254)
2434         exmode = -254;
2435       else
2436         exmode = 0;
2437       err = iso7816_put_data_odd (app->slot, exmode, 0x3fff,
2438                                   template, template_len);
2439     }
2440   else
2441     {
2442       /* Build the private key template as described in section 4.3.3.6 of
2443          the OpenPGP card specs version 1.1:
2444          0xC0   <length> public exponent
2445          0xC1   <length> prime p 
2446          0xC2   <length> prime q 
2447       */
2448       assert (rsa_e_len <= 4);
2449       template_len = (1 + 1 + 4
2450                       + 1 + 1 + rsa_p_len
2451                       + 1 + 1 + rsa_q_len);
2452       template = tp = xtrymalloc_secure (template_len);
2453       if (!template)
2454         {
2455           err = gpg_error_from_syserror ();
2456           goto leave;
2457         }
2458       *tp++ = 0xC0;
2459       *tp++ = 4;
2460       memcpy (tp, rsa_e, rsa_e_len);
2461       if (rsa_e_len < 4)
2462         {
2463           /* Right justify E. */
2464           memmove (tp+4-rsa_e_len, tp, rsa_e_len);
2465           memset (tp, 0, 4-rsa_e_len);
2466         }                 
2467       tp += 4;
2468       
2469       *tp++ = 0xC1;
2470       *tp++ = rsa_p_len;
2471       memcpy (tp, rsa_p, rsa_p_len);
2472       tp += rsa_p_len;
2473       
2474       *tp++ = 0xC2;
2475       *tp++ = rsa_q_len;
2476       memcpy (tp, rsa_q, rsa_q_len);
2477       tp += rsa_q_len;
2478       
2479       assert (tp - template == template_len);
2480       
2481       /* Prepare for storing the key.  */
2482       err = verify_chv3 (app, pincb, pincb_arg);
2483       if (err)
2484         goto leave;
2485
2486       /* Store the key. */
2487       err = iso7816_put_data (app->slot, 0,
2488                               (app->card_version > 0x0007? 0xE0:0xE9)+keyno,
2489                               template, template_len);
2490     }
2491   if (err)
2492     {
2493       log_error (_("failed to store the key: %s\n"), gpg_strerror (err));
2494       goto leave;
2495     }
2496  
2497   err = store_fpr (app->slot, keyno, created_at,
2498                   rsa_n, rsa_n_len, rsa_e, rsa_e_len,
2499                   fprbuf, app->card_version);
2500   if (err)
2501     goto leave;
2502
2503
2504  leave:
2505   xfree (template);
2506   return err;
2507 }
2508
2509
2510 /* Handle the GENKEY command. */
2511 static gpg_error_t 
2512 do_genkey (app_t app, ctrl_t ctrl,  const char *keynostr, unsigned int flags,
2513            time_t createtime,
2514            gpg_error_t (*pincb)(void*, const char *, char **),
2515            void *pincb_arg)
2516 {
2517   int rc;
2518   char numbuf[30];
2519   unsigned char fprbuf[20];
2520   const unsigned char *keydata, *m, *e;
2521   unsigned char *buffer = NULL;
2522   size_t buflen, keydatalen, mlen, elen;
2523   time_t created_at;
2524   int keyno = atoi (keynostr);
2525   int force = (flags & 1);
2526   time_t start_at;
2527
2528   if (keyno < 1 || keyno > 3)
2529     return gpg_error (GPG_ERR_INV_ID);
2530   keyno--;
2531
2532   /* We flush the cache to increase the traffic before a key
2533      generation.  This _might_ help a card to gather more entropy. */
2534   flush_cache (app);
2535
2536   /* Obviously we need to remove the cached public key.  */
2537   xfree (app->app_local->pk[keyno].key);
2538   app->app_local->pk[keyno].key = NULL;
2539   app->app_local->pk[keyno].keylen = 0;
2540   app->app_local->pk[keyno].read_done = 0;
2541
2542   /* Check whether a key already exists.  */
2543   rc = does_key_exist (app, keyno, force);
2544   if (rc)
2545     return rc;
2546
2547   /* Prepare for key generation by verifying the Admin PIN.  */
2548   rc = verify_chv3 (app, pincb, pincb_arg);
2549   if (rc)
2550     goto leave;
2551    
2552 #if 1
2553   log_info (_("please wait while key is being generated ...\n"));
2554   start_at = time (NULL);
2555   rc = iso7816_generate_keypair 
2556 #else
2557 # warning key generation temporary replaced by reading an existing key.
2558   rc = iso7816_read_public_key
2559 #endif
2560     (app->slot, (const unsigned char*)(keyno == 0? "\xB6" :
2561                                        keyno == 1? "\xB8" : "\xA4"),
2562      2,
2563      &buffer, &buflen);
2564   if (rc)
2565     {
2566       rc = gpg_error (GPG_ERR_CARD);
2567       log_error (_("generating key failed\n"));
2568       goto leave;
2569     }
2570   log_info (_("key generation completed (%d seconds)\n"),
2571             (int)(time (NULL) - start_at));
2572   keydata = find_tlv (buffer, buflen, 0x7F49, &keydatalen);
2573   if (!keydata)
2574     {
2575       rc = gpg_error (GPG_ERR_CARD);
2576       log_error (_("response does not contain the public key data\n"));
2577       goto leave;
2578     }
2579  
2580   m = find_tlv (keydata, keydatalen, 0x0081, &mlen);
2581   if (!m)
2582     {
2583       rc = gpg_error (GPG_ERR_CARD);
2584       log_error (_("response does not contain the RSA modulus\n"));
2585       goto leave;
2586     }
2587 /*    log_printhex ("RSA n:", m, mlen); */
2588   send_key_data (ctrl, "n", m, mlen);
2589
2590   e = find_tlv (keydata, keydatalen, 0x0082, &elen);
2591   if (!e)
2592     {
2593       rc = gpg_error (GPG_ERR_CARD);
2594       log_error (_("response does not contain the RSA public exponent\n"));
2595       goto leave;
2596     }
2597 /*    log_printhex ("RSA e:", e, elen); */
2598   send_key_data (ctrl, "e", e, elen);
2599
2600   created_at = createtime? createtime : gnupg_get_time ();
2601   sprintf (numbuf, "%lu", (unsigned long)created_at);
2602   send_status_info (ctrl, "KEY-CREATED-AT",
2603                     numbuf, (size_t)strlen(numbuf), NULL, 0);
2604
2605   rc = store_fpr (app->slot, keyno, (u32)created_at,
2606                   m, mlen, e, elen, fprbuf, app->card_version);
2607   if (rc)
2608     goto leave;
2609   send_fpr_if_not_null (ctrl, "KEY-FPR", -1, fprbuf);
2610
2611
2612  leave:
2613   xfree (buffer);
2614   return rc;
2615 }
2616
2617
2618 static unsigned long
2619 convert_sig_counter_value (const unsigned char *value, size_t valuelen)
2620 {
2621   unsigned long ul;
2622
2623   if (valuelen == 3 )
2624     ul = (value[0] << 16) | (value[1] << 8) | value[2];
2625   else
2626     {
2627       log_error (_("invalid structure of OpenPGP card (DO 0x93)\n"));
2628       ul = 0;
2629     }
2630   return ul;
2631 }
2632
2633 static unsigned long
2634 get_sig_counter (app_t app)
2635 {
2636   void *relptr;
2637   unsigned char *value;
2638   size_t valuelen;
2639   unsigned long ul;
2640
2641   relptr = get_one_do (app, 0x0093, &value, &valuelen, NULL);
2642   if (!relptr)
2643     return 0;
2644   ul = convert_sig_counter_value (value, valuelen);
2645   xfree (relptr);
2646   return ul;
2647 }
2648
2649 static gpg_error_t
2650 compare_fingerprint (app_t app, int keyno, unsigned char *sha1fpr)
2651 {
2652   const unsigned char *fpr;
2653   unsigned char *buffer;
2654   size_t buflen, n;
2655   int rc, i;
2656   
2657   assert (keyno >= 1 && keyno <= 3);
2658
2659   rc = get_cached_data (app, 0x006E, &buffer, &buflen, 0);
2660   if (rc)
2661     {
2662       log_error (_("error reading application data\n"));
2663       return gpg_error (GPG_ERR_GENERAL);
2664     }
2665   fpr = find_tlv (buffer, buflen, 0x00C5, &n);
2666   if (!fpr || n != 60)
2667     {
2668       xfree (buffer);
2669       log_error (_("error reading fingerprint DO\n"));
2670       return gpg_error (GPG_ERR_GENERAL);
2671     }
2672   fpr += (keyno-1)*20;
2673   for (i=0; i < 20; i++)
2674     if (sha1fpr[i] != fpr[i])
2675       {
2676         xfree (buffer);
2677         log_info (_("fingerprint on card does not match requested one\n"));
2678         return gpg_error (GPG_ERR_WRONG_SECKEY);
2679       }
2680   xfree (buffer);
2681   return 0;
2682 }
2683
2684
2685   /* If a fingerprint has been specified check it against the one on
2686      the card.  This is allows for a meaningful error message in case
2687      the key on the card has been replaced but the shadow information
2688      known to gpg was not updated.  If there is no fingerprint we
2689      assume that this is okay. */
2690 static gpg_error_t
2691 check_against_given_fingerprint (app_t app, const char *fpr, int keyno)
2692 {
2693   unsigned char tmp[20];
2694   const char *s;
2695   int n;
2696
2697   for (s=fpr, n=0; hexdigitp (s); s++, n++)
2698     ;
2699   if (n != 40)
2700     return gpg_error (GPG_ERR_INV_ID);
2701   else if (!*s)
2702     ; /* okay */
2703   else
2704     return gpg_error (GPG_ERR_INV_ID);
2705
2706   for (s=fpr, n=0; n < 20; s += 2, n++)
2707         tmp[n] = xtoi_2 (s);
2708   return compare_fingerprint (app, keyno, tmp);
2709 }
2710
2711
2712
2713 /* Compute a digital signature on INDATA which is expected to be the
2714    raw message digest. For this application the KEYIDSTR consists of
2715    the serialnumber and the fingerprint delimited by a slash.
2716
2717    Note that this function may return the error code
2718    GPG_ERR_WRONG_CARD to indicate that the card currently present does
2719    not match the one required for the requested action (e.g. the
2720    serial number does not match). 
2721    
2722    As a special feature a KEYIDSTR of "OPENPGP.3" redirects the
2723    operation to the auth command.
2724 */
2725 static gpg_error_t 
2726 do_sign (app_t app, const char *keyidstr, int hashalgo,
2727          gpg_error_t (*pincb)(void*, const char *, char **),
2728          void *pincb_arg,
2729          const void *indata, size_t indatalen,
2730          unsigned char **outdata, size_t *outdatalen )
2731 {
2732   static unsigned char rmd160_prefix[15] = /* Object ID is 1.3.36.3.2.1 */
2733     { 0x30, 0x21, 0x30, 0x09, 0x06, 0x05, 0x2b, 0x24, 0x03,
2734       0x02, 0x01, 0x05, 0x00, 0x04, 0x14  };
2735   static unsigned char sha1_prefix[15] =   /* (1.3.14.3.2.26) */
2736     { 0x30, 0x21, 0x30, 0x09, 0x06, 0x05, 0x2b, 0x0e, 0x03,
2737       0x02, 0x1a, 0x05, 0x00, 0x04, 0x14  };
2738   static unsigned char sha224_prefix[19] = /* (2.16.840.1.101.3.4.2.4) */
2739     { 0x30, 0x2D, 0x30, 0x0d, 0x06, 0x09, 0x60, 0x86, 0x48,
2740       0x01, 0x65, 0x03, 0x04, 0x02, 0x04, 0x05, 0x00, 0x04,
2741       0x1C  };
2742   static unsigned char sha256_prefix[19] = /* (2.16.840.1.101.3.4.2.1) */
2743     { 0x30, 0x31, 0x30, 0x0d, 0x06, 0x09, 0x60, 0x86,
2744       0x48, 0x01, 0x65, 0x03, 0x04, 0x02, 0x01, 0x05,
2745       0x00, 0x04, 0x20  };
2746   static unsigned char sha384_prefix[19] = /* (2.16.840.1.101.3.4.2.2) */
2747     { 0x30, 0x41, 0x30, 0x0d, 0x06, 0x09, 0x60, 0x86,
2748       0x48, 0x01, 0x65, 0x03, 0x04, 0x02, 0x02, 0x05,
2749       0x00, 0x04, 0x30  };
2750   static unsigned char sha512_prefix[19] = /* (2.16.840.1.101.3.4.2.3) */
2751     { 0x30, 0x51, 0x30, 0x0d, 0x06, 0x09, 0x60, 0x86,
2752       0x48, 0x01, 0x65, 0x03, 0x04, 0x02, 0x03, 0x05,
2753       0x00, 0x04, 0x40  };
2754   int rc;
2755   unsigned char data[19+64];
2756   size_t datalen;
2757   unsigned char tmp_sn[20]; /* Actually 16 bytes but also for the fpr. */
2758   const char *s;
2759   int n;
2760   const char *fpr = NULL;
2761   unsigned long sigcount;
2762   int use_auth = 0;
2763
2764   if (!keyidstr || !*keyidstr)
2765     return gpg_error (GPG_ERR_INV_VALUE);
2766
2767   /* Strip off known prefixes.  */
2768 #define X(a,b,c,d) \
2769   if (hashalgo == GCRY_MD_ ## a                               \
2770       && (d)                                                  \
2771       && indatalen == sizeof b ## _prefix + (c)               \
2772       && !memcmp (indata, b ## _prefix, sizeof b ## _prefix)) \
2773     {                                                         \
2774       indata = (const char*)indata + sizeof b ## _prefix;     \
2775       indatalen -= sizeof b ## _prefix;                       \
2776     }                                                         
2777
2778   if (indatalen == 20)
2779     ;  /* Assume a plain SHA-1 or RMD160 digest has been given.  */
2780   else X(SHA1,   sha1,   20, 1)
2781   else X(RMD160, rmd160, 20, 1)
2782   else X(SHA224, sha224, 28, app->app_local->extcap.is_v2)
2783   else X(SHA256, sha256, 32, app->app_local->extcap.is_v2)
2784   else X(SHA384, sha384, 48, app->app_local->extcap.is_v2)
2785   else X(SHA512, sha512, 64, app->app_local->extcap.is_v2)
2786   else if ((indatalen == 28 || indatalen == 32 
2787             || indatalen == 48 || indatalen ==64)
2788            && app->app_local->extcap.is_v2)
2789     ;  /* Assume a plain SHA-3 digest has been given.  */
2790   else
2791     {
2792       log_error (_("card does not support digest algorithm %s\n"),
2793                  gcry_md_algo_name (hashalgo));
2794       /* Or the supplied digest length does not match an algorithm.  */
2795       return gpg_error (GPG_ERR_INV_VALUE);
2796     }
2797 #undef X
2798
2799   /* Check whether an OpenPGP card of any version has been requested. */
2800   if (!strcmp (keyidstr, "OPENPGP.1"))
2801     ;
2802   else if (!strcmp (keyidstr, "OPENPGP.3"))
2803     use_auth = 1;
2804   else if (strlen (keyidstr) < 32 || strncmp (keyidstr, "D27600012401", 12))
2805     return gpg_error (GPG_ERR_INV_ID);
2806   else
2807     {
2808       for (s=keyidstr, n=0; hexdigitp (s); s++, n++)
2809         ;
2810       if (n != 32)
2811         return gpg_error (GPG_ERR_INV_ID);
2812       else if (!*s)
2813         ; /* no fingerprint given: we allow this for now. */
2814       else if (*s == '/')
2815         fpr = s + 1; 
2816       else
2817         return gpg_error (GPG_ERR_INV_ID);
2818
2819       for (s=keyidstr, n=0; n < 16; s += 2, n++)
2820         tmp_sn[n] = xtoi_2 (s);
2821
2822       if (app->serialnolen != 16)
2823         return gpg_error (GPG_ERR_INV_CARD);
2824       if (memcmp (app->serialno, tmp_sn, 16))
2825         return gpg_error (GPG_ERR_WRONG_CARD);
2826     }
2827
2828   /* If a fingerprint has been specified check it against the one on
2829      the card.  This is allows for a meaningful error message in case
2830      the key on the card has been replaced but the shadow information
2831      known to gpg was not updated.  If there is no fingerprint, gpg
2832      will detect a bogus signature anyway due to the
2833      verify-after-signing feature. */
2834   rc = fpr? check_against_given_fingerprint (app, fpr, 1) : 0;
2835   if (rc)
2836     return rc;
2837
2838   /* Concatenate prefix and digest.  */
2839 #define X(a,b,d) \
2840   if (hashalgo == GCRY_MD_ ## a && (d) )                      \
2841     {                                                         \
2842       datalen = sizeof b ## _prefix + indatalen;              \
2843       assert (datalen <= sizeof data);                        \
2844       memcpy (data, b ## _prefix, sizeof b ## _prefix);       \
2845       memcpy (data + sizeof b ## _prefix, indata, indatalen); \
2846     }                                                         
2847
2848   X(SHA1,   sha1,   1)
2849   else X(RMD160, rmd160, 1)
2850   else X(SHA224, sha224, app->app_local->extcap.is_v2)
2851   else X(SHA256, sha256, app->app_local->extcap.is_v2)
2852   else X(SHA384, sha384, app->app_local->extcap.is_v2)
2853   else X(SHA512, sha512, app->app_local->extcap.is_v2)
2854   else 
2855     return gpg_error (GPG_ERR_UNSUPPORTED_ALGORITHM);
2856 #undef X
2857
2858   /* Redirect to the AUTH command if asked to. */
2859   if (use_auth)
2860     {
2861       return do_auth (app, "OPENPGP.3", pincb, pincb_arg,
2862                       data, datalen,
2863                       outdata, outdatalen);
2864     }
2865
2866   /* Show the number of signature done using this key.  */
2867   sigcount = get_sig_counter (app);
2868   log_info (_("signatures created so far: %lu\n"), sigcount);
2869
2870   /* Check CHV if needed.  */
2871   if (!app->did_chv1 || app->force_chv1 ) 
2872     {
2873       char *pinvalue;
2874
2875       rc = verify_a_chv (app, pincb, pincb_arg, 1, sigcount, &pinvalue);
2876       if (rc)
2877         return rc;
2878
2879       app->did_chv1 = 1;
2880
2881       /* For cards with versions < 2 we want to keep CHV1 and CHV2 in
2882          sync, thus we verify CHV2 here using the given PIN.  Cards
2883          with version2 to not have the need for a separate CHV2 and
2884          internally use just one.  Obviously we can't do that if the
2885          keypad has been used. */
2886       if (!app->did_chv2 && pinvalue && !app->app_local->extcap.is_v2)
2887         {
2888           rc = iso7816_verify (app->slot, 0x82, pinvalue, strlen (pinvalue));
2889           if (gpg_err_code (rc) == GPG_ERR_BAD_PIN)
2890             rc = gpg_error (GPG_ERR_PIN_NOT_SYNCED);
2891           if (rc)
2892             {
2893               log_error (_("verify CHV%d failed: %s\n"), 2, gpg_strerror (rc));
2894               xfree (pinvalue);
2895               flush_cache_after_error (app);
2896               return rc;
2897             }
2898           app->did_chv2 = 1;
2899         }
2900       xfree (pinvalue);
2901     }
2902
2903   rc = iso7816_compute_ds (app->slot, data, datalen, outdata, outdatalen);
2904   return rc;
2905 }
2906
2907 /* Compute a digital signature using the INTERNAL AUTHENTICATE command
2908    on INDATA which is expected to be the raw message digest. For this
2909    application the KEYIDSTR consists of the serialnumber and the
2910    fingerprint delimited by a slash.  Optionally the id OPENPGP.3 may
2911    be given.
2912
2913    Note that this function may return the error code
2914    GPG_ERR_WRONG_CARD to indicate that the card currently present does
2915    not match the one required for the requested action (e.g. the
2916    serial number does not match). */
2917 static gpg_error_t 
2918 do_auth (app_t app, const char *keyidstr,
2919          gpg_error_t (*pincb)(void*, const char *, char **),
2920          void *pincb_arg,
2921          const void *indata, size_t indatalen,
2922          unsigned char **outdata, size_t *outdatalen )
2923 {
2924   int rc;
2925   unsigned char tmp_sn[20]; /* Actually 16 but we use it also for the fpr. */
2926   const char *s;
2927   int n;
2928   const char *fpr = NULL;
2929
2930   if (!keyidstr || !*keyidstr)
2931     return gpg_error (GPG_ERR_INV_VALUE);
2932   if (indatalen > 101) /* For a 2048 bit key. */
2933     return gpg_error (GPG_ERR_INV_VALUE);
2934
2935   /* Check whether an OpenPGP card of any version has been requested. */
2936   if (!strcmp (keyidstr, "OPENPGP.3"))
2937     ;
2938   else if (strlen (keyidstr) < 32 || strncmp (keyidstr, "D27600012401", 12))
2939     return gpg_error (GPG_ERR_INV_ID);
2940   else
2941     {
2942       for (s=keyidstr, n=0; hexdigitp (s); s++, n++)
2943         ;
2944       if (n != 32)
2945         return gpg_error (GPG_ERR_INV_ID);
2946       else if (!*s)
2947         ; /* no fingerprint given: we allow this for now. */
2948       else if (*s == '/')
2949         fpr = s + 1; 
2950       else
2951         return gpg_error (GPG_ERR_INV_ID);
2952
2953       for (s=keyidstr, n=0; n < 16; s += 2, n++)
2954         tmp_sn[n] = xtoi_2 (s);
2955       
2956       if (app->serialnolen != 16)
2957         return gpg_error (GPG_ERR_INV_CARD);
2958       if (memcmp (app->serialno, tmp_sn, 16))
2959         return gpg_error (GPG_ERR_WRONG_CARD);
2960     }
2961
2962   /* If a fingerprint has been specified check it against the one on
2963      the card.  This is allows for a meaningful error message in case
2964      the key on the card has been replaced but the shadow information
2965      known to gpg was not updated.  If there is no fingerprint, gpg
2966      will detect a bogus signature anyway due to the
2967      verify-after-signing feature. */
2968   rc = fpr? check_against_given_fingerprint (app, fpr, 3) : 0;
2969   if (rc)
2970     return rc;
2971
2972   rc = verify_chv2 (app, pincb, pincb_arg);
2973   if (!rc)
2974     rc = iso7816_internal_authenticate (app->slot, indata, indatalen,
2975                                         outdata, outdatalen);
2976   return rc;
2977 }
2978
2979
2980 static gpg_error_t 
2981 do_decipher (app_t app, const char *keyidstr,
2982              gpg_error_t (*pincb)(void*, const char *, char **),
2983              void *pincb_arg,
2984              const void *indata, size_t indatalen,
2985              unsigned char **outdata, size_t *outdatalen )
2986 {
2987   int rc;
2988   unsigned char tmp_sn[20]; /* actually 16 but we use it also for the fpr. */
2989   const char *s;
2990   int n;
2991   const char *fpr = NULL;
2992
2993   if (!keyidstr || !*keyidstr || !indatalen)
2994     return gpg_error (GPG_ERR_INV_VALUE);
2995
2996   /* Check whether an OpenPGP card of any version has been requested. */
2997   if (!strcmp (keyidstr, "OPENPGP.2"))
2998     ;
2999   else if (strlen (keyidstr) < 32 || strncmp (keyidstr, "D27600012401", 12))
3000     return gpg_error (GPG_ERR_INV_ID);
3001   else
3002     {
3003       for (s=keyidstr, n=0; hexdigitp (s); s++, n++)
3004         ;
3005       if (n != 32)
3006         return gpg_error (GPG_ERR_INV_ID);
3007       else if (!*s)
3008         ; /* no fingerprint given: we allow this for now. */
3009       else if (*s == '/')
3010         fpr = s + 1; 
3011       else
3012         return gpg_error (GPG_ERR_INV_ID);
3013       
3014       for (s=keyidstr, n=0; n < 16; s += 2, n++)
3015         tmp_sn[n] = xtoi_2 (s);
3016       
3017       if (app->serialnolen != 16)
3018         return gpg_error (GPG_ERR_INV_CARD);
3019       if (memcmp (app->serialno, tmp_sn, 16))
3020         return gpg_error (GPG_ERR_WRONG_CARD);
3021     }
3022
3023   /* If a fingerprint has been specified check it against the one on
3024      the card.  This is allows for a meaningful error message in case
3025      the key on the card has been replaced but the shadow information
3026      known to gpg was not updated.  If there is no fingerprint, the
3027      decryption will won't produce the right plaintext anyway. */
3028   rc = fpr? check_against_given_fingerprint (app, fpr, 2) : 0;
3029   if (rc)
3030     return rc;
3031
3032   rc = verify_chv2 (app, pincb, pincb_arg);
3033   if (!rc)
3034     {
3035       size_t fixuplen;
3036
3037       /* We might encounter a couple of leading zeroes in the
3038          cryptogram.  Due to internal use of MPIs thease leading
3039          zeroes are stripped.  However the OpenPGP card expects
3040          exactly 128 bytes for the cryptogram (for a 1k key).  Thus we
3041          need to fix it up.  We do this for up to 16 leading zero
3042          bytes; a cryptogram with more than this is with a very high
3043          probability anyway broken.  */
3044       if (indatalen >= (128-16) && indatalen < 128)      /* 1024 bit key.  */
3045         fixuplen = 128 - indatalen;
3046       else if (indatalen >= (256-16) && indatalen < 256) /* 2048 bit key.  */
3047         fixuplen = 256 - indatalen;
3048       else if (indatalen >= (192-16) && indatalen < 192) /* 1536 bit key.  */
3049         fixuplen = 192 - indatalen;
3050       else
3051         fixuplen = 0;
3052       if (fixuplen)
3053         {
3054           unsigned char *fixbuf;
3055
3056           /* While we have to prepend stuff anyway, we can also
3057              include the padding byte here so that iso1816_decipher
3058              does not need to do yet another data mangling.  */
3059           fixuplen++;
3060           fixbuf = xtrymalloc (fixuplen + indatalen);
3061           if (!fixbuf)
3062             rc = gpg_error_from_syserror ();
3063           else
3064             {
3065               memset (fixbuf, 0, fixuplen);
3066               memcpy (fixbuf+fixuplen, indata, indatalen);
3067               rc = iso7816_decipher (app->slot, fixbuf, fixuplen+indatalen, -1,
3068                                      outdata, outdatalen);
3069               xfree (fixbuf);
3070             }
3071
3072         }
3073       else
3074         rc = iso7816_decipher (app->slot, indata, indatalen, 0,
3075                                outdata, outdatalen);
3076     }
3077   return rc;
3078 }
3079
3080
3081 /* Perform a simple verify operation for CHV1 and CHV2, so that
3082    further operations won't ask for CHV2 and it is possible to do a
3083    cheap check on the PIN: If there is something wrong with the PIN
3084    entry system, only the regular CHV will get blocked and not the
3085    dangerous CHV3.  KEYIDSTR is the usual card's serial number; an
3086    optional fingerprint part will be ignored.
3087
3088    There is a special mode if the keyidstr is "<serialno>[CHV3]" with
3089    the "[CHV3]" being a literal string:  The Admin Pin is checked if
3090    and only if the retry counter is still at 3. */
3091 static gpg_error_t 
3092 do_check_pin (app_t app, const char *keyidstr,
3093               gpg_error_t (*pincb)(void*, const char *, char **),
3094               void *pincb_arg)
3095 {
3096   unsigned char tmp_sn[20]; 
3097   const char *s;
3098   int n;
3099   int admin_pin = 0;
3100
3101   if (!keyidstr || !*keyidstr)
3102     return gpg_error (GPG_ERR_INV_VALUE);
3103
3104   /* Check whether an OpenPGP card of any version has been requested. */
3105   if (strlen (keyidstr) < 32 || strncmp (keyidstr, "D27600012401", 12))
3106     return gpg_error (GPG_ERR_INV_ID);
3107   
3108   for (s=keyidstr, n=0; hexdigitp (s); s++, n++)
3109     ;
3110   if (n != 32)
3111     return gpg_error (GPG_ERR_INV_ID);
3112   else if (!*s)
3113     ; /* No fingerprint given: we allow this for now. */
3114   else if (*s == '/')
3115     ; /* We ignore a fingerprint. */
3116   else if (!strcmp (s, "[CHV3]") )
3117     admin_pin = 1;
3118   else
3119     return gpg_error (GPG_ERR_INV_ID);
3120
3121   for (s=keyidstr, n=0; n < 16; s += 2, n++)
3122     tmp_sn[n] = xtoi_2 (s);
3123
3124   if (app->serialnolen != 16)
3125     return gpg_error (GPG_ERR_INV_CARD);
3126   if (memcmp (app->serialno, tmp_sn, 16))
3127     return gpg_error (GPG_ERR_WRONG_CARD);
3128
3129   /* Yes, there is a race conditions: The user might pull the card
3130      right here and we won't notice that.  However this is not a
3131      problem and the check above is merely for a graceful failure
3132      between operations. */
3133
3134   if (admin_pin)
3135     {
3136       void *relptr;
3137       unsigned char *value;
3138       size_t valuelen;
3139       int count;
3140       
3141       relptr = get_one_do (app, 0x00C4, &value, &valuelen, NULL);
3142       if (!relptr || valuelen < 7)
3143         {
3144           log_error (_("error retrieving CHV status from card\n"));
3145           xfree (relptr);
3146           return gpg_error (GPG_ERR_CARD);
3147         }
3148       count = value[6];
3149       xfree (relptr);
3150
3151       if (!count)
3152         {
3153           log_info (_("card is permanently locked!\n"));
3154           return gpg_error (GPG_ERR_BAD_PIN);
3155         }
3156       else if (value[6] < 3)
3157         {
3158           log_info (_("verification of Admin PIN is currently prohibited "
3159                       "through this command\n"));
3160           return gpg_error (GPG_ERR_GENERAL);
3161         }
3162
3163       app->did_chv3 = 0; /* Force verification.  */
3164       return verify_chv3 (app, pincb, pincb_arg);
3165     }
3166   else
3167     return verify_chv2 (app, pincb, pincb_arg);
3168 }
3169
3170
3171 /* Show information about card capabilities.  */
3172 static void
3173 show_caps (struct app_local_s *s)
3174 {
3175   log_info ("Version-2 ......: %s\n", s->extcap.is_v2? "yes":"no");
3176   log_info ("Get-Challenge ..: %s", s->extcap.get_challenge? "yes":"no");
3177   if (s->extcap.get_challenge)
3178     log_printf (" (%u bytes max)", s->extcap.max_get_challenge);
3179   log_info ("Key-Import .....: %s\n", s->extcap.key_import? "yes":"no");
3180   log_info ("Change-Force-PW1: %s\n", s->extcap.change_force_chv? "yes":"no");
3181   log_info ("Private-DOs ....: %s\n", s->extcap.private_dos? "yes":"no");
3182   log_info ("Algo-Attr-Change: %s\n", s->extcap.algo_attr_change? "yes":"no");
3183   log_info ("SM-Support .....: %s", s->extcap.sm_supported? "yes":"no");
3184   if (s->extcap.sm_supported)
3185     log_printf (" (%s)", s->extcap.sm_aes128? "AES-128":"3DES");
3186   log_info ("Max-Cert3-Len ..: %u\n", s->extcap.max_certlen_3);
3187   log_info ("Max-Cmd-Data ...: %u\n", s->extcap.max_cmd_data);
3188   log_info ("Max-Rsp-Data ...: %u\n", s->extcap.max_rsp_data);
3189   log_info ("Cmd-Chaining ...: %s\n", s->cardcap.cmd_chaining?"yes":"no");
3190   log_info ("Ext-Lc-Le ......: %s\n", s->cardcap.ext_lc_le?"yes":"no");
3191   log_info ("Status Indicator: %02X\n", s->status_indicator);
3192
3193   log_info ("GnuPG-No-Sync ..: %s\n",  s->flags.no_sync? "yes":"no");
3194   log_info ("GnuPG-Def-PW2 ..: %s\n",  s->flags.def_chv2? "yes":"no");
3195 }
3196
3197
3198 /* Parse the historical bytes in BUFFER of BUFLEN and store them in
3199    APPLOC.  */
3200 static void
3201 parse_historical (struct app_local_s *apploc, 
3202                   const unsigned char * buffer, size_t buflen)
3203 {
3204   /* Example buffer: 00 31 C5 73 C0 01 80 00 90 00  */
3205   if (buflen < 4)
3206     {
3207       log_error ("warning: historical bytes are too short\n");
3208       return; /* Too short.  */
3209     }
3210   if (*buffer)
3211     {
3212       log_error ("warning: bad category indicator in historical bytes\n");
3213       return; 
3214     }
3215   
3216   /* Skip category indicator.  */
3217   buffer++;
3218   buflen--;
3219
3220   /* Get the status indicator.  */
3221   apploc->status_indicator = buffer[buflen-3];
3222   buflen -= 3;
3223
3224   /* Parse the compact TLV.  */
3225   while (buflen)
3226     {
3227       unsigned int tag = (*buffer & 0xf0) >> 4;
3228       unsigned int len = (*buffer & 0x0f);
3229       if (len+1 > buflen)
3230         {
3231           log_error ("warning: bad Compact-TLV in historical bytes\n");
3232           return; /* Error.  */
3233         }
3234       buffer++;
3235       buflen--;
3236       if (tag == 7 && len == 3)
3237         {
3238           /* Card capabilities.  */
3239           apploc->cardcap.cmd_chaining = !!(buffer[2] & 0x80);
3240           apploc->cardcap.ext_lc_le    = !!(buffer[2] & 0x40);
3241         }
3242       buffer += len;
3243       buflen -= len;
3244     }
3245 }
3246
3247
3248 /* Parse and optionally show the algorithm attributes for KEYNO.
3249    KEYNO must be in the range 0..2.  */
3250 static void 
3251 parse_algorithm_attribute (app_t app, int keyno)
3252
3253   unsigned char *buffer;
3254   size_t buflen;
3255   void *relptr;
3256   const char const desc[3][5] = {"sign", "encr", "auth"};
3257
3258   assert (keyno >=0 && keyno <= 2);
3259
3260   app->app_local->keyattr[keyno].n_bits = 0;
3261       
3262   relptr = get_one_do (app, 0xC1+keyno, &buffer, &buflen, NULL);
3263   if (!relptr)
3264     {
3265       log_error ("error reading DO 0x%02X\n", 0xc1+keyno);
3266       return;
3267     }
3268   if (buflen < 1)
3269     {
3270       log_error ("error reading DO 0x%02X\n", 0xc1+keyno);
3271       xfree (relptr);
3272       return;
3273     }
3274
3275   if (opt.verbose)
3276     log_info ("Key-Attr-%s ..: ", desc[keyno]);
3277   if (*buffer == 1 && (buflen == 5 || buflen == 6))
3278     {
3279       app->app_local->keyattr[keyno].n_bits = (buffer[1]<<8 | buffer[2]);
3280       app->app_local->keyattr[keyno].e_bits = (buffer[3]<<8 | buffer[4]);
3281       app->app_local->keyattr[keyno].format = 0;
3282       if (buflen < 6)
3283         app->app_local->keyattr[keyno].format = RSA_STD;
3284       else
3285         app->app_local->keyattr[keyno].format = (buffer[5] == 0? RSA_STD   :
3286                                                  buffer[5] == 1? RSA_STD_N :
3287                                                  buffer[5] == 2? RSA_CRT   :
3288                                                  buffer[5] == 3? RSA_CRT_N : 
3289                                                  RSA_UNKNOWN_FMT);
3290
3291       if (opt.verbose)
3292         log_printf
3293           ("RSA, n=%u, e=%u, fmt=%s\n",
3294            app->app_local->keyattr[keyno].n_bits,
3295            app->app_local->keyattr[keyno].e_bits,
3296            app->app_local->keyattr[keyno].format == RSA_STD?  "std"  :
3297            app->app_local->keyattr[keyno].format == RSA_STD_N?"std+n":
3298            app->app_local->keyattr[keyno].format == RSA_CRT?  "crt"  :
3299            app->app_local->keyattr[keyno].format == RSA_CRT_N?"crt+n":"?");
3300     }
3301   else if (opt.verbose)
3302     log_printhex ("", buffer, buflen);
3303
3304   xfree (relptr);
3305 }
3306
3307 /* Select the OpenPGP application on the card in SLOT.  This function
3308    must be used before any other OpenPGP application functions. */
3309 gpg_error_t
3310 app_select_openpgp (app_t app)
3311 {
3312   static char const aid[] = { 0xD2, 0x76, 0x00, 0x01, 0x24, 0x01 };
3313   int slot = app->slot;
3314   int rc;
3315   unsigned char *buffer;
3316   size_t buflen;
3317   void *relptr;
3318   
3319   /* Note that the card can't cope with P2=0xCO, thus we need to pass a
3320      special flag value. */
3321   rc = iso7816_select_application (slot, aid, sizeof aid, 0x0001);
3322   if (!rc)
3323     {
3324       unsigned int manufacturer;
3325
3326       app->apptype = "OPENPGP";
3327
3328       app->did_chv1 = 0;
3329       app->did_chv2 = 0;
3330       app->did_chv3 = 0;
3331       app->app_local = NULL;
3332
3333       /* The OpenPGP card returns the serial number as part of the
3334          AID; because we prefer to use OpenPGP serial numbers, we
3335          replace a possibly already set one from a EF.GDO with this
3336          one.  Note, that for current OpenPGP cards, no EF.GDO exists
3337          and thus it won't matter at all. */
3338       rc = iso7816_get_data (slot, 0x004F, &buffer, &buflen);
3339       if (rc)
3340         goto leave;
3341       if (opt.verbose)
3342         {
3343           log_info ("AID: ");
3344           log_printhex ("", buffer, buflen);
3345         }
3346
3347       app->card_version = buffer[6] << 8;
3348       app->card_version |= buffer[7];
3349       manufacturer = (buffer[8]<<8 | buffer[9]);
3350
3351       xfree (app->serialno);
3352       app->serialno = buffer;
3353       app->serialnolen = buflen;
3354       buffer = NULL;
3355       app->app_local = xtrycalloc (1, sizeof *app->app_local);
3356       if (!app->app_local)
3357         {
3358           rc = gpg_error (gpg_err_code_from_errno (errno));
3359           goto leave;
3360         }
3361
3362       if (app->card_version >= 0x0200)
3363         app->app_local->extcap.is_v2 = 1;
3364
3365
3366       /* Read the historical bytes.  */
3367       relptr = get_one_do (app, 0x5f52, &buffer, &buflen, NULL);
3368       if (relptr)
3369         {
3370           if (opt.verbose)
3371             {
3372               log_info ("Historical Bytes: ");
3373               log_printhex ("", buffer, buflen);
3374             }
3375           parse_historical (app->app_local, buffer, buflen);
3376           xfree (relptr);
3377         }
3378
3379       /* Read the force-chv1 flag.  */
3380       relptr = get_one_do (app, 0x00C4, &buffer, &buflen, NULL);
3381       if (!relptr)
3382         {
3383           log_error (_("can't access %s - invalid OpenPGP card?\n"),
3384                      "CHV Status Bytes");
3385           goto leave;
3386         }
3387       app->force_chv1 = (buflen && *buffer == 0);
3388       xfree (relptr);
3389
3390       /* Read the extended capabilities.  */
3391       relptr = get_one_do (app, 0x00C0, &buffer, &buflen, NULL);
3392       if (!relptr)
3393         {
3394           log_error (_("can't access %s - invalid OpenPGP card?\n"),
3395                      "Extended Capability Flags" );
3396           goto leave;
3397         }
3398       if (buflen)
3399         {
3400           app->app_local->extcap.sm_supported     = !!(*buffer & 0x80);
3401           app->app_local->extcap.get_challenge    = !!(*buffer & 0x40);
3402           app->app_local->extcap.key_import       = !!(*buffer & 0x20);
3403           app->app_local->extcap.change_force_chv = !!(*buffer & 0x10);
3404           app->app_local->extcap.private_dos      = !!(*buffer & 0x08);
3405           app->app_local->extcap.algo_attr_change = !!(*buffer & 0x04);
3406         }
3407       if (buflen >= 10)
3408         {
3409           /* Available with v2 cards.  */
3410           app->app_local->extcap.sm_aes128     = (buffer[1] == 1);
3411           app->app_local->extcap.max_get_challenge 
3412                                                = (buffer[2] << 8 | buffer[3]);
3413           app->app_local->extcap.max_certlen_3 = (buffer[4] << 8 | buffer[5]);
3414           app->app_local->extcap.max_cmd_data  = (buffer[6] << 8 | buffer[7]);
3415           app->app_local->extcap.max_rsp_data  = (buffer[8] << 8 | buffer[9]);
3416         }
3417       xfree (relptr);
3418
3419       /* Some of the first cards accidently don't set the
3420          CHANGE_FORCE_CHV bit but allow it anyway. */
3421       if (app->card_version <= 0x0100 && manufacturer == 1)
3422         app->app_local->extcap.change_force_chv = 1;
3423
3424       parse_login_data (app);
3425
3426       if (opt.verbose)
3427         show_caps (app->app_local);
3428
3429       parse_algorithm_attribute (app, 0);
3430       parse_algorithm_attribute (app, 1);
3431       parse_algorithm_attribute (app, 2);
3432       
3433       if (opt.verbose > 1)
3434         dump_all_do (slot);
3435
3436       app->fnc.deinit = do_deinit;
3437       app->fnc.learn_status = do_learn_status;
3438       app->fnc.readcert = do_readcert;
3439       app->fnc.readkey = do_readkey;
3440       app->fnc.getattr = do_getattr;
3441       app->fnc.setattr = do_setattr;
3442       app->fnc.writecert = do_writecert;
3443       app->fnc.writekey = do_writekey;
3444       app->fnc.genkey = do_genkey;
3445       app->fnc.sign = do_sign;
3446       app->fnc.auth = do_auth;
3447       app->fnc.decipher = do_decipher;
3448       app->fnc.change_pin = do_change_pin;
3449       app->fnc.check_pin = do_check_pin;
3450    }
3451
3452 leave:
3453   if (rc)
3454     do_deinit (app);
3455   return rc;
3456 }
3457
3458
3459