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