Marked all unused args on non-W32 platforms.
[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   (void)ctrl;
1781 #if GNUPG_MAJOR_VERSION > 1
1782   if (strcmp (certidstr, "OPENPGP.3"))
1783     return gpg_error (GPG_ERR_INV_ID);
1784   if (!certdata || !certdatalen)
1785     return gpg_error (GPG_ERR_INV_ARG);
1786   if (!app->app_local->extcap.is_v2)
1787     return gpg_error (GPG_ERR_NOT_SUPPORTED);
1788   if (certdatalen > app->app_local->extcap.max_certlen_3)
1789     return gpg_error (GPG_ERR_TOO_LARGE);
1790   return do_setattr (app, "CERT-3", pincb, pincb_arg, certdata, certdatalen);
1791 #else
1792   return gpg_error (GPG_ERR_NOT_IMPLEMENTED);
1793 #endif
1794 }
1795
1796
1797
1798 /* Handle the PASSWD command. */
1799 static gpg_error_t 
1800 do_change_pin (app_t app, ctrl_t ctrl,  const char *chvnostr, 
1801                unsigned int flags,
1802                gpg_error_t (*pincb)(void*, const char *, char **),
1803                void *pincb_arg)
1804 {
1805   int rc = 0;
1806   int chvno = atoi (chvnostr);
1807   char *resetcode = NULL;
1808   char *pinvalue;
1809   int reset_mode = !!(flags & APP_CHANGE_FLAG_RESET);
1810   int set_resetcode = 0;
1811
1812   (void)ctrl;
1813
1814   if (reset_mode && chvno == 3)
1815     {
1816       rc = gpg_error (GPG_ERR_INV_ID);
1817       goto leave;
1818     }
1819   else if (reset_mode || chvno == 3)
1820     {
1821       /* We always require that the PIN is entered. */
1822       app->did_chv3 = 0;
1823       rc = verify_chv3 (app, pincb, pincb_arg);
1824       if (rc)
1825         goto leave;
1826   
1827       if (chvno == 2 && app->app_local->extcap.is_v2)
1828         set_resetcode = 1;
1829     }
1830   else if (chvno == 2 && app->app_local->extcap.is_v2)
1831     {
1832       /* There is no PW2 for v2 cards.  We use this condition to allow
1833          a PW reset using the Reset Code.  */
1834       void *relptr;
1835       unsigned char *value;
1836       size_t valuelen;
1837       int remaining;
1838
1839       relptr = get_one_do (app, 0x00C4, &value, &valuelen, NULL);
1840       if (!relptr || valuelen < 7)
1841         {
1842           log_error (_("error retrieving CHV status from card\n"));
1843           xfree (relptr);
1844           rc = gpg_error (GPG_ERR_CARD);
1845           goto leave;
1846         }
1847       remaining = value[5];
1848       xfree (relptr);
1849       if (!remaining)
1850         {
1851           log_error (_("Reset Code not or not anymore available\n"));
1852           rc = gpg_error (GPG_ERR_BAD_PIN);
1853           goto leave;
1854         }          
1855
1856       rc = pincb (pincb_arg, _("||Please enter the Reset Code for the card"),
1857                   &resetcode); 
1858       if (rc)
1859         {
1860           log_info (_("PIN callback returned error: %s\n"), gpg_strerror (rc));
1861           goto leave;
1862         }
1863       if (strlen (resetcode) < 8)
1864         {
1865           log_error (_("Reset Code is too short; minimum length is %d\n"), 8);
1866           rc = gpg_error (GPG_ERR_BAD_PIN);
1867           goto leave;
1868         }
1869     }
1870   else if (chvno == 1 || chvno == 2)
1871     {
1872       /* CHV1 and CVH2 should always have the same value, thus we
1873          enforce it here.  */
1874       int save_force = app->force_chv1;
1875
1876       app->force_chv1 = 0;
1877       app->did_chv1 = 0;
1878       app->did_chv2 = 0;
1879       rc = verify_chv2 (app, pincb, pincb_arg);
1880       app->force_chv1 = save_force;
1881       if (rc)
1882         goto leave;
1883     }
1884   else
1885     {
1886       rc = gpg_error (GPG_ERR_INV_ID);
1887       goto leave;
1888     }
1889
1890   if (chvno == 3)
1891     app->did_chv3 = 0;
1892   else
1893     app->did_chv1 = app->did_chv2 = 0;
1894
1895   /* TRANSLATORS: Do not translate the "|*|" prefixes but
1896      keep it at the start of the string.  We need this elsewhere
1897      to get some infos on the string. */
1898   rc = pincb (pincb_arg, 
1899               set_resetcode? _("|RN|New Reset Code") :
1900               chvno == 3? _("|AN|New Admin PIN") : _("|N|New PIN"), 
1901               &pinvalue); 
1902   if (rc)
1903     {
1904       log_error (_("error getting new PIN: %s\n"), gpg_strerror (rc));
1905       goto leave;
1906     }
1907
1908   if (resetcode)
1909     {
1910       char *buffer;
1911
1912       buffer = xtrymalloc (strlen (resetcode) + strlen (pinvalue) + 1);
1913       if (!buffer)
1914         rc = gpg_error_from_syserror ();
1915       else
1916         {
1917           strcpy (stpcpy (buffer, resetcode), pinvalue);
1918           rc = iso7816_reset_retry_counter_with_rc (app->slot, 0x81,
1919                                                     buffer, strlen (buffer));
1920           wipememory (buffer, strlen (buffer));
1921           xfree (buffer);
1922         }
1923     }
1924   else if (set_resetcode)
1925     {
1926       if (strlen (pinvalue) < 8)
1927         {
1928           log_error (_("Reset Code is too short; minimum length is %d\n"), 8);
1929           rc = gpg_error (GPG_ERR_BAD_PIN);
1930         }
1931       else
1932         rc = iso7816_put_data (app->slot, 0, 0xD3,
1933                                pinvalue, strlen (pinvalue));
1934     }
1935   else if (reset_mode)
1936     {
1937       rc = iso7816_reset_retry_counter (app->slot, 0x81,
1938                                         pinvalue, strlen (pinvalue));
1939       if (!rc && !app->app_local->extcap.is_v2)
1940         rc = iso7816_reset_retry_counter (app->slot, 0x82,
1941                                           pinvalue, strlen (pinvalue));
1942     }
1943   else
1944     {
1945       if (chvno == 1 || chvno == 2)
1946         {
1947           rc = iso7816_change_reference_data (app->slot, 0x81, NULL, 0,
1948                                               pinvalue, strlen (pinvalue));
1949           if (!rc && !app->app_local->extcap.is_v2)
1950             rc = iso7816_change_reference_data (app->slot, 0x82, NULL, 0,
1951                                                 pinvalue, strlen (pinvalue));
1952         }
1953       else
1954         rc = iso7816_change_reference_data (app->slot, 0x80 + chvno, NULL, 0,
1955                                             pinvalue, strlen (pinvalue));
1956     }
1957   if (pinvalue)
1958     {
1959       wipememory (pinvalue, strlen (pinvalue));
1960       xfree (pinvalue);
1961     }
1962   if (rc)
1963     flush_cache_after_error (app);
1964
1965  leave:
1966   if (resetcode)
1967     {
1968       wipememory (resetcode, strlen (resetcode));
1969       xfree (resetcode);
1970     }
1971   return rc;
1972 }
1973
1974
1975 /* Check whether a key already exists.  KEYIDX is the index of the key
1976    (0..2).  If FORCE is TRUE a diagnositic will be printed but no
1977    error returned if the key already exists. */
1978 static gpg_error_t
1979 does_key_exist (app_t app, int keyidx, int force)
1980 {
1981   const unsigned char *fpr;
1982   unsigned char *buffer;
1983   size_t buflen, n;
1984   int i;
1985
1986   assert (keyidx >=0 && keyidx <= 2);
1987
1988   if (iso7816_get_data (app->slot, 0x006E, &buffer, &buflen))
1989     {
1990       log_error (_("error reading application data\n"));
1991       return gpg_error (GPG_ERR_GENERAL);
1992     }
1993   fpr = find_tlv (buffer, buflen, 0x00C5, &n);
1994   if (!fpr || n < 60)
1995     {
1996       log_error (_("error reading fingerprint DO\n"));
1997       xfree (buffer);
1998       return gpg_error (GPG_ERR_GENERAL);
1999     }
2000   fpr += 20*keyidx;
2001   for (i=0; i < 20 && !fpr[i]; i++)
2002     ;
2003   xfree (buffer);
2004   if (i!=20 && !force)
2005     {
2006       log_error (_("key already exists\n"));
2007       return gpg_error (GPG_ERR_EEXIST);
2008     }
2009   else if (i!=20)
2010     log_info (_("existing key will be replaced\n"));
2011   else
2012     log_info (_("generating new key\n"));
2013   return 0;
2014 }
2015
2016
2017 /* Create a TLV tag and value and store it at BUFFER.  Return the length
2018    of tag and length.  A LENGTH greater than 65535 is truncated. */
2019 static size_t
2020 add_tlv (unsigned char *buffer, unsigned int tag, size_t length)
2021
2022   unsigned char *p = buffer;
2023
2024   assert (tag <= 0xffff);
2025   if ( tag > 0xff )
2026     *p++ = tag >> 8;
2027   *p++ = tag;
2028   if (length < 128)
2029     *p++ = length;
2030   else if (length < 256)
2031     {
2032       *p++ = 0x81;
2033       *p++ = length;
2034     }
2035   else
2036     {
2037       if (length > 0xffff)
2038         length = 0xffff;
2039       *p++ = 0x82;
2040       *p++ = length >> 8;
2041       *p++ = length;
2042     }
2043
2044   return p - buffer;
2045 }
2046
2047
2048 /* Build the private key template as specified in the OpenPGP specs
2049    v2.0 section 4.3.3.7.  */
2050 static gpg_error_t
2051 build_privkey_template (app_t app, int keyno,
2052                         const unsigned char *rsa_n, size_t rsa_n_len,
2053                         const unsigned char *rsa_e, size_t rsa_e_len,
2054                         const unsigned char *rsa_p, size_t rsa_p_len,
2055                         const unsigned char *rsa_q, size_t rsa_q_len,
2056                         unsigned char **result, size_t *resultlen)
2057 {
2058   size_t rsa_e_reqlen;
2059   unsigned char privkey[7*(1+3)];
2060   size_t privkey_len;
2061   unsigned char exthdr[2+2+3];
2062   size_t exthdr_len;
2063   unsigned char suffix[2+3];
2064   size_t suffix_len;
2065   unsigned char *tp;
2066   size_t datalen;
2067   unsigned char *template;
2068   size_t template_size;
2069
2070   *result = NULL;
2071   *resultlen = 0;
2072
2073   switch (app->app_local->keyattr[keyno].format)
2074     {
2075     case RSA_STD:
2076     case RSA_STD_N:
2077       break;
2078     case RSA_CRT:
2079     case RSA_CRT_N:
2080       return gpg_error (GPG_ERR_NOT_SUPPORTED);
2081
2082     default:
2083       return gpg_error (GPG_ERR_INV_VALUE);
2084     }
2085
2086   /* Get the required length for E.  */
2087   rsa_e_reqlen = app->app_local->keyattr[keyno].e_bits/8;
2088   assert (rsa_e_len <= rsa_e_reqlen);
2089
2090   /* Build the 7f48 cardholder private key template.  */
2091   datalen = 0;
2092   tp = privkey;
2093
2094   tp += add_tlv (tp, 0x91, rsa_e_reqlen);
2095   datalen += rsa_e_reqlen;
2096
2097   tp += add_tlv (tp, 0x92, rsa_p_len);
2098   datalen += rsa_p_len;
2099
2100   tp += add_tlv (tp, 0x93, rsa_q_len);
2101   datalen += rsa_q_len;
2102
2103   if (app->app_local->keyattr[keyno].format == RSA_STD_N
2104       || app->app_local->keyattr[keyno].format == RSA_CRT_N)
2105     {
2106       tp += add_tlv (tp, 0x97, rsa_n_len);
2107       datalen += rsa_n_len;
2108     }
2109   privkey_len = tp - privkey;
2110
2111   /* Build the extended header list without the private key template.  */
2112   tp = exthdr;
2113   *tp++ = keyno ==0 ? 0xb6 : keyno == 1? 0xb8 : 0xa4;
2114   *tp++ = 0;
2115   tp += add_tlv (tp, 0x7f48, privkey_len);
2116   exthdr_len = tp - exthdr;
2117
2118   /* Build the 5f48 suffix of the data.  */
2119   tp = suffix;
2120   tp += add_tlv (tp, 0x5f48, datalen);
2121   suffix_len = tp - suffix;
2122
2123   /* Now concatenate everything.  */
2124   template_size = (1 + 3   /* 0x4d and len. */
2125                    + exthdr_len
2126                    + privkey_len
2127                    + suffix_len
2128                    + datalen);
2129   tp = template = xtrymalloc_secure (template_size);
2130   if (!template)
2131     return gpg_error_from_syserror ();
2132
2133   tp += add_tlv (tp, 0x4d, exthdr_len + privkey_len + suffix_len + datalen);
2134   memcpy (tp, exthdr, exthdr_len);
2135   tp += exthdr_len;
2136   memcpy (tp, privkey, privkey_len);
2137   tp += privkey_len;
2138   memcpy (tp, suffix, suffix_len);
2139   tp += suffix_len;
2140
2141   memcpy (tp, rsa_e, rsa_e_len);
2142   if (rsa_e_len < rsa_e_reqlen)
2143     {
2144       /* Right justify E. */
2145       memmove (tp + rsa_e_reqlen - rsa_e_len, tp, rsa_e_len);
2146       memset (tp, 0, rsa_e_reqlen - rsa_e_len);
2147     }                 
2148   tp += rsa_e_reqlen;
2149       
2150   memcpy (tp, rsa_p, rsa_p_len);
2151   tp += rsa_p_len;
2152       
2153   memcpy (tp, rsa_q, rsa_q_len);
2154   tp += rsa_q_len;
2155   
2156   if (app->app_local->keyattr[keyno].format == RSA_STD_N
2157       || app->app_local->keyattr[keyno].format == RSA_CRT_N)
2158     {
2159       memcpy (tp, rsa_n, rsa_n_len);
2160       tp += rsa_n_len;
2161     }
2162
2163   /* Sanity check.  We don't know the exact length because we
2164      allocated 3 bytes for the first length header.  */
2165   assert (tp - template <= template_size);
2166
2167   *result = template;
2168   *resultlen = tp - template;
2169   return 0;
2170 }
2171
2172
2173
2174 /* Handle the WRITEKEY command for OpenPGP.  This function expects a
2175    canonical encoded S-expression with the secret key in KEYDATA and
2176    its length (for assertions) in KEYDATALEN.  KEYID needs to be the
2177    usual keyid which for OpenPGP is the string "OPENPGP.n" with
2178    n=1,2,3.  Bit 0 of FLAGS indicates whether an existing key shall
2179    get overwritten.  PINCB and PINCB_ARG are the usual arguments for
2180    the pinentry callback.  */
2181 static gpg_error_t
2182 do_writekey (app_t app, ctrl_t ctrl,
2183              const char *keyid, unsigned int flags,
2184              gpg_error_t (*pincb)(void*, const char *, char **),
2185              void *pincb_arg,
2186              const unsigned char *keydata, size_t keydatalen)
2187 {
2188   gpg_error_t err;
2189   int force = (flags & 1);
2190   int keyno;
2191   const unsigned char *buf, *tok;
2192   size_t buflen, toklen;
2193   int depth, last_depth1, last_depth2;
2194   const unsigned char *rsa_n = NULL;
2195   const unsigned char *rsa_e = NULL;
2196   const unsigned char *rsa_p = NULL;
2197   const unsigned char *rsa_q = NULL;
2198   size_t rsa_n_len, rsa_e_len, rsa_p_len, rsa_q_len;
2199   unsigned int nbits;
2200   unsigned int maxbits;
2201   unsigned char *template = NULL;
2202   unsigned char *tp;
2203   size_t template_len;
2204   unsigned char fprbuf[20];
2205   u32 created_at = 0;
2206
2207   (void)ctrl;
2208
2209   if (!strcmp (keyid, "OPENPGP.1"))
2210     keyno = 0;
2211   else if (!strcmp (keyid, "OPENPGP.2"))
2212     keyno = 1;
2213   else if (!strcmp (keyid, "OPENPGP.3"))
2214     keyno = 2;
2215   else
2216     return gpg_error (GPG_ERR_INV_ID);
2217   
2218   err = does_key_exist (app, keyno, force);
2219   if (err)
2220     return err;
2221
2222
2223   /* 
2224      Parse the S-expression
2225    */
2226   buf = keydata;
2227   buflen = keydatalen;
2228   depth = 0;
2229   if ((err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen)))
2230     goto leave;
2231   if ((err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen)))
2232     goto leave;
2233   if (!tok || toklen != 11 || memcmp ("private-key", tok, toklen))
2234     {
2235       if (!tok)
2236         ;
2237       else if (toklen == 21 && !memcmp ("protected-private-key", tok, toklen))
2238         log_info ("protected-private-key passed to writekey\n");
2239       else if (toklen == 20 && !memcmp ("shadowed-private-key", tok, toklen))
2240         log_info ("shadowed-private-key passed to writekey\n");
2241       err = gpg_error (GPG_ERR_BAD_SECKEY);
2242       goto leave;
2243     }
2244   if ((err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen)))
2245     goto leave;
2246   if ((err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen)))
2247     goto leave;
2248   if (!tok || toklen != 3 || memcmp ("rsa", tok, toklen))
2249     {
2250       err = gpg_error (GPG_ERR_WRONG_PUBKEY_ALGO);
2251       goto leave;
2252     }
2253   last_depth1 = depth;
2254   while (!(err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen))
2255          && depth && depth >= last_depth1)
2256     {
2257       if (tok)
2258         {
2259           err = gpg_error (GPG_ERR_UNKNOWN_SEXP);
2260           goto leave;
2261         }
2262       if ((err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen)))
2263         goto leave;
2264       if (tok && toklen == 1)
2265         {
2266           const unsigned char **mpi;
2267           size_t *mpi_len;
2268
2269           switch (*tok)
2270             {
2271             case 'n': mpi = &rsa_n; mpi_len = &rsa_n_len; break; 
2272             case 'e': mpi = &rsa_e; mpi_len = &rsa_e_len; break; 
2273             case 'p': mpi = &rsa_p; mpi_len = &rsa_p_len; break; 
2274             case 'q': mpi = &rsa_q; mpi_len = &rsa_q_len;break; 
2275             default: mpi = NULL;  mpi_len = NULL; break;
2276             }
2277           if (mpi && *mpi)
2278             {
2279               err = gpg_error (GPG_ERR_DUP_VALUE);
2280               goto leave;
2281             }
2282           if ((err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen)))
2283             goto leave;
2284           if (tok && mpi)
2285             {
2286               /* Strip off leading zero bytes and save. */
2287               for (;toklen && !*tok; toklen--, tok++)
2288                 ;
2289               *mpi = tok;
2290               *mpi_len = toklen;
2291             }
2292         }
2293       /* Skip until end of list. */
2294       last_depth2 = depth;
2295       while (!(err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen))
2296              && depth && depth >= last_depth2)
2297         ;
2298       if (err)
2299         goto leave;
2300     }
2301   /* Parse other attributes. */
2302   last_depth1 = depth;
2303   while (!(err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen))
2304          && depth && depth >= last_depth1)
2305     {
2306       if (tok)
2307         {
2308           err = gpg_error (GPG_ERR_UNKNOWN_SEXP);
2309           goto leave;
2310         }
2311       if ((err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen)))
2312         goto leave;
2313       if (tok && toklen == 10 && !memcmp ("created-at", tok, toklen))
2314         {
2315           if ((err = parse_sexp (&buf,&buflen,&depth,&tok,&toklen)))
2316             goto leave;
2317           if (tok)
2318             {
2319               for (created_at=0; toklen && *tok && *tok >= '0' && *tok <= '9';
2320                    tok++, toklen--)
2321                 created_at = created_at*10 + (*tok - '0');
2322             }
2323         }
2324       /* Skip until end of list. */
2325       last_depth2 = depth;
2326       while (!(err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen))
2327              && depth && depth >= last_depth2)
2328         ;
2329       if (err)
2330         goto leave;
2331     }
2332
2333
2334   /* Check that we have all parameters and that they match the card
2335      description. */
2336   if (!created_at)
2337     {
2338       log_error (_("creation timestamp missing\n"));
2339       err = gpg_error (GPG_ERR_INV_VALUE);
2340       goto leave;
2341     }
2342
2343   maxbits = app->app_local->keyattr[keyno].n_bits;
2344   nbits = rsa_n? count_bits (rsa_n, rsa_n_len) : 0;
2345   if (nbits != maxbits)
2346     {
2347       log_error (_("RSA modulus missing or not of size %d bits\n"), 
2348                  (int)maxbits);
2349       err = gpg_error (GPG_ERR_BAD_SECKEY);
2350       goto leave;
2351     }
2352
2353   maxbits = app->app_local->keyattr[keyno].e_bits;
2354   if (maxbits > 32 && !app->app_local->extcap.is_v2)
2355     maxbits = 32; /* Our code for v1 does only support 32 bits.  */
2356   nbits = rsa_e? count_bits (rsa_e, rsa_e_len) : 0;
2357   if (nbits < 2 || nbits > maxbits)
2358     {
2359       log_error (_("RSA public exponent missing or larger than %d bits\n"),
2360                  (int)maxbits);
2361       err = gpg_error (GPG_ERR_BAD_SECKEY);
2362       goto leave;
2363     }
2364
2365   maxbits = app->app_local->keyattr[keyno].n_bits/2;
2366   nbits = rsa_p? count_bits (rsa_p, rsa_p_len) : 0;
2367   if (nbits != maxbits)
2368     {
2369       log_error (_("RSA prime %s missing or not of size %d bits\n"), 
2370                  "P", (int)maxbits);
2371       err = gpg_error (GPG_ERR_BAD_SECKEY);
2372       goto leave;
2373     }
2374   nbits = rsa_q? count_bits (rsa_q, rsa_q_len) : 0;
2375   if (nbits != maxbits)
2376     {
2377       log_error (_("RSA prime %s missing or not of size %d bits\n"), 
2378                  "Q", (int)maxbits);
2379       err = gpg_error (GPG_ERR_BAD_SECKEY);
2380       goto leave;
2381     }
2382   
2383   /* We need to remove the cached public key.  */
2384   xfree (app->app_local->pk[keyno].key);
2385   app->app_local->pk[keyno].key = NULL;
2386   app->app_local->pk[keyno].keylen = 0;
2387   app->app_local->pk[keyno].read_done = 0;
2388
2389
2390   if (app->app_local->extcap.is_v2)
2391     {
2392       /* Build the private key template as described in section 4.3.3.7 of
2393          the OpenPGP card specs version 2.0.  */
2394       int exmode;
2395  
2396       err = build_privkey_template (app, keyno,
2397                                     rsa_n, rsa_n_len,
2398                                     rsa_e, rsa_e_len,
2399                                     rsa_p, rsa_p_len,
2400                                     rsa_q, rsa_q_len,
2401                                     &template, &template_len);
2402       if (err)
2403         goto leave;
2404
2405       /* Prepare for storing the key.  */
2406       err = verify_chv3 (app, pincb, pincb_arg);
2407       if (err)
2408         goto leave;
2409
2410       /* Store the key. */
2411       if (app->app_local->cardcap.cmd_chaining && template_len > 254)
2412         exmode = -254;
2413       else
2414         exmode = 0;
2415       err = iso7816_put_data_odd (app->slot, exmode, 0x3fff,
2416                                   template, template_len);
2417     }
2418   else
2419     {
2420       /* Build the private key template as described in section 4.3.3.6 of
2421          the OpenPGP card specs version 1.1:
2422          0xC0   <length> public exponent
2423          0xC1   <length> prime p 
2424          0xC2   <length> prime q 
2425       */
2426       assert (rsa_e_len <= 4);
2427       template_len = (1 + 1 + 4
2428                       + 1 + 1 + rsa_p_len
2429                       + 1 + 1 + rsa_q_len);
2430       template = tp = xtrymalloc_secure (template_len);
2431       if (!template)
2432         {
2433           err = gpg_error_from_syserror ();
2434           goto leave;
2435         }
2436       *tp++ = 0xC0;
2437       *tp++ = 4;
2438       memcpy (tp, rsa_e, rsa_e_len);
2439       if (rsa_e_len < 4)
2440         {
2441           /* Right justify E. */
2442           memmove (tp+4-rsa_e_len, tp, rsa_e_len);
2443           memset (tp, 0, 4-rsa_e_len);
2444         }                 
2445       tp += 4;
2446       
2447       *tp++ = 0xC1;
2448       *tp++ = rsa_p_len;
2449       memcpy (tp, rsa_p, rsa_p_len);
2450       tp += rsa_p_len;
2451       
2452       *tp++ = 0xC2;
2453       *tp++ = rsa_q_len;
2454       memcpy (tp, rsa_q, rsa_q_len);
2455       tp += rsa_q_len;
2456       
2457       assert (tp - template == template_len);
2458       
2459       /* Prepare for storing the key.  */
2460       err = verify_chv3 (app, pincb, pincb_arg);
2461       if (err)
2462         goto leave;
2463
2464       /* Store the key. */
2465       err = iso7816_put_data (app->slot, 0,
2466                               (app->card_version > 0x0007? 0xE0:0xE9)+keyno,
2467                               template, template_len);
2468     }
2469   if (err)
2470     {
2471       log_error (_("failed to store the key: %s\n"), gpg_strerror (err));
2472       goto leave;
2473     }
2474  
2475   err = store_fpr (app->slot, keyno, created_at,
2476                   rsa_n, rsa_n_len, rsa_e, rsa_e_len,
2477                   fprbuf, app->card_version);
2478   if (err)
2479     goto leave;
2480
2481
2482  leave:
2483   xfree (template);
2484   return err;
2485 }
2486
2487
2488 /* Handle the GENKEY command. */
2489 static gpg_error_t 
2490 do_genkey (app_t app, ctrl_t ctrl,  const char *keynostr, unsigned int flags,
2491            time_t createtime,
2492            gpg_error_t (*pincb)(void*, const char *, char **),
2493            void *pincb_arg)
2494 {
2495   int rc;
2496   char numbuf[30];
2497   unsigned char fprbuf[20];
2498   const unsigned char *keydata, *m, *e;
2499   unsigned char *buffer = NULL;
2500   size_t buflen, keydatalen, mlen, elen;
2501   time_t created_at;
2502   int keyno = atoi (keynostr);
2503   int force = (flags & 1);
2504   time_t start_at;
2505
2506   if (keyno < 1 || keyno > 3)
2507     return gpg_error (GPG_ERR_INV_ID);
2508   keyno--;
2509
2510   /* We flush the cache to increase the traffic before a key
2511      generation.  This _might_ help a card to gather more entropy. */
2512   flush_cache (app);
2513
2514   /* Obviously we need to remove the cached public key.  */
2515   xfree (app->app_local->pk[keyno].key);
2516   app->app_local->pk[keyno].key = NULL;
2517   app->app_local->pk[keyno].keylen = 0;
2518   app->app_local->pk[keyno].read_done = 0;
2519
2520   /* Check whether a key already exists.  */
2521   rc = does_key_exist (app, keyno, force);
2522   if (rc)
2523     return rc;
2524
2525   /* Prepare for key generation by verifying the Admin PIN.  */
2526   rc = verify_chv3 (app, pincb, pincb_arg);
2527   if (rc)
2528     goto leave;
2529    
2530 #if 1
2531   log_info (_("please wait while key is being generated ...\n"));
2532   start_at = time (NULL);
2533   rc = iso7816_generate_keypair 
2534 #else
2535 # warning key generation temporary replaced by reading an existing key.
2536   rc = iso7816_read_public_key
2537 #endif
2538     (app->slot, (const unsigned char*)(keyno == 0? "\xB6" :
2539                                        keyno == 1? "\xB8" : "\xA4"),
2540      2,
2541      &buffer, &buflen);
2542   if (rc)
2543     {
2544       rc = gpg_error (GPG_ERR_CARD);
2545       log_error (_("generating key failed\n"));
2546       goto leave;
2547     }
2548   log_info (_("key generation completed (%d seconds)\n"),
2549             (int)(time (NULL) - start_at));
2550   keydata = find_tlv (buffer, buflen, 0x7F49, &keydatalen);
2551   if (!keydata)
2552     {
2553       rc = gpg_error (GPG_ERR_CARD);
2554       log_error (_("response does not contain the public key data\n"));
2555       goto leave;
2556     }
2557  
2558   m = find_tlv (keydata, keydatalen, 0x0081, &mlen);
2559   if (!m)
2560     {
2561       rc = gpg_error (GPG_ERR_CARD);
2562       log_error (_("response does not contain the RSA modulus\n"));
2563       goto leave;
2564     }
2565 /*    log_printhex ("RSA n:", m, mlen); */
2566   send_key_data (ctrl, "n", m, mlen);
2567
2568   e = find_tlv (keydata, keydatalen, 0x0082, &elen);
2569   if (!e)
2570     {
2571       rc = gpg_error (GPG_ERR_CARD);
2572       log_error (_("response does not contain the RSA public exponent\n"));
2573       goto leave;
2574     }
2575 /*    log_printhex ("RSA e:", e, elen); */
2576   send_key_data (ctrl, "e", e, elen);
2577
2578   created_at = createtime? createtime : gnupg_get_time ();
2579   sprintf (numbuf, "%lu", (unsigned long)created_at);
2580   send_status_info (ctrl, "KEY-CREATED-AT",
2581                     numbuf, (size_t)strlen(numbuf), NULL, 0);
2582
2583   rc = store_fpr (app->slot, keyno, (u32)created_at,
2584                   m, mlen, e, elen, fprbuf, app->card_version);
2585   if (rc)
2586     goto leave;
2587   send_fpr_if_not_null (ctrl, "KEY-FPR", -1, fprbuf);
2588
2589
2590  leave:
2591   xfree (buffer);
2592   return rc;
2593 }
2594
2595
2596 static unsigned long
2597 convert_sig_counter_value (const unsigned char *value, size_t valuelen)
2598 {
2599   unsigned long ul;
2600
2601   if (valuelen == 3 )
2602     ul = (value[0] << 16) | (value[1] << 8) | value[2];
2603   else
2604     {
2605       log_error (_("invalid structure of OpenPGP card (DO 0x93)\n"));
2606       ul = 0;
2607     }
2608   return ul;
2609 }
2610
2611 static unsigned long
2612 get_sig_counter (app_t app)
2613 {
2614   void *relptr;
2615   unsigned char *value;
2616   size_t valuelen;
2617   unsigned long ul;
2618
2619   relptr = get_one_do (app, 0x0093, &value, &valuelen, NULL);
2620   if (!relptr)
2621     return 0;
2622   ul = convert_sig_counter_value (value, valuelen);
2623   xfree (relptr);
2624   return ul;
2625 }
2626
2627 static gpg_error_t
2628 compare_fingerprint (app_t app, int keyno, unsigned char *sha1fpr)
2629 {
2630   const unsigned char *fpr;
2631   unsigned char *buffer;
2632   size_t buflen, n;
2633   int rc, i;
2634   
2635   assert (keyno >= 1 && keyno <= 3);
2636
2637   rc = get_cached_data (app, 0x006E, &buffer, &buflen, 0);
2638   if (rc)
2639     {
2640       log_error (_("error reading application data\n"));
2641       return gpg_error (GPG_ERR_GENERAL);
2642     }
2643   fpr = find_tlv (buffer, buflen, 0x00C5, &n);
2644   if (!fpr || n != 60)
2645     {
2646       xfree (buffer);
2647       log_error (_("error reading fingerprint DO\n"));
2648       return gpg_error (GPG_ERR_GENERAL);
2649     }
2650   fpr += (keyno-1)*20;
2651   for (i=0; i < 20; i++)
2652     if (sha1fpr[i] != fpr[i])
2653       {
2654         xfree (buffer);
2655         log_info (_("fingerprint on card does not match requested one\n"));
2656         return gpg_error (GPG_ERR_WRONG_SECKEY);
2657       }
2658   xfree (buffer);
2659   return 0;
2660 }
2661
2662
2663   /* If a fingerprint has been specified check it against the one on
2664      the card.  This is allows for a meaningful error message in case
2665      the key on the card has been replaced but the shadow information
2666      known to gpg was not updated.  If there is no fingerprint we
2667      assume that this is okay. */
2668 static gpg_error_t
2669 check_against_given_fingerprint (app_t app, const char *fpr, int keyno)
2670 {
2671   unsigned char tmp[20];
2672   const char *s;
2673   int n;
2674
2675   for (s=fpr, n=0; hexdigitp (s); s++, n++)
2676     ;
2677   if (n != 40)
2678     return gpg_error (GPG_ERR_INV_ID);
2679   else if (!*s)
2680     ; /* okay */
2681   else
2682     return gpg_error (GPG_ERR_INV_ID);
2683
2684   for (s=fpr, n=0; n < 20; s += 2, n++)
2685         tmp[n] = xtoi_2 (s);
2686   return compare_fingerprint (app, keyno, tmp);
2687 }
2688
2689
2690
2691 /* Compute a digital signature on INDATA which is expected to be the
2692    raw message digest. For this application the KEYIDSTR consists of
2693    the serialnumber and the fingerprint delimited by a slash.
2694
2695    Note that this function may return the error code
2696    GPG_ERR_WRONG_CARD to indicate that the card currently present does
2697    not match the one required for the requested action (e.g. the
2698    serial number does not match). 
2699    
2700    As a special feature a KEYIDSTR of "OPENPGP.3" redirects the
2701    operation to the auth command.
2702 */
2703 static gpg_error_t 
2704 do_sign (app_t app, const char *keyidstr, int hashalgo,
2705          gpg_error_t (*pincb)(void*, const char *, char **),
2706          void *pincb_arg,
2707          const void *indata, size_t indatalen,
2708          unsigned char **outdata, size_t *outdatalen )
2709 {
2710   static unsigned char rmd160_prefix[15] = /* Object ID is 1.3.36.3.2.1 */
2711     { 0x30, 0x21, 0x30, 0x09, 0x06, 0x05, 0x2b, 0x24, 0x03,
2712       0x02, 0x01, 0x05, 0x00, 0x04, 0x14  };
2713   static unsigned char sha1_prefix[15] =   /* (1.3.14.3.2.26) */
2714     { 0x30, 0x21, 0x30, 0x09, 0x06, 0x05, 0x2b, 0x0e, 0x03,
2715       0x02, 0x1a, 0x05, 0x00, 0x04, 0x14  };
2716   static unsigned char sha224_prefix[19] = /* (2.16.840.1.101.3.4.2.4) */
2717     { 0x30, 0x2D, 0x30, 0x0d, 0x06, 0x09, 0x60, 0x86, 0x48,
2718       0x01, 0x65, 0x03, 0x04, 0x02, 0x04, 0x05, 0x00, 0x04,
2719       0x1C  };
2720   static unsigned char sha256_prefix[19] = /* (2.16.840.1.101.3.4.2.1) */
2721     { 0x30, 0x31, 0x30, 0x0d, 0x06, 0x09, 0x60, 0x86,
2722       0x48, 0x01, 0x65, 0x03, 0x04, 0x02, 0x01, 0x05,
2723       0x00, 0x04, 0x20  };
2724   static unsigned char sha384_prefix[19] = /* (2.16.840.1.101.3.4.2.2) */
2725     { 0x30, 0x41, 0x30, 0x0d, 0x06, 0x09, 0x60, 0x86,
2726       0x48, 0x01, 0x65, 0x03, 0x04, 0x02, 0x02, 0x05,
2727       0x00, 0x04, 0x30  };
2728   static unsigned char sha512_prefix[19] = /* (2.16.840.1.101.3.4.2.3) */
2729     { 0x30, 0x51, 0x30, 0x0d, 0x06, 0x09, 0x60, 0x86,
2730       0x48, 0x01, 0x65, 0x03, 0x04, 0x02, 0x03, 0x05,
2731       0x00, 0x04, 0x40  };
2732   int rc;
2733   unsigned char data[19+64];
2734   size_t datalen;
2735   unsigned char tmp_sn[20]; /* Actually 16 bytes but also for the fpr. */
2736   const char *s;
2737   int n;
2738   const char *fpr = NULL;
2739   unsigned long sigcount;
2740   int use_auth = 0;
2741
2742   if (!keyidstr || !*keyidstr)
2743     return gpg_error (GPG_ERR_INV_VALUE);
2744
2745   /* Strip off known prefixes.  */
2746 #define X(a,b,c,d) \
2747   if (hashalgo == GCRY_MD_ ## a                               \
2748       && (d)                                                  \
2749       && indatalen == sizeof b ## _prefix + (c)               \
2750       && !memcmp (indata, b ## _prefix, sizeof b ## _prefix)) \
2751     {                                                         \
2752       indata = (const char*)indata + sizeof b ## _prefix;     \
2753       indatalen -= sizeof b ## _prefix;                       \
2754     }                                                         
2755
2756   if (indatalen == 20)
2757     ;  /* Assume a plain SHA-1 or RMD160 digest has been given.  */
2758   else X(SHA1,   sha1,   20, 1)
2759   else X(RMD160, rmd160, 20, 1)
2760   else X(SHA224, sha224, 28, app->app_local->extcap.is_v2)
2761   else X(SHA256, sha256, 32, app->app_local->extcap.is_v2)
2762   else X(SHA384, sha384, 48, app->app_local->extcap.is_v2)
2763   else X(SHA512, sha512, 64, app->app_local->extcap.is_v2)
2764   else if ((indatalen == 28 || indatalen == 32 
2765             || indatalen == 48 || indatalen ==64)
2766            && app->app_local->extcap.is_v2)
2767     ;  /* Assume a plain SHA-3 digest has been given.  */
2768   else
2769     {
2770       log_error (_("card does not support digest algorithm %s\n"),
2771                  gcry_md_algo_name (hashalgo));
2772       /* Or the supplied digest length does not match an algorithm.  */
2773       return gpg_error (GPG_ERR_INV_VALUE);
2774     }
2775 #undef X
2776
2777   /* Check whether an OpenPGP card of any version has been requested. */
2778   if (!strcmp (keyidstr, "OPENPGP.1"))
2779     ;
2780   else if (!strcmp (keyidstr, "OPENPGP.3"))
2781     use_auth = 1;
2782   else if (strlen (keyidstr) < 32 || strncmp (keyidstr, "D27600012401", 12))
2783     return gpg_error (GPG_ERR_INV_ID);
2784   else
2785     {
2786       for (s=keyidstr, n=0; hexdigitp (s); s++, n++)
2787         ;
2788       if (n != 32)
2789         return gpg_error (GPG_ERR_INV_ID);
2790       else if (!*s)
2791         ; /* no fingerprint given: we allow this for now. */
2792       else if (*s == '/')
2793         fpr = s + 1; 
2794       else
2795         return gpg_error (GPG_ERR_INV_ID);
2796
2797       for (s=keyidstr, n=0; n < 16; s += 2, n++)
2798         tmp_sn[n] = xtoi_2 (s);
2799
2800       if (app->serialnolen != 16)
2801         return gpg_error (GPG_ERR_INV_CARD);
2802       if (memcmp (app->serialno, tmp_sn, 16))
2803         return gpg_error (GPG_ERR_WRONG_CARD);
2804     }
2805
2806   /* If a fingerprint has been specified check it against the one on
2807      the card.  This is allows for a meaningful error message in case
2808      the key on the card has been replaced but the shadow information
2809      known to gpg was not updated.  If there is no fingerprint, gpg
2810      will detect a bogus signature anyway due to the
2811      verify-after-signing feature. */
2812   rc = fpr? check_against_given_fingerprint (app, fpr, 1) : 0;
2813   if (rc)
2814     return rc;
2815
2816   /* Concatenate prefix and digest.  */
2817 #define X(a,b,d) \
2818   if (hashalgo == GCRY_MD_ ## a && (d) )                      \
2819     {                                                         \
2820       datalen = sizeof b ## _prefix + indatalen;              \
2821       assert (datalen <= sizeof data);                        \
2822       memcpy (data, b ## _prefix, sizeof b ## _prefix);       \
2823       memcpy (data + sizeof b ## _prefix, indata, indatalen); \
2824     }                                                         
2825
2826   X(SHA1,   sha1,   1)
2827   else X(RMD160, rmd160, 1)
2828   else X(SHA224, sha224, app->app_local->extcap.is_v2)
2829   else X(SHA256, sha256, app->app_local->extcap.is_v2)
2830   else X(SHA384, sha384, app->app_local->extcap.is_v2)
2831   else X(SHA512, sha512, app->app_local->extcap.is_v2)
2832   else 
2833     return gpg_error (GPG_ERR_UNSUPPORTED_ALGORITHM);
2834 #undef X
2835
2836   /* Redirect to the AUTH command if asked to. */
2837   if (use_auth)
2838     {
2839       return do_auth (app, "OPENPGP.3", pincb, pincb_arg,
2840                       data, datalen,
2841                       outdata, outdatalen);
2842     }
2843
2844   /* Show the number of signature done using this key.  */
2845   sigcount = get_sig_counter (app);
2846   log_info (_("signatures created so far: %lu\n"), sigcount);
2847
2848   /* Check CHV if needed.  */
2849   if (!app->did_chv1 || app->force_chv1 ) 
2850     {
2851       char *pinvalue;
2852
2853       rc = verify_a_chv (app, pincb, pincb_arg, 1, sigcount, &pinvalue);
2854       if (rc)
2855         return rc;
2856
2857       app->did_chv1 = 1;
2858
2859       /* For cards with versions < 2 we want to keep CHV1 and CHV2 in
2860          sync, thus we verify CHV2 here using the given PIN.  Cards
2861          with version2 to not have the need for a separate CHV2 and
2862          internally use just one.  Obviously we can't do that if the
2863          keypad has been used. */
2864       if (!app->did_chv2 && pinvalue && !app->app_local->extcap.is_v2)
2865         {
2866           rc = iso7816_verify (app->slot, 0x82, pinvalue, strlen (pinvalue));
2867           if (gpg_err_code (rc) == GPG_ERR_BAD_PIN)
2868             rc = gpg_error (GPG_ERR_PIN_NOT_SYNCED);
2869           if (rc)
2870             {
2871               log_error (_("verify CHV%d failed: %s\n"), 2, gpg_strerror (rc));
2872               xfree (pinvalue);
2873               flush_cache_after_error (app);
2874               return rc;
2875             }
2876           app->did_chv2 = 1;
2877         }
2878       xfree (pinvalue);
2879     }
2880
2881   rc = iso7816_compute_ds (app->slot, data, datalen, outdata, outdatalen);
2882   return rc;
2883 }
2884
2885 /* Compute a digital signature using the INTERNAL AUTHENTICATE command
2886    on INDATA which is expected to be the raw message digest. For this
2887    application the KEYIDSTR consists of the serialnumber and the
2888    fingerprint delimited by a slash.  Optionally the id OPENPGP.3 may
2889    be given.
2890
2891    Note that this function may return the error code
2892    GPG_ERR_WRONG_CARD to indicate that the card currently present does
2893    not match the one required for the requested action (e.g. the
2894    serial number does not match). */
2895 static gpg_error_t 
2896 do_auth (app_t app, const char *keyidstr,
2897          gpg_error_t (*pincb)(void*, const char *, char **),
2898          void *pincb_arg,
2899          const void *indata, size_t indatalen,
2900          unsigned char **outdata, size_t *outdatalen )
2901 {
2902   int rc;
2903   unsigned char tmp_sn[20]; /* Actually 16 but we use it also for the fpr. */
2904   const char *s;
2905   int n;
2906   const char *fpr = NULL;
2907
2908   if (!keyidstr || !*keyidstr)
2909     return gpg_error (GPG_ERR_INV_VALUE);
2910   if (indatalen > 101) /* For a 2048 bit key. */
2911     return gpg_error (GPG_ERR_INV_VALUE);
2912
2913   /* Check whether an OpenPGP card of any version has been requested. */
2914   if (!strcmp (keyidstr, "OPENPGP.3"))
2915     ;
2916   else if (strlen (keyidstr) < 32 || strncmp (keyidstr, "D27600012401", 12))
2917     return gpg_error (GPG_ERR_INV_ID);
2918   else
2919     {
2920       for (s=keyidstr, n=0; hexdigitp (s); s++, n++)
2921         ;
2922       if (n != 32)
2923         return gpg_error (GPG_ERR_INV_ID);
2924       else if (!*s)
2925         ; /* no fingerprint given: we allow this for now. */
2926       else if (*s == '/')
2927         fpr = s + 1; 
2928       else
2929         return gpg_error (GPG_ERR_INV_ID);
2930
2931       for (s=keyidstr, n=0; n < 16; s += 2, n++)
2932         tmp_sn[n] = xtoi_2 (s);
2933       
2934       if (app->serialnolen != 16)
2935         return gpg_error (GPG_ERR_INV_CARD);
2936       if (memcmp (app->serialno, tmp_sn, 16))
2937         return gpg_error (GPG_ERR_WRONG_CARD);
2938     }
2939
2940   /* If a fingerprint has been specified check it against the one on
2941      the card.  This is allows for a meaningful error message in case
2942      the key on the card has been replaced but the shadow information
2943      known to gpg was not updated.  If there is no fingerprint, gpg
2944      will detect a bogus signature anyway due to the
2945      verify-after-signing feature. */
2946   rc = fpr? check_against_given_fingerprint (app, fpr, 3) : 0;
2947   if (rc)
2948     return rc;
2949
2950   rc = verify_chv2 (app, pincb, pincb_arg);
2951   if (!rc)
2952     rc = iso7816_internal_authenticate (app->slot, indata, indatalen,
2953                                         outdata, outdatalen);
2954   return rc;
2955 }
2956
2957
2958 static gpg_error_t 
2959 do_decipher (app_t app, const char *keyidstr,
2960              gpg_error_t (*pincb)(void*, const char *, char **),
2961              void *pincb_arg,
2962              const void *indata, size_t indatalen,
2963              unsigned char **outdata, size_t *outdatalen )
2964 {
2965   int rc;
2966   unsigned char tmp_sn[20]; /* actually 16 but we use it also for the fpr. */
2967   const char *s;
2968   int n;
2969   const char *fpr = NULL;
2970
2971   if (!keyidstr || !*keyidstr || !indatalen)
2972     return gpg_error (GPG_ERR_INV_VALUE);
2973
2974   /* Check whether an OpenPGP card of any version has been requested. */
2975   if (!strcmp (keyidstr, "OPENPGP.2"))
2976     ;
2977   else if (strlen (keyidstr) < 32 || strncmp (keyidstr, "D27600012401", 12))
2978     return gpg_error (GPG_ERR_INV_ID);
2979   else
2980     {
2981       for (s=keyidstr, n=0; hexdigitp (s); s++, n++)
2982         ;
2983       if (n != 32)
2984         return gpg_error (GPG_ERR_INV_ID);
2985       else if (!*s)
2986         ; /* no fingerprint given: we allow this for now. */
2987       else if (*s == '/')
2988         fpr = s + 1; 
2989       else
2990         return gpg_error (GPG_ERR_INV_ID);
2991       
2992       for (s=keyidstr, n=0; n < 16; s += 2, n++)
2993         tmp_sn[n] = xtoi_2 (s);
2994       
2995       if (app->serialnolen != 16)
2996         return gpg_error (GPG_ERR_INV_CARD);
2997       if (memcmp (app->serialno, tmp_sn, 16))
2998         return gpg_error (GPG_ERR_WRONG_CARD);
2999     }
3000
3001   /* If a fingerprint has been specified check it against the one on
3002      the card.  This is allows for a meaningful error message in case
3003      the key on the card has been replaced but the shadow information
3004      known to gpg was not updated.  If there is no fingerprint, the
3005      decryption will won't produce the right plaintext anyway. */
3006   rc = fpr? check_against_given_fingerprint (app, fpr, 2) : 0;
3007   if (rc)
3008     return rc;
3009
3010   rc = verify_chv2 (app, pincb, pincb_arg);
3011   if (!rc)
3012     {
3013       size_t fixuplen;
3014
3015       /* We might encounter a couple of leading zeroes in the
3016          cryptogram.  Due to internal use of MPIs thease leading
3017          zeroes are stripped.  However the OpenPGP card expects
3018          exactly 128 bytes for the cryptogram (for a 1k key).  Thus we
3019          need to fix it up.  We do this for up to 16 leading zero
3020          bytes; a cryptogram with more than this is with a very high
3021          probability anyway broken.  */
3022       if (indatalen >= (128-16) && indatalen < 128)      /* 1024 bit key.  */
3023         fixuplen = 128 - indatalen;
3024       else if (indatalen >= (256-16) && indatalen < 256) /* 2048 bit key.  */
3025         fixuplen = 256 - indatalen;
3026       else if (indatalen >= (192-16) && indatalen < 192) /* 1536 bit key.  */
3027         fixuplen = 192 - indatalen;
3028       else
3029         fixuplen = 0;
3030       if (fixuplen)
3031         {
3032           unsigned char *fixbuf;
3033
3034           /* While we have to prepend stuff anyway, we can also
3035              include the padding byte here so that iso1816_decipher
3036              does not need to do yet another data mangling.  */
3037           fixuplen++;
3038           fixbuf = xtrymalloc (fixuplen + indatalen);
3039           if (!fixbuf)
3040             rc = gpg_error_from_syserror ();
3041           else
3042             {
3043               memset (fixbuf, 0, fixuplen);
3044               memcpy (fixbuf+fixuplen, indata, indatalen);
3045               rc = iso7816_decipher (app->slot, fixbuf, fixuplen+indatalen, -1,
3046                                      outdata, outdatalen);
3047               xfree (fixbuf);
3048             }
3049
3050         }
3051       else
3052         rc = iso7816_decipher (app->slot, indata, indatalen, 0,
3053                                outdata, outdatalen);
3054     }
3055   return rc;
3056 }
3057
3058
3059 /* Perform a simple verify operation for CHV1 and CHV2, so that
3060    further operations won't ask for CHV2 and it is possible to do a
3061    cheap check on the PIN: If there is something wrong with the PIN
3062    entry system, only the regular CHV will get blocked and not the
3063    dangerous CHV3.  KEYIDSTR is the usual card's serial number; an
3064    optional fingerprint part will be ignored.
3065
3066    There is a special mode if the keyidstr is "<serialno>[CHV3]" with
3067    the "[CHV3]" being a literal string:  The Admin Pin is checked if
3068    and only if the retry counter is still at 3. */
3069 static gpg_error_t 
3070 do_check_pin (app_t app, const char *keyidstr,
3071               gpg_error_t (*pincb)(void*, const char *, char **),
3072               void *pincb_arg)
3073 {
3074   unsigned char tmp_sn[20]; 
3075   const char *s;
3076   int n;
3077   int admin_pin = 0;
3078
3079   if (!keyidstr || !*keyidstr)
3080     return gpg_error (GPG_ERR_INV_VALUE);
3081
3082   /* Check whether an OpenPGP card of any version has been requested. */
3083   if (strlen (keyidstr) < 32 || strncmp (keyidstr, "D27600012401", 12))
3084     return gpg_error (GPG_ERR_INV_ID);
3085   
3086   for (s=keyidstr, n=0; hexdigitp (s); s++, n++)
3087     ;
3088   if (n != 32)
3089     return gpg_error (GPG_ERR_INV_ID);
3090   else if (!*s)
3091     ; /* No fingerprint given: we allow this for now. */
3092   else if (*s == '/')
3093     ; /* We ignore a fingerprint. */
3094   else if (!strcmp (s, "[CHV3]") )
3095     admin_pin = 1;
3096   else
3097     return gpg_error (GPG_ERR_INV_ID);
3098
3099   for (s=keyidstr, n=0; n < 16; s += 2, n++)
3100     tmp_sn[n] = xtoi_2 (s);
3101
3102   if (app->serialnolen != 16)
3103     return gpg_error (GPG_ERR_INV_CARD);
3104   if (memcmp (app->serialno, tmp_sn, 16))
3105     return gpg_error (GPG_ERR_WRONG_CARD);
3106
3107   /* Yes, there is a race conditions: The user might pull the card
3108      right here and we won't notice that.  However this is not a
3109      problem and the check above is merely for a graceful failure
3110      between operations. */
3111
3112   if (admin_pin)
3113     {
3114       void *relptr;
3115       unsigned char *value;
3116       size_t valuelen;
3117       int count;
3118       
3119       relptr = get_one_do (app, 0x00C4, &value, &valuelen, NULL);
3120       if (!relptr || valuelen < 7)
3121         {
3122           log_error (_("error retrieving CHV status from card\n"));
3123           xfree (relptr);
3124           return gpg_error (GPG_ERR_CARD);
3125         }
3126       count = value[6];
3127       xfree (relptr);
3128
3129       if (!count)
3130         {
3131           log_info (_("card is permanently locked!\n"));
3132           return gpg_error (GPG_ERR_BAD_PIN);
3133         }
3134       else if (value[6] < 3)
3135         {
3136           log_info (_("verification of Admin PIN is currently prohibited "
3137                       "through this command\n"));
3138           return gpg_error (GPG_ERR_GENERAL);
3139         }
3140
3141       app->did_chv3 = 0; /* Force verification.  */
3142       return verify_chv3 (app, pincb, pincb_arg);
3143     }
3144   else
3145     return verify_chv2 (app, pincb, pincb_arg);
3146 }
3147
3148
3149 /* Show information about card capabilities.  */
3150 static void
3151 show_caps (struct app_local_s *s)
3152 {
3153   log_info ("Version-2 ......: %s\n", s->extcap.is_v2? "yes":"no");
3154   log_info ("Get-Challenge ..: %s", s->extcap.get_challenge? "yes":"no");
3155   if (s->extcap.get_challenge)
3156     log_printf (" (%u bytes max)", s->extcap.max_get_challenge);
3157   log_info ("Key-Import .....: %s\n", s->extcap.key_import? "yes":"no");
3158   log_info ("Change-Force-PW1: %s\n", s->extcap.change_force_chv? "yes":"no");
3159   log_info ("Private-DOs ....: %s\n", s->extcap.private_dos? "yes":"no");
3160   log_info ("SM-Support .....: %s", s->extcap.sm_supported? "yes":"no");
3161   if (s->extcap.sm_supported)
3162     log_printf (" (%s)", s->extcap.sm_aes128? "AES-128":"3DES");
3163   log_info ("Max-Cert3-Len ..: %u\n", s->extcap.max_certlen_3);
3164   log_info ("Max-Cmd-Data ...: %u\n", s->extcap.max_cmd_data);
3165   log_info ("Max-Rsp-Data ...: %u\n", s->extcap.max_rsp_data);
3166   log_info ("Cmd-Chaining ...: %s\n", s->cardcap.cmd_chaining?"yes":"no");
3167   log_info ("Ext-Lc-Le ......: %s\n", s->cardcap.ext_lc_le?"yes":"no");
3168   log_info ("Status Indicator: %02X\n", s->status_indicator);
3169
3170   log_info ("GnuPG-No-Sync ..: %s\n",  s->flags.no_sync? "yes":"no");
3171   log_info ("GnuPG-Def-PW2 ..: %s\n",  s->flags.def_chv2? "yes":"no");
3172 }
3173
3174
3175 /* Parse the historical bytes in BUFFER of BUFLEN and store them in
3176    APPLOC.  */
3177 static void
3178 parse_historical (struct app_local_s *apploc, 
3179                   const unsigned char * buffer, size_t buflen)
3180 {
3181   /* Example buffer: 00 31 C5 73 C0 01 80 00 90 00  */
3182   if (buflen < 4)
3183     {
3184       log_error ("warning: historical bytes are too short\n");
3185       return; /* Too short.  */
3186     }
3187   if (*buffer)
3188     {
3189       log_error ("warning: bad category indicator in historical bytes\n");
3190       return; 
3191     }
3192   
3193   /* Skip category indicator.  */
3194   buffer++;
3195   buflen--;
3196
3197   /* Get the status indicator.  */
3198   apploc->status_indicator = buffer[buflen-3];
3199   buflen -= 3;
3200
3201   /* Parse the compact TLV.  */
3202   while (buflen)
3203     {
3204       unsigned int tag = (*buffer & 0xf0) >> 4;
3205       unsigned int len = (*buffer & 0x0f);
3206       if (len+1 > buflen)
3207         {
3208           log_error ("warning: bad Compact-TLV in historical bytes\n");
3209           return; /* Error.  */
3210         }
3211       buffer++;
3212       buflen--;
3213       if (tag == 7 && len == 3)
3214         {
3215           /* Card capabilities.  */
3216           apploc->cardcap.cmd_chaining = !!(buffer[2] & 0x80);
3217           apploc->cardcap.ext_lc_le    = !!(buffer[2] & 0x40);
3218         }
3219       buffer += len;
3220       buflen -= len;
3221     }
3222 }
3223
3224
3225 /* Parse and optionally show the algorithm attributes for KEYNO.
3226    KEYNO must be in the range 0..2.  */
3227 static void 
3228 parse_algorithm_attribute (app_t app, int keyno)
3229
3230   unsigned char *buffer;
3231   size_t buflen;
3232   void *relptr;
3233   const char const desc[3][5] = {"sign", "encr", "auth"};
3234
3235   assert (keyno >=0 && keyno <= 2);
3236
3237   app->app_local->keyattr[keyno].n_bits = 0;
3238       
3239   relptr = get_one_do (app, 0xC1+keyno, &buffer, &buflen, NULL);
3240   if (!relptr)
3241     {
3242       log_error ("error reading DO 0x%02X\n", 0xc1+keyno);
3243       return;
3244     }
3245   if (buflen < 1)
3246     {
3247       log_error ("error reading DO 0x%02X\n", 0xc1+keyno);
3248       xfree (relptr);
3249       return;
3250     }
3251
3252   if (opt.verbose)
3253     log_info ("Key-Attr-%s ..: ", desc[keyno]);
3254   if (*buffer == 1 && (buflen == 5 || buflen == 6))
3255     {
3256       app->app_local->keyattr[keyno].n_bits = (buffer[1]<<8 | buffer[2]);
3257       app->app_local->keyattr[keyno].e_bits = (buffer[3]<<8 | buffer[4]);
3258       app->app_local->keyattr[keyno].format = 0;
3259       if (buflen < 6)
3260         app->app_local->keyattr[keyno].format = RSA_STD;
3261       else
3262         app->app_local->keyattr[keyno].format = (buffer[5] == 0? RSA_STD   :
3263                                                  buffer[5] == 1? RSA_STD_N :
3264                                                  buffer[5] == 2? RSA_CRT   :
3265                                                  buffer[5] == 3? RSA_CRT_N : 
3266                                                  RSA_UNKNOWN_FMT);
3267
3268       if (opt.verbose)
3269         log_printf
3270           ("RSA, n=%u, e=%u, fmt=%s\n",
3271            app->app_local->keyattr[keyno].n_bits,
3272            app->app_local->keyattr[keyno].e_bits,
3273            app->app_local->keyattr[keyno].format == RSA_STD?  "std"  :
3274            app->app_local->keyattr[keyno].format == RSA_STD_N?"std+n":
3275            app->app_local->keyattr[keyno].format == RSA_CRT?  "crt"  :
3276            app->app_local->keyattr[keyno].format == RSA_CRT_N?"crt+n":"?");
3277     }
3278   else if (opt.verbose)
3279     log_printhex ("", buffer, buflen);
3280
3281   xfree (relptr);
3282 }
3283
3284 /* Select the OpenPGP application on the card in SLOT.  This function
3285    must be used before any other OpenPGP application functions. */
3286 gpg_error_t
3287 app_select_openpgp (app_t app)
3288 {
3289   static char const aid[] = { 0xD2, 0x76, 0x00, 0x01, 0x24, 0x01 };
3290   int slot = app->slot;
3291   int rc;
3292   unsigned char *buffer;
3293   size_t buflen;
3294   void *relptr;
3295   
3296   /* Note that the card can't cope with P2=0xCO, thus we need to pass a
3297      special flag value. */
3298   rc = iso7816_select_application (slot, aid, sizeof aid, 0x0001);
3299   if (!rc)
3300     {
3301       unsigned int manufacturer;
3302
3303       app->apptype = "OPENPGP";
3304
3305       app->did_chv1 = 0;
3306       app->did_chv2 = 0;
3307       app->did_chv3 = 0;
3308       app->app_local = NULL;
3309
3310       /* The OpenPGP card returns the serial number as part of the
3311          AID; because we prefer to use OpenPGP serial numbers, we
3312          replace a possibly already set one from a EF.GDO with this
3313          one.  Note, that for current OpenPGP cards, no EF.GDO exists
3314          and thus it won't matter at all. */
3315       rc = iso7816_get_data (slot, 0x004F, &buffer, &buflen);
3316       if (rc)
3317         goto leave;
3318       if (opt.verbose)
3319         {
3320           log_info ("AID: ");
3321           log_printhex ("", buffer, buflen);
3322         }
3323
3324       app->card_version = buffer[6] << 8;
3325       app->card_version |= buffer[7];
3326       manufacturer = (buffer[8]<<8 | buffer[9]);
3327
3328       xfree (app->serialno);
3329       app->serialno = buffer;
3330       app->serialnolen = buflen;
3331       buffer = NULL;
3332       app->app_local = xtrycalloc (1, sizeof *app->app_local);
3333       if (!app->app_local)
3334         {
3335           rc = gpg_error (gpg_err_code_from_errno (errno));
3336           goto leave;
3337         }
3338
3339       if (app->card_version >= 0x0200)
3340         app->app_local->extcap.is_v2 = 1;
3341
3342
3343       /* Read the historical bytes.  */
3344       relptr = get_one_do (app, 0x5f52, &buffer, &buflen, NULL);
3345       if (relptr)
3346         {
3347           if (opt.verbose)
3348             {
3349               log_info ("Historical Bytes: ");
3350               log_printhex ("", buffer, buflen);
3351             }
3352           parse_historical (app->app_local, buffer, buflen);
3353           xfree (relptr);
3354         }
3355
3356       /* Read the force-chv1 flag.  */
3357       relptr = get_one_do (app, 0x00C4, &buffer, &buflen, NULL);
3358       if (!relptr)
3359         {
3360           log_error (_("can't access %s - invalid OpenPGP card?\n"),
3361                      "CHV Status Bytes");
3362           goto leave;
3363         }
3364       app->force_chv1 = (buflen && *buffer == 0);
3365       xfree (relptr);
3366
3367       /* Read the extended capabilities.  */
3368       relptr = get_one_do (app, 0x00C0, &buffer, &buflen, NULL);
3369       if (!relptr)
3370         {
3371           log_error (_("can't access %s - invalid OpenPGP card?\n"),
3372                      "Extended Capability Flags" );
3373           goto leave;
3374         }
3375       if (buflen)
3376         {
3377           app->app_local->extcap.sm_supported     = !!(*buffer & 0x80);
3378           app->app_local->extcap.get_challenge    = !!(*buffer & 0x40);
3379           app->app_local->extcap.key_import       = !!(*buffer & 0x20);
3380           app->app_local->extcap.change_force_chv = !!(*buffer & 0x10);
3381           app->app_local->extcap.private_dos      = !!(*buffer & 0x08);
3382         }
3383       if (buflen >= 10)
3384         {
3385           /* Available with v2 cards.  */
3386           app->app_local->extcap.sm_aes128     = (buffer[1] == 1);
3387           app->app_local->extcap.max_get_challenge 
3388                                                = (buffer[2] << 8 | buffer[3]);
3389           app->app_local->extcap.max_certlen_3 = (buffer[4] << 8 | buffer[5]);
3390           app->app_local->extcap.max_cmd_data  = (buffer[6] << 8 | buffer[7]);
3391           app->app_local->extcap.max_rsp_data  = (buffer[8] << 8 | buffer[9]);
3392         }
3393       xfree (relptr);
3394
3395       /* Some of the first cards accidently don't set the
3396          CHANGE_FORCE_CHV bit but allow it anyway. */
3397       if (app->card_version <= 0x0100 && manufacturer == 1)
3398         app->app_local->extcap.change_force_chv = 1;
3399
3400       parse_login_data (app);
3401
3402       if (opt.verbose)
3403         show_caps (app->app_local);
3404
3405       parse_algorithm_attribute (app, 0);
3406       parse_algorithm_attribute (app, 1);
3407       parse_algorithm_attribute (app, 2);
3408       
3409       if (opt.verbose > 1)
3410         dump_all_do (slot);
3411
3412       app->fnc.deinit = do_deinit;
3413       app->fnc.learn_status = do_learn_status;
3414       app->fnc.readcert = do_readcert;
3415       app->fnc.readkey = do_readkey;
3416       app->fnc.getattr = do_getattr;
3417       app->fnc.setattr = do_setattr;
3418       app->fnc.writecert = do_writecert;
3419       app->fnc.writekey = do_writekey;
3420       app->fnc.genkey = do_genkey;
3421       app->fnc.sign = do_sign;
3422       app->fnc.auth = do_auth;
3423       app->fnc.decipher = do_decipher;
3424       app->fnc.change_pin = do_change_pin;
3425       app->fnc.check_pin = do_check_pin;
3426    }
3427
3428 leave:
3429   if (rc)
3430     do_deinit (app);
3431   return rc;
3432 }
3433
3434
3435