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