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