* trustdb.h, keyedit.c (keyedit_menu, menu_select_uid_namehash): Allow
[gnupg.git] / g10 / app-openpgp.c
1 /* app-openpgp.c - The OpenPGP card application.
2  *      Copyright (C) 2003, 2004, 2005 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 2 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, write to the Free Software
18  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
19  *
20  * $Id$
21  */
22
23 #include <config.h>
24 #include <errno.h>
25 #include <stdio.h>
26 #include <stdlib.h>
27 #include <string.h>
28 #include <assert.h>
29 #include <time.h>
30
31 #if GNUPG_MAJOR_VERSION == 1
32 /* This is used with GnuPG version < 1.9.  The code has been source
33    copied from the current GnuPG >= 1.9  and is maintained over
34    there. */
35 #include "options.h"
36 #include "errors.h"
37 #include "memory.h"
38 #include "util.h"
39 #include "cardglue.h"
40 #else /* GNUPG_MAJOR_VERSION != 1 */
41 #include "scdaemon.h"
42 #endif /* GNUPG_MAJOR_VERSION != 1 */
43
44 #include "i18n.h"
45 #include "iso7816.h"
46 #include "app-common.h"
47 #include "tlv.h"
48
49
50 static struct {
51   int tag;
52   int constructed;
53   int get_from;  /* Constructed DO with this DO or 0 for direct access. */
54   int binary;
55   int dont_cache;
56   int flush_on_error;
57   int get_immediate_in_v11; /* Enable a hack to bypass the cache of
58                                this data object if it is used in 1.1
59                                and later versions of the card.  This
60                                does not work with composite DO and is
61                                currently only useful for the CHV
62                                status bytes. */
63   char *desc;
64 } data_objects[] = {
65   { 0x005E, 0,    0, 1, 0, 0, 0, "Login Data" },
66   { 0x5F50, 0,    0, 0, 0, 0, 0, "URL" },
67   { 0x0065, 1,    0, 1, 0, 0, 0, "Cardholder Related Data"},
68   { 0x005B, 0, 0x65, 0, 0, 0, 0, "Name" },
69   { 0x5F2D, 0, 0x65, 0, 0, 0, 0, "Language preferences" },
70   { 0x5F35, 0, 0x65, 0, 0, 0, 0, "Sex" },
71   { 0x006E, 1,    0, 1, 0, 0, 0, "Application Related Data" },
72   { 0x004F, 0, 0x6E, 1, 0, 0, 0, "AID" },
73   { 0x0073, 1,    0, 1, 0, 0, 0, "Discretionary Data Objects" },
74   { 0x0047, 0, 0x6E, 1, 1, 0, 0, "Card Capabilities" },
75   { 0x00C0, 0, 0x6E, 1, 1, 0, 0, "Extended Card Capabilities" },
76   { 0x00C1, 0, 0x6E, 1, 1, 0, 0, "Algorithm Attributes Signature" },
77   { 0x00C2, 0, 0x6E, 1, 1, 0, 0, "Algorithm Attributes Decryption" },
78   { 0x00C3, 0, 0x6E, 1, 1, 0, 0, "Algorithm Attributes Authentication" },
79   { 0x00C4, 0, 0x6E, 1, 0, 1, 1, "CHV Status Bytes" },
80   { 0x00C5, 0, 0x6E, 1, 0, 0, 0, "Fingerprints" },
81   { 0x00C6, 0, 0x6E, 1, 0, 0, 0, "CA Fingerprints" },
82   { 0x00CD, 0, 0x6E, 1, 0, 0, 0, "Generation time" },
83   { 0x007A, 1,    0, 1, 0, 0, 0, "Security Support Template" },
84   { 0x0093, 0, 0x7A, 1, 1, 0, 0, "Digital Signature Counter" },
85   { 0x0101, 0,    0, 0, 0, 0, 0, "Private DO 1"},
86   { 0x0102, 0,    0, 0, 0, 0, 0, "Private DO 2"},
87   { 0x0103, 0,    0, 0, 0, 0, 0, "Private DO 3"},
88   { 0x0104, 0,    0, 0, 0, 0, 0, "Private DO 4"},
89   { 0 }
90 };
91
92
93 struct cache_s {
94   struct cache_s *next;
95   int tag;
96   size_t length;
97   unsigned char data[1];
98 };
99
100 struct app_local_s {
101   struct cache_s *cache;
102   struct 
103   {
104     unsigned int get_challenge:1;
105     unsigned int key_import:1;
106     unsigned int change_force_chv:1;
107     unsigned int private_dos:1;
108   } extcap;
109   struct
110   {
111     unsigned int no_sync:1;   /* Do not sync CHV1 and CHV2 */
112     unsigned int def_chv2:1;  /* Use 123456 for CHV2.  */
113   } flags;
114 };
115
116
117 static unsigned long convert_sig_counter_value (const unsigned char *value,
118                                                 size_t valuelen);
119 static unsigned long get_sig_counter (APP app);
120
121 /* Deconstructor. */
122 static void
123 do_deinit (app_t app)
124 {
125   if (app && app->app_local)
126     {
127       struct cache_s *c, *c2;
128
129       for (c = app->app_local->cache; c; c = c2)
130         {
131           c2 = c->next;
132           xfree (c);
133         }
134       xfree (app->app_local);
135       app->app_local = NULL;
136     }
137 }
138
139
140 /* Wrapper around iso7816_get_data which first tries to get the data
141    from the cache.  With GET_IMMEDIATE passed as true, the cache is
142    bypassed. */
143 static gpg_error_t
144 get_cached_data (app_t app, int tag, 
145                  unsigned char **result, size_t *resultlen,
146                  int get_immediate)
147 {
148   gpg_error_t err;
149   int i;
150   unsigned char *p;
151   size_t len;
152   struct cache_s *c;
153
154   *result = NULL;
155   *resultlen = 0;
156
157   if (!get_immediate)
158     {
159       for (c=app->app_local->cache; c; c = c->next)
160         if (c->tag == tag)
161           {
162             if(c->length)
163               {
164                 p = xtrymalloc (c->length);
165                 if (!p)
166                   return gpg_error (gpg_err_code_from_errno (errno));
167                 memcpy (p, c->data, c->length);
168                 *result = p;
169               }
170             
171             *resultlen = c->length;
172             
173             return 0;
174           }
175     }
176   
177   err = iso7816_get_data (app->slot, tag, &p, &len);
178   if (err)
179     return err;
180   *result = p;
181   *resultlen = len;
182
183   /* Check whether we should cache this object. */
184   if (get_immediate)
185     return 0;
186
187   for (i=0; data_objects[i].tag; i++)
188     if (data_objects[i].tag == tag)
189       {
190         if (data_objects[i].dont_cache)
191           return 0;
192         break;
193       }
194
195   /* Okay, cache it. */
196   for (c=app->app_local->cache; c; c = c->next)
197     assert (c->tag != tag);
198   
199   c = xtrymalloc (sizeof *c + len);
200   if (c)
201     {
202       memcpy (c->data, p, len);
203       c->length = len;
204       c->tag = tag;
205       c->next = app->app_local->cache;
206       app->app_local->cache = c;
207     }
208
209   return 0;
210 }
211
212 /* Remove DO at TAG from the cache. */
213 static void
214 flush_cache_item (app_t app, int tag)
215 {
216   struct cache_s *c, *cprev;
217   int i;
218
219   if (!app->app_local)
220     return;
221
222   for (c=app->app_local->cache, cprev=NULL; c ; cprev=c, c = c->next)
223     if (c->tag == tag)
224       {
225         if (cprev)
226           cprev->next = c->next;
227         else
228           app->app_local->cache = c->next;
229         xfree (c);
230
231         for (c=app->app_local->cache; c ; c = c->next)
232           {
233             assert (c->tag != tag); /* Oops: duplicated entry. */
234           }
235         return;
236       }
237
238   /* Try again if we have an outer tag. */
239   for (i=0; data_objects[i].tag; i++)
240     if (data_objects[i].tag == tag && data_objects[i].get_from
241         && data_objects[i].get_from != tag)
242       flush_cache_item (app, data_objects[i].get_from);
243 }
244
245 /* Flush all entries from the cache which might be out of sync after
246    an error. */
247 static void
248 flush_cache_after_error (app_t app)
249 {
250   int i;
251
252   for (i=0; data_objects[i].tag; i++)
253     if (data_objects[i].flush_on_error)
254       flush_cache_item (app, data_objects[i].tag);
255 }
256
257
258 /* Flush the entire cache. */
259 static void
260 flush_cache (app_t app)
261 {
262   if (app && app->app_local)
263     {
264       struct cache_s *c, *c2;
265
266       for (c = app->app_local->cache; c; c = c2)
267         {
268           c2 = c->next;
269           xfree (c);
270         }
271       app->app_local->cache = NULL;
272     }
273 }
274
275
276 /* Get the DO identified by TAG from the card in SLOT and return a
277    buffer with its content in RESULT and NBYTES.  The return value is
278    NULL if not found or a pointer which must be used to release the
279    buffer holding value. */
280 static void *
281 get_one_do (app_t app, int tag, unsigned char **result, size_t *nbytes)
282 {
283   int rc, i;
284   unsigned char *buffer;
285   size_t buflen;
286   unsigned char *value;
287   size_t valuelen;
288
289   *result = NULL;
290   *nbytes = 0;
291   for (i=0; data_objects[i].tag && data_objects[i].tag != tag; i++)
292     ;
293
294   if (app->card_version > 0x0100 && data_objects[i].get_immediate_in_v11)
295     {
296       if( iso7816_get_data (app->slot, tag, &buffer, &buflen))
297         return NULL;
298       *result = buffer;
299       *nbytes = buflen;
300       return buffer;
301     }
302
303   value = NULL;
304   rc = -1;
305   if (data_objects[i].tag && data_objects[i].get_from)
306     {
307       rc = get_cached_data (app, data_objects[i].get_from,
308                             &buffer, &buflen,
309                             data_objects[i].get_immediate_in_v11);
310       if (!rc)
311         {
312           const unsigned char *s;
313
314           s = find_tlv (buffer, buflen, tag, &valuelen);
315           if (!s)
316             value = NULL; /* not found */
317           else if (valuelen > buflen - (s - buffer))
318             {
319               log_error ("warning: constructed DO too short\n");
320               value = NULL;
321               xfree (buffer); buffer = NULL;
322             }
323           else
324             value = buffer + (s - buffer);
325         }
326     }
327
328   if (!value) /* Not in a constructed DO, try simple. */
329     {
330       rc = get_cached_data (app, tag, &buffer, &buflen,
331                             data_objects[i].get_immediate_in_v11);
332       if (!rc)
333         {
334           value = buffer;
335           valuelen = buflen;
336         }
337     }
338
339   if (!rc)
340     {
341       *nbytes = valuelen;
342       *result = value;
343       return buffer;
344     }
345   return NULL;
346 }
347
348
349 static void
350 dump_all_do (int slot)
351 {
352   int rc, i, j;
353   unsigned char *buffer;
354   size_t buflen;
355   
356   for (i=0; data_objects[i].tag; i++)
357     {
358       if (data_objects[i].get_from)
359         continue;
360
361       rc = iso7816_get_data (slot, data_objects[i].tag, &buffer, &buflen);
362       if (gpg_err_code (rc) == GPG_ERR_NO_OBJ)
363         ;
364       else if (rc) 
365         log_info ("DO `%s' not available: %s\n",
366                   data_objects[i].desc, gpg_strerror (rc));
367       else
368         {
369           if (data_objects[i].binary)
370             {
371               log_info ("DO `%s': ", data_objects[i].desc);
372               log_printhex ("", buffer, buflen);
373             }
374           else
375             log_info ("DO `%s': `%.*s'\n",
376                       data_objects[i].desc,
377                       (int)buflen, buffer); /* FIXME: sanitize */
378
379           if (data_objects[i].constructed)
380             {
381               for (j=0; data_objects[j].tag; j++)
382                 {
383                   const unsigned char *value;
384                   size_t valuelen;
385                   
386                   if (j==i || data_objects[i].tag != data_objects[j].get_from)
387                     continue;
388                   value = find_tlv (buffer, buflen,
389                                     data_objects[j].tag, &valuelen);
390                   if (!value)
391                     ; /* not found */
392                   else if (valuelen > buflen - (value - buffer))
393                     log_error ("warning: constructed DO too short\n");
394                   else
395                     {
396                       if (data_objects[j].binary)
397                         {
398                           log_info ("DO `%s': ", data_objects[j].desc);
399                           log_printhex ("", value, valuelen);
400                         }
401                       else
402                         log_info ("DO `%s': `%.*s'\n",
403                                   data_objects[j].desc,
404                                   (int)valuelen, value); /* FIXME: sanitize */
405                     }
406                 }
407             }
408         }
409       xfree (buffer); buffer = NULL;
410     }
411 }
412
413
414 /* Count the number of bits, assuming the A represents an unsigned big
415    integer of length LEN bytes. */
416 static unsigned int
417 count_bits (const unsigned char *a, size_t len)
418 {
419   unsigned int n = len * 8;
420   int i;
421
422   for (; len && !*a; len--, a++, n -=8)
423     ;
424   if (len)
425     {
426       for (i=7; i && !(*a & (1<<i)); i--)
427         n--;
428     }
429   return n;
430 }
431
432 /* GnuPG makes special use of the login-data DO, this fucntion parses
433    the login data to store the flags for later use.  It may be called
434    at any time and should be called after changing the login-data DO.
435
436    Everything up to a LF is considered a mailbox or account name.  If
437    the first LF is followed by DC4 (0x14) control sequence are
438    expected up to the next LF.  Control sequences are separated by FS
439    (0x28) and consist of key=value pairs.  There is one key defined:
440
441     F=<flags>
442
443     Were FLAGS is a plain hexadecimal number representing flag values.
444     The lsb is here the rightmost bit.  Defined flags bits are:
445
446       Bit 0 = CHV1 and CHV2 are not syncronized
447       Bit 1 = CHV2 has been been set to the default PIN of "123456"
448               (this implies that bit 0 is also set).
449
450 */
451 static void
452 parse_login_data (app_t app)
453 {
454   unsigned char *buffer, *p;
455   size_t buflen, len;
456   void *relptr;
457
458   /* Set defaults.  */
459   app->app_local->flags.no_sync = 0;
460   app->app_local->flags.def_chv2 = 0;
461
462   /* Read the DO.  */
463   relptr = get_one_do (app, 0x005E, &buffer, &buflen);
464   if (!relptr)
465     return; /* Ooops. */
466   for (; buflen; buflen--, buffer++)
467     if (*buffer == '\n')
468       break;
469   if (buflen < 2 || buffer[1] != '\x14')
470     return; /* No control sequences.  */
471   buflen--;
472   buffer++;
473   do
474     {
475       buflen--;
476       buffer++;
477       if (buflen > 1 && *buffer == 'F' && buffer[1] == '=')
478         {
479           /* Flags control sequence found.  */
480           int lastdig = 0;
481
482           /* For now we are only interested in the last digit, so skip
483              any leading digits but bail out on invalid characters. */
484           for (p=buffer+2, len = buflen-2; len && hexdigitp (p); p++, len--)
485             lastdig = xtoi_1 (p);
486           if (len && !(*p == '\n' || *p == '\x18'))
487             goto next;  /* Invalid characters in field.  */
488           app->app_local->flags.no_sync = !!(lastdig & 1);
489           app->app_local->flags.def_chv2 = (lastdig & 3) == 3;
490         }
491     next:
492       for (; buflen && *buffer != '\x18'; buflen--, buffer++)
493         if (*buffer == '\n')
494           buflen = 1; 
495     }
496   while (buflen);
497
498   xfree (relptr);
499 }
500
501 /* Note, that FPR must be at least 20 bytes. */
502 static int 
503 store_fpr (int slot, int keynumber, u32 timestamp,
504            const unsigned char *m, size_t mlen,
505            const unsigned char *e, size_t elen, 
506            unsigned char *fpr, unsigned int card_version)
507 {
508   unsigned int n, nbits;
509   unsigned char *buffer, *p;
510   int rc;
511   
512   for (; mlen && !*m; mlen--, m++) /* strip leading zeroes */
513     ;
514   for (; elen && !*e; elen--, e++) /* strip leading zeroes */
515     ;
516
517   n = 6 + 2 + mlen + 2 + elen;
518   p = buffer = xtrymalloc (3 + n);
519   if (!buffer)
520     return gpg_error (gpg_err_code_from_errno (errno));
521   
522   *p++ = 0x99;     /* ctb */
523   *p++ = n >> 8;   /* 2 byte length header */
524   *p++ = n;
525   *p++ = 4;        /* key packet version */
526   *p++ = timestamp >> 24;
527   *p++ = timestamp >> 16;
528   *p++ = timestamp >>  8;
529   *p++ = timestamp;
530   *p++ = 1; /* RSA */
531   nbits = count_bits (m, mlen);
532   *p++ = nbits >> 8;
533   *p++ = nbits;
534   memcpy (p, m, mlen); p += mlen;
535   nbits = count_bits (e, elen);
536   *p++ = nbits >> 8;
537   *p++ = nbits;
538   memcpy (p, e, elen); p += elen;
539     
540   gcry_md_hash_buffer (GCRY_MD_SHA1, fpr, buffer, n+3);
541
542   xfree (buffer);
543
544   rc = iso7816_put_data (slot, (card_version > 0x0007? 0xC7 : 0xC6)
545                                + keynumber, fpr, 20);
546   if (rc)
547     log_error (_("failed to store the fingerprint: %s\n"),gpg_strerror (rc));
548
549   if (!rc && card_version > 0x0100)
550     {
551       unsigned char buf[4];
552
553       buf[0] = timestamp >> 24;
554       buf[1] = timestamp >> 16;
555       buf[2] = timestamp >>  8;
556       buf[3] = timestamp;
557
558       rc = iso7816_put_data (slot, 0xCE + keynumber, buf, 4);
559       if (rc)
560         log_error (_("failed to store the creation date: %s\n"),
561                    gpg_strerror (rc));
562     }
563
564   return rc;
565 }
566
567        
568 static void
569 send_fpr_if_not_null (ctrl_t ctrl, const char *keyword,
570                       int number, const unsigned char *fpr)
571 {                      
572   int i;
573   char buf[41];
574   char numbuf[25];
575
576   for (i=0; i < 20 && !fpr[i]; i++)
577     ;
578   if (i==20)
579     return; /* All zero. */
580   for (i=0; i< 20; i++)
581     sprintf (buf+2*i, "%02X", fpr[i]);
582   if (number == -1)
583     *numbuf = 0; /* Don't print the key number */
584   else
585     sprintf (numbuf, "%d", number);
586   send_status_info (ctrl, keyword,
587                     numbuf, (size_t)strlen(numbuf),
588                     buf, (size_t)strlen (buf), NULL, 0);
589 }
590
591 static void
592 send_fprtime_if_not_null (ctrl_t ctrl, const char *keyword,
593                           int number, const unsigned char *stamp)
594 {                      
595   char numbuf1[50], numbuf2[50];
596   unsigned long value;
597
598   value = (stamp[0] << 24) | (stamp[1]<<16) | (stamp[2]<<8) | stamp[3];
599   if (!value)
600     return;
601   sprintf (numbuf1, "%d", number);
602   sprintf (numbuf2, "%lu", value);
603   send_status_info (ctrl, keyword,
604                     numbuf1, (size_t)strlen(numbuf1),
605                     numbuf2, (size_t)strlen(numbuf2), NULL, 0);
606 }
607
608 static void
609 send_key_data (ctrl_t ctrl, const char *name, 
610                const unsigned char *a, size_t alen)
611 {
612   char *p, *buf = xmalloc (alen*2+1);
613   
614   for (p=buf; alen; a++, alen--, p += 2)
615     sprintf (p, "%02X", *a);
616
617   send_status_info (ctrl, "KEY-DATA",
618                     name, (size_t)strlen(name), 
619                     buf, (size_t)strlen (buf),
620                     NULL, 0);
621   xfree (buf);
622 }
623
624 /* Implement the GETATTR command.  This is similar to the LEARN
625    command but returns just one value via the status interface. */
626 static int 
627 do_getattr (app_t app, ctrl_t ctrl, const char *name)
628 {
629   static struct {
630     const char *name;
631     int tag;
632     int special;
633   } table[] = {
634     { "DISP-NAME",    0x005B },
635     { "LOGIN-DATA",   0x005E },
636     { "DISP-LANG",    0x5F2D },
637     { "DISP-SEX",     0x5F35 },
638     { "PUBKEY-URL",   0x5F50 },
639     { "KEY-FPR",      0x00C5, 3 },
640     { "KEY-TIME",     0x00CD, 4 },
641     { "CA-FPR",       0x00C6, 3 },
642     { "CHV-STATUS",   0x00C4, 1 }, 
643     { "SIG-COUNTER",  0x0093, 2 },
644     { "SERIALNO",     0x004F, -1 },
645     { "AID",          0x004F },
646     { "EXTCAP",       0x0000, -2 },
647     { "PRIVATE-DO-1", 0x0101 },
648     { "PRIVATE-DO-2", 0x0102 },
649     { "PRIVATE-DO-3", 0x0103 },
650     { "PRIVATE-DO-4", 0x0104 },
651     { NULL, 0 }
652   };
653   int idx, i;
654   void *relptr;
655   unsigned char *value;
656   size_t valuelen;
657
658   for (idx=0; table[idx].name && strcmp (table[idx].name, name); idx++)
659     ;
660   if (!table[idx].name)
661     return gpg_error (GPG_ERR_INV_NAME); 
662   
663   if (table[idx].special == -1)
664     {
665       /* The serial number is very special.  We could have used the
666          AID DO to retrieve it, but we have it already in the app
667          context and the stamp argument is required anyway which we
668          can't by other means. The AID DO is available anyway but not
669          hex formatted. */
670       char *serial;
671       time_t stamp;
672       char tmp[50];
673
674       if (!app_get_serial_and_stamp (app, &serial, &stamp))
675         {
676           sprintf (tmp, "%lu", (unsigned long)stamp);
677           send_status_info (ctrl, "SERIALNO",
678                             serial, strlen (serial),
679                             tmp, strlen (tmp),
680                             NULL, 0);
681           xfree (serial);
682         }
683       return 0;
684     }
685   if (table[idx].special == -2)
686     {
687       char tmp[50];
688
689       sprintf (tmp, "gc=%d ki=%d fc=%d pd=%d", 
690                app->app_local->extcap.get_challenge,
691                app->app_local->extcap.key_import,
692                app->app_local->extcap.change_force_chv,
693                app->app_local->extcap.private_dos);
694       send_status_info (ctrl, table[idx].name, tmp, strlen (tmp), NULL, 0);
695       return 0;
696     }
697
698   relptr = get_one_do (app, table[idx].tag, &value, &valuelen);
699   if (relptr)
700     {
701       if (table[idx].special == 1)
702         {
703           char numbuf[7*23];
704           
705           for (i=0,*numbuf=0; i < valuelen && i < 7; i++)
706             sprintf (numbuf+strlen (numbuf), " %d", value[i]); 
707           send_status_info (ctrl, table[idx].name,
708                             numbuf, strlen (numbuf), NULL, 0);
709         }
710       else if (table[idx].special == 2)
711         {
712           char numbuf[50];
713
714           sprintf (numbuf, "%lu", convert_sig_counter_value (value, valuelen));
715           send_status_info (ctrl, table[idx].name,
716                             numbuf, strlen (numbuf), NULL, 0);
717         }
718       else if (table[idx].special == 3)
719         {
720           if (valuelen >= 60)
721             for (i=0; i < 3; i++)
722               send_fpr_if_not_null (ctrl, table[idx].name, i+1, value+i*20);
723         }
724       else if (table[idx].special == 4)
725         {
726           if (valuelen >= 12)
727             for (i=0; i < 3; i++)
728               send_fprtime_if_not_null (ctrl, table[idx].name, i+1, value+i*4);
729         }
730       else
731         send_status_info (ctrl, table[idx].name, value, valuelen, NULL, 0);
732
733       xfree (relptr);
734     }
735   return 0;
736 }
737
738
739 static int
740 do_learn_status (app_t app, ctrl_t ctrl)
741 {
742   do_getattr (app, ctrl, "EXTCAP");
743   do_getattr (app, ctrl, "DISP-NAME");
744   do_getattr (app, ctrl, "DISP-LANG");
745   do_getattr (app, ctrl, "DISP-SEX");
746   do_getattr (app, ctrl, "PUBKEY-URL");
747   do_getattr (app, ctrl, "LOGIN-DATA");
748   do_getattr (app, ctrl, "KEY-FPR");
749   if (app->card_version > 0x0100)
750     do_getattr (app, ctrl, "KEY-TIME");
751   do_getattr (app, ctrl, "CA-FPR");
752   do_getattr (app, ctrl, "CHV-STATUS");
753   do_getattr (app, ctrl, "SIG-COUNTER");
754   if (app->app_local->extcap.private_dos)
755     {
756       do_getattr (app, ctrl, "PRIVATE-DO-1");
757       do_getattr (app, ctrl, "PRIVATE-DO-2");
758       if (app->did_chv2)
759         do_getattr (app, ctrl, "PRIVATE-DO-3");
760       if (app->did_chv3)
761         do_getattr (app, ctrl, "PRIVATE-DO-4");
762     }
763
764   return 0;
765 }
766
767
768 /* Verify CHV2 if required.  Depending on the configuration of the
769    card CHV1 will also be verified. */
770 static int
771 verify_chv2 (app_t app,
772              int (*pincb)(void*, const char *, char **),
773              void *pincb_arg)
774 {
775   int rc = 0;
776
777   if (!app->did_chv2) 
778     {
779       char *pinvalue;
780
781       rc = pincb (pincb_arg, "PIN", &pinvalue); 
782       if (rc)
783         {
784           log_info (_("PIN callback returned error: %s\n"), gpg_strerror (rc));
785           return rc;
786         }
787
788       if (strlen (pinvalue) < 6)
789         {
790           log_error (_("PIN for CHV%d is too short;"
791                        " minimum length is %d\n"), 2, 6);
792           xfree (pinvalue);
793           return gpg_error (GPG_ERR_BAD_PIN);
794         }
795
796       rc = iso7816_verify (app->slot, 0x82, pinvalue, strlen (pinvalue));
797       if (rc)
798         {
799           log_error (_("verify CHV%d failed: %s\n"), 2, gpg_strerror (rc));
800           xfree (pinvalue);
801           flush_cache_after_error (app);
802           return rc;
803         }
804       app->did_chv2 = 1;
805
806       if (!app->did_chv1 && !app->force_chv1)
807         {
808           rc = iso7816_verify (app->slot, 0x81, pinvalue, strlen (pinvalue));
809           if (gpg_err_code (rc) == GPG_ERR_BAD_PIN)
810             rc = gpg_error (GPG_ERR_PIN_NOT_SYNCED);
811           if (rc)
812             {
813               log_error (_("verify CHV%d failed: %s\n"), 1, gpg_strerror (rc));
814               xfree (pinvalue);
815               flush_cache_after_error (app);
816               return rc;
817             }
818           app->did_chv1 = 1;
819         }
820       xfree (pinvalue);
821     }
822   return rc;
823 }
824
825 /* Verify CHV3 if required. */
826 static int
827 verify_chv3 (app_t app,
828              int (*pincb)(void*, const char *, char **),
829              void *pincb_arg)
830 {
831   int rc = 0;
832
833 #if GNUPG_MAJOR_VERSION != 1
834   if (!opt.allow_admin)
835     {
836       log_info (_("access to admin commands is not configured\n"));
837       return gpg_error (GPG_ERR_EACCES);
838     }
839 #endif
840       
841   if (!app->did_chv3) 
842     {
843       char *pinvalue;
844       void *relptr;
845       unsigned char *value;
846       size_t valuelen;
847
848       relptr = get_one_do (app, 0x00C4, &value, &valuelen);
849       if (!relptr || valuelen < 7)
850         {
851           log_error (_("error retrieving CHV status from card\n"));
852           xfree (relptr);
853           return gpg_error (GPG_ERR_CARD);
854         }
855       if (value[6] == 0)
856         {
857           log_info (_("card is permanently locked!\n"));
858           xfree (relptr);
859           return gpg_error (GPG_ERR_BAD_PIN);
860         }
861
862       log_info(_("%d Admin PIN attempts remaining before card"
863                  " is permanently locked\n"), value[6]);
864       xfree (relptr);
865
866       /* TRANSLATORS: Do not translate the "|A|" prefix but
867          keep it at the start of the string.  We need this elsewhere
868          to get some infos on the string. */
869       rc = pincb (pincb_arg, _("|A|Admin PIN"), &pinvalue); 
870       if (rc)
871         {
872           log_info (_("PIN callback returned error: %s\n"), gpg_strerror (rc));
873           return rc;
874         }
875
876       if (strlen (pinvalue) < 8)
877         {
878           log_error (_("PIN for CHV%d is too short;"
879                        " minimum length is %d\n"), 3, 8);
880           xfree (pinvalue);
881           return gpg_error (GPG_ERR_BAD_PIN);
882         }
883
884       rc = iso7816_verify (app->slot, 0x83, pinvalue, strlen (pinvalue));
885       xfree (pinvalue);
886       if (rc)
887         {
888           log_error (_("verify CHV%d failed: %s\n"), 3, gpg_strerror (rc));
889           flush_cache_after_error (app);
890           return rc;
891         }
892       app->did_chv3 = 1;
893     }
894   return rc;
895 }
896
897
898 /* Handle the SETATTR operation. All arguments are already basically
899    checked. */
900 static int 
901 do_setattr (app_t app, const char *name,
902             int (*pincb)(void*, const char *, char **),
903             void *pincb_arg,
904             const unsigned char *value, size_t valuelen)
905 {
906   gpg_error_t rc;
907   int idx;
908   static struct {
909     const char *name;
910     int tag;
911     int need_chv;
912     int special;
913   } table[] = {
914     { "DISP-NAME",    0x005B, 3 },
915     { "LOGIN-DATA",   0x005E, 3, 2 },
916     { "DISP-LANG",    0x5F2D, 3 },
917     { "DISP-SEX",     0x5F35, 3 },
918     { "PUBKEY-URL",   0x5F50, 3 },
919     { "CHV-STATUS-1", 0x00C4, 3, 1 },
920     { "CA-FPR-1",     0x00CA, 3 },
921     { "CA-FPR-2",     0x00CB, 3 },
922     { "CA-FPR-3",     0x00CC, 3 },
923     { "PRIVATE-DO-1", 0x0101, 2 },
924     { "PRIVATE-DO-2", 0x0102, 3 },
925     { "PRIVATE-DO-3", 0x0103, 2 },
926     { "PRIVATE-DO-4", 0x0104, 3 },
927     { NULL, 0 }
928   };
929
930
931   for (idx=0; table[idx].name && strcmp (table[idx].name, name); idx++)
932     ;
933   if (!table[idx].name)
934     return gpg_error (GPG_ERR_INV_NAME); 
935
936   switch (table[idx].need_chv)
937     {
938     case 2:
939       rc = verify_chv2 (app, pincb, pincb_arg);
940       break;
941     case 3:
942       rc = verify_chv3 (app, pincb, pincb_arg);
943       break;
944     default:
945       rc = 0;
946     }
947   if (rc)
948     return rc;
949
950   /* Flush the cache before writing it, so that the next get operation
951      will reread the data from the card and thus get synced in case of
952      errors (e.g. data truncated by the card). */
953   flush_cache_item (app, table[idx].tag);
954   rc = iso7816_put_data (app->slot, table[idx].tag, value, valuelen);
955   if (rc)
956     log_error ("failed to set `%s': %s\n", table[idx].name, gpg_strerror (rc));
957
958   if (table[idx].special == 1)
959     app->force_chv1 = (valuelen && *value == 0);
960   else if (table[idx].special == 2)
961     parse_login_data (app);
962
963   return rc;
964 }
965
966
967 /* Handle the PASSWD command. */
968 static int 
969 do_change_pin (app_t app, ctrl_t ctrl,  const char *chvnostr, int reset_mode,
970                int (*pincb)(void*, const char *, char **),
971                void *pincb_arg)
972 {
973   int rc = 0;
974   int chvno = atoi (chvnostr);
975   char *pinvalue;
976
977   if (reset_mode && chvno == 3)
978     {
979       rc = gpg_error (GPG_ERR_INV_ID);
980       goto leave;
981     }
982   else if (reset_mode || chvno == 3)
983     {
984       /* we always require that the PIN is entered. */
985       app->did_chv3 = 0;
986       rc = verify_chv3 (app, pincb, pincb_arg);
987       if (rc)
988         goto leave;
989     }
990   else if (chvno == 1 || chvno == 2)
991     {
992       /* CHV1 and CVH2 should always have the same value, thus we
993          enforce it here.  */
994       int save_force = app->force_chv1;
995
996       app->force_chv1 = 0;
997       app->did_chv1 = 0;
998       app->did_chv2 = 0;
999       rc = verify_chv2 (app, pincb, pincb_arg);
1000       app->force_chv1 = save_force;
1001       if (rc)
1002         goto leave;
1003     }
1004   else
1005     {
1006       rc = gpg_error (GPG_ERR_INV_ID);
1007       goto leave;
1008     }
1009
1010   if (chvno == 3)
1011     app->did_chv3 = 0;
1012   else
1013     app->did_chv1 = app->did_chv2 = 0;
1014
1015   /* TRANSLATORS: Do not translate the "|*|" prefixes but
1016      keep it at the start of the string.  We need this elsewhere
1017      to get some infos on the string. */
1018   rc = pincb (pincb_arg, chvno == 3? _("|AN|New Admin PIN") : _("|N|New PIN"), 
1019               &pinvalue); 
1020   if (rc)
1021     {
1022       log_error (_("error getting new PIN: %s\n"), gpg_strerror (rc));
1023       goto leave;
1024     }
1025
1026   if (reset_mode)
1027     {
1028       rc = iso7816_reset_retry_counter (app->slot, 0x81,
1029                                         pinvalue, strlen (pinvalue));
1030       if (!rc)
1031         rc = iso7816_reset_retry_counter (app->slot, 0x82,
1032                                           pinvalue, strlen (pinvalue));
1033     }
1034   else
1035     {
1036       if (chvno == 1 || chvno == 2)
1037         {
1038           rc = iso7816_change_reference_data (app->slot, 0x81, NULL, 0,
1039                                               pinvalue, strlen (pinvalue));
1040           if (!rc)
1041             rc = iso7816_change_reference_data (app->slot, 0x82, NULL, 0,
1042                                                 pinvalue, strlen (pinvalue));
1043         }
1044       else
1045         rc = iso7816_change_reference_data (app->slot, 0x80 + chvno, NULL, 0,
1046                                             pinvalue, strlen (pinvalue));
1047     }
1048   xfree (pinvalue);
1049   if (rc)
1050     flush_cache_after_error (app);
1051
1052  leave:
1053   return rc;
1054 }
1055
1056
1057
1058 /* Handle the GENKEY command. */
1059 static int 
1060 do_genkey (app_t app, ctrl_t ctrl,  const char *keynostr, unsigned int flags,
1061           int (*pincb)(void*, const char *, char **),
1062           void *pincb_arg)
1063 {
1064   int rc;
1065   int i;
1066   char numbuf[30];
1067   unsigned char fprbuf[20];
1068   const unsigned char *fpr;
1069   const unsigned char *keydata, *m, *e;
1070   unsigned char *buffer;
1071   size_t buflen, keydatalen, n, mlen, elen;
1072   time_t created_at;
1073   int keyno = atoi (keynostr);
1074   int force = (flags & 1);
1075   time_t start_at;
1076
1077   if (keyno < 1 || keyno > 3)
1078     return gpg_error (GPG_ERR_INV_ID);
1079   keyno--;
1080
1081   /* We flush the cache to increase the traffic before a key
1082      generation.  This _might_ help a card to gather more entropy. */
1083   flush_cache (app);
1084
1085   rc = iso7816_get_data (app->slot, 0x006E, &buffer, &buflen);
1086   if (rc)
1087     {
1088       log_error (_("error reading application data\n"));
1089       return gpg_error (GPG_ERR_GENERAL);
1090     }
1091   fpr = find_tlv (buffer, buflen, 0x00C5, &n);
1092   if (!fpr || n != 60)
1093     {
1094       rc = gpg_error (GPG_ERR_GENERAL);
1095       log_error (_("error reading fingerprint DO\n"));
1096       goto leave;
1097     }
1098   fpr += 20*keyno;
1099   for (i=0; i < 20 && !fpr[i]; i++)
1100     ;
1101   if (i!=20 && !force)
1102     {
1103       rc = gpg_error (GPG_ERR_EEXIST);
1104       log_error (_("key already exists\n"));
1105       goto leave;
1106     }
1107   else if (i!=20)
1108     log_info (_("existing key will be replaced\n"));
1109   else
1110     log_info (_("generating new key\n"));
1111
1112
1113   rc = verify_chv3 (app, pincb, pincb_arg);
1114   if (rc)
1115     goto leave;
1116
1117   xfree (buffer); buffer = NULL;
1118
1119 #if 1
1120   log_info (_("please wait while key is being generated ...\n"));
1121   start_at = time (NULL);
1122   rc = iso7816_generate_keypair 
1123 #else
1124 #warning key generation temporary replaced by reading an existing key.
1125   rc = iso7816_read_public_key
1126 #endif
1127                               (app->slot, 
1128                                  keyno == 0? "\xB6" :
1129                                  keyno == 1? "\xB8" : "\xA4",
1130                                  2,
1131                                  &buffer, &buflen);
1132   if (rc)
1133     {
1134       rc = gpg_error (GPG_ERR_CARD);
1135       log_error (_("generating key failed\n"));
1136       goto leave;
1137     }
1138   log_info (_("key generation completed (%d seconds)\n"),
1139             (int)(time (NULL) - start_at));
1140   keydata = find_tlv (buffer, buflen, 0x7F49, &keydatalen);
1141   if (!keydata)
1142     {
1143       rc = gpg_error (GPG_ERR_CARD);
1144       log_error (_("response does not contain the public key data\n"));
1145       goto leave;
1146     }
1147  
1148   m = find_tlv (keydata, keydatalen, 0x0081, &mlen);
1149   if (!m)
1150     {
1151       rc = gpg_error (GPG_ERR_CARD);
1152       log_error (_("response does not contain the RSA modulus\n"));
1153       goto leave;
1154     }
1155 /*    log_printhex ("RSA n:", m, mlen); */
1156   send_key_data (ctrl, "n", m, mlen);
1157
1158   e = find_tlv (keydata, keydatalen, 0x0082, &elen);
1159   if (!e)
1160     {
1161       rc = gpg_error (GPG_ERR_CARD);
1162       log_error (_("response does not contain the RSA public exponent\n"));
1163       goto leave;
1164     }
1165 /*    log_printhex ("RSA e:", e, elen); */
1166   send_key_data (ctrl, "e", e, elen);
1167
1168   created_at = gnupg_get_time ();
1169   sprintf (numbuf, "%lu", (unsigned long)created_at);
1170   send_status_info (ctrl, "KEY-CREATED-AT",
1171                     numbuf, (size_t)strlen(numbuf), NULL, 0);
1172
1173   rc = store_fpr (app->slot, keyno, (u32)created_at,
1174                   m, mlen, e, elen, fprbuf, app->card_version);
1175   if (rc)
1176     goto leave;
1177   send_fpr_if_not_null (ctrl, "KEY-FPR", -1, fprbuf);
1178
1179
1180  leave:
1181   xfree (buffer);
1182   return rc;
1183 }
1184
1185
1186 static unsigned long
1187 convert_sig_counter_value (const unsigned char *value, size_t valuelen)
1188 {
1189   unsigned long ul;
1190
1191   if (valuelen == 3 )
1192     ul = (value[0] << 16) | (value[1] << 8) | value[2];
1193   else
1194     {
1195       log_error (_("invalid structure of OpenPGP card (DO 0x93)\n"));
1196       ul = 0;
1197     }
1198   return ul;
1199 }
1200
1201 static unsigned long
1202 get_sig_counter (app_t app)
1203 {
1204   void *relptr;
1205   unsigned char *value;
1206   size_t valuelen;
1207   unsigned long ul;
1208
1209   relptr = get_one_do (app, 0x0093, &value, &valuelen);
1210   if (!relptr)
1211     return 0;
1212   ul = convert_sig_counter_value (value, valuelen);
1213   xfree (relptr);
1214   return ul;
1215 }
1216
1217 static int
1218 compare_fingerprint (app_t app, int keyno, unsigned char *sha1fpr)
1219 {
1220   const unsigned char *fpr;
1221   unsigned char *buffer;
1222   size_t buflen, n;
1223   int rc, i;
1224   
1225   assert (keyno >= 1 && keyno <= 3);
1226
1227   rc = get_cached_data (app, 0x006E, &buffer, &buflen, 0);
1228   if (rc)
1229     {
1230       log_error (_("error reading application data\n"));
1231       return gpg_error (GPG_ERR_GENERAL);
1232     }
1233   fpr = find_tlv (buffer, buflen, 0x00C5, &n);
1234   if (!fpr || n != 60)
1235     {
1236       xfree (buffer);
1237       log_error (_("error reading fingerprint DO\n"));
1238       return gpg_error (GPG_ERR_GENERAL);
1239     }
1240   fpr += (keyno-1)*20;
1241   for (i=0; i < 20; i++)
1242     if (sha1fpr[i] != fpr[i])
1243       {
1244         xfree (buffer);
1245         return gpg_error (GPG_ERR_WRONG_SECKEY);
1246       }
1247   xfree (buffer);
1248   return 0;
1249 }
1250
1251
1252   /* If a fingerprint has been specified check it against the one on
1253      the card.  This is allows for a meaningful error message in case
1254      the key on the card has been replaced but the shadow information
1255      known to gpg was not updated.  If there is no fingerprint we
1256      assume that this is okay. */
1257 static int
1258 check_against_given_fingerprint (app_t app, const char *fpr, int keyno)
1259 {
1260   unsigned char tmp[20];
1261   const char *s;
1262   int n;
1263
1264   for (s=fpr, n=0; hexdigitp (s); s++, n++)
1265     ;
1266   if (n != 40)
1267     return gpg_error (GPG_ERR_INV_ID);
1268   else if (!*s)
1269     ; /* okay */
1270   else
1271     return gpg_error (GPG_ERR_INV_ID);
1272
1273   for (s=fpr, n=0; n < 20; s += 2, n++)
1274         tmp[n] = xtoi_2 (s);
1275   return compare_fingerprint (app, keyno, tmp);
1276 }
1277
1278
1279
1280 /* Compute a digital signature on INDATA which is expected to be the
1281    raw message digest. For this application the KEYIDSTR consists of
1282    the serialnumber and the fingerprint delimited by a slash.
1283
1284    Note that this fucntion may return the error code
1285    GPG_ERR_WRONG_CARD to indicate that the card currently present does
1286    not match the one required for the requested action (e.g. the
1287    serial number does not match). */
1288 static int 
1289 do_sign (app_t app, const char *keyidstr, int hashalgo,
1290          int (*pincb)(void*, const char *, char **),
1291          void *pincb_arg,
1292          const void *indata, size_t indatalen,
1293          unsigned char **outdata, size_t *outdatalen )
1294 {
1295   static unsigned char sha1_prefix[15] = /* Object ID is 1.3.14.3.2.26 */
1296   { 0x30, 0x21, 0x30, 0x09, 0x06, 0x05, 0x2b, 0x0e, 0x03,
1297     0x02, 0x1a, 0x05, 0x00, 0x04, 0x14 };
1298   static unsigned char rmd160_prefix[15] = /* Object ID is 1.3.36.3.2.1 */
1299   { 0x30, 0x21, 0x30, 0x09, 0x06, 0x05, 0x2b, 0x24, 0x03,
1300     0x02, 0x01, 0x05, 0x00, 0x04, 0x14 };
1301   int rc;
1302   unsigned char data[35];
1303   unsigned char tmp_sn[20]; /* actually 16 but we use it also for the fpr. */
1304   const char *s;
1305   int n;
1306   const char *fpr = NULL;
1307   unsigned long sigcount;
1308
1309   if (!keyidstr || !*keyidstr)
1310     return gpg_error (GPG_ERR_INV_VALUE);
1311   if (indatalen != 20)
1312     return gpg_error (GPG_ERR_INV_VALUE);
1313
1314   /* Check whether an OpenPGP card of any version has been requested. */
1315   if (strlen (keyidstr) < 32 || strncmp (keyidstr, "D27600012401", 12))
1316     return gpg_error (GPG_ERR_INV_ID);
1317   
1318   for (s=keyidstr, n=0; hexdigitp (s); s++, n++)
1319     ;
1320   if (n != 32)
1321     return gpg_error (GPG_ERR_INV_ID);
1322   else if (!*s)
1323     ; /* no fingerprint given: we allow this for now. */
1324   else if (*s == '/')
1325     fpr = s + 1; 
1326   else
1327     return gpg_error (GPG_ERR_INV_ID);
1328
1329   for (s=keyidstr, n=0; n < 16; s += 2, n++)
1330     tmp_sn[n] = xtoi_2 (s);
1331
1332   if (app->serialnolen != 16)
1333     return gpg_error (GPG_ERR_INV_CARD);
1334   if (memcmp (app->serialno, tmp_sn, 16))
1335     return gpg_error (GPG_ERR_WRONG_CARD);
1336
1337   /* If a fingerprint has been specified check it against the one on
1338      the card.  This is allows for a meaningful error message in case
1339      the key on the card has been replaced but the shadow information
1340      known to gpg was not updated.  If there is no fingerprint, gpg
1341      will detect a bogus signature anyway due to the
1342      verify-after-signing feature. */
1343   rc = fpr? check_against_given_fingerprint (app, fpr, 1) : 0;
1344   if (rc)
1345     return rc;
1346
1347   if (hashalgo == GCRY_MD_SHA1)
1348     memcpy (data, sha1_prefix, 15);
1349   else if (hashalgo == GCRY_MD_RMD160)
1350     memcpy (data, rmd160_prefix, 15);
1351   else 
1352     return gpg_error (GPG_ERR_UNSUPPORTED_ALGORITHM);
1353   memcpy (data+15, indata, indatalen);
1354
1355   sigcount = get_sig_counter (app);
1356   log_info (_("signatures created so far: %lu\n"), sigcount);
1357
1358   if (!app->did_chv1 || app->force_chv1 ) 
1359     {
1360       char *pinvalue;
1361
1362       {
1363         char *prompt;
1364 #define PROMPTSTRING  _("PIN [sigs done: %lu]")
1365
1366         prompt = malloc (strlen (PROMPTSTRING) + 50);
1367         if (!prompt)
1368           return gpg_error_from_errno (errno);
1369         sprintf (prompt, PROMPTSTRING, sigcount);
1370         rc = pincb (pincb_arg, prompt, &pinvalue); 
1371         free (prompt);
1372 #undef PROMPTSTRING
1373       }
1374       if (rc)
1375         {
1376           log_info (_("PIN callback returned error: %s\n"), gpg_strerror (rc));
1377           return rc;
1378         }
1379
1380       if (strlen (pinvalue) < 6)
1381         {
1382           log_error (_("PIN for CHV%d is too short;"
1383                        " minimum length is %d\n"), 1, 6);
1384           xfree (pinvalue);
1385           return gpg_error (GPG_ERR_BAD_PIN);
1386         }
1387
1388       rc = iso7816_verify (app->slot, 0x81, pinvalue, strlen (pinvalue));
1389       if (rc)
1390         {
1391           log_error (_("verify CHV%d failed: %s\n"), 1, gpg_strerror (rc));
1392           xfree (pinvalue);
1393           flush_cache_after_error (app);
1394           return rc;
1395         }
1396       app->did_chv1 = 1;
1397       if (!app->did_chv2)
1398         {
1399           /* We should also verify CHV2. */
1400           rc = iso7816_verify (app->slot, 0x82, pinvalue, strlen (pinvalue));
1401           if (gpg_err_code (rc) == GPG_ERR_BAD_PIN)
1402             rc = gpg_error (GPG_ERR_PIN_NOT_SYNCED);
1403           if (rc)
1404             {
1405               log_error (_("verify CHV%d failed: %s\n"), 2, gpg_strerror (rc));
1406               xfree (pinvalue);
1407               flush_cache_after_error (app);
1408               return rc;
1409             }
1410           app->did_chv2 = 1;
1411         }
1412       xfree (pinvalue);
1413     }
1414
1415   rc = iso7816_compute_ds (app->slot, data, 35, outdata, outdatalen);
1416   return rc;
1417 }
1418
1419 /* Compute a digital signature using the INTERNAL AUTHENTICATE command
1420    on INDATA which is expected to be the raw message digest. For this
1421    application the KEYIDSTR consists of the serialnumber and the
1422    fingerprint delimited by a slash.
1423
1424    Note that this fucntion may return the error code
1425    GPG_ERR_WRONG_CARD to indicate that the card currently present does
1426    not match the one required for the requested action (e.g. the
1427    serial number does not match). */
1428 static int 
1429 do_auth (app_t app, const char *keyidstr,
1430          int (*pincb)(void*, const char *, char **),
1431          void *pincb_arg,
1432          const void *indata, size_t indatalen,
1433          unsigned char **outdata, size_t *outdatalen )
1434 {
1435   int rc;
1436   unsigned char tmp_sn[20]; /* actually 16 but we use it also for the fpr. */
1437   const char *s;
1438   int n;
1439   const char *fpr = NULL;
1440
1441   if (!keyidstr || !*keyidstr)
1442     return gpg_error (GPG_ERR_INV_VALUE);
1443   if (indatalen > 50) /* For a 1024 bit key. */
1444     return gpg_error (GPG_ERR_INV_VALUE);
1445
1446   /* Check whether an OpenPGP card of any version has been requested. */
1447   if (strlen (keyidstr) < 32 || strncmp (keyidstr, "D27600012401", 12))
1448     return gpg_error (GPG_ERR_INV_ID);
1449   
1450   for (s=keyidstr, n=0; hexdigitp (s); s++, n++)
1451     ;
1452   if (n != 32)
1453     return gpg_error (GPG_ERR_INV_ID);
1454   else if (!*s)
1455     ; /* no fingerprint given: we allow this for now. */
1456   else if (*s == '/')
1457     fpr = s + 1; 
1458   else
1459     return gpg_error (GPG_ERR_INV_ID);
1460
1461   for (s=keyidstr, n=0; n < 16; s += 2, n++)
1462     tmp_sn[n] = xtoi_2 (s);
1463
1464   if (app->serialnolen != 16)
1465     return gpg_error (GPG_ERR_INV_CARD);
1466   if (memcmp (app->serialno, tmp_sn, 16))
1467     return gpg_error (GPG_ERR_WRONG_CARD);
1468
1469   /* If a fingerprint has been specified check it against the one on
1470      the card.  This is allows for a meaningful error message in case
1471      the key on the card has been replaced but the shadow information
1472      known to gpg was not updated.  If there is no fingerprint, gpg
1473      will detect a bogus signature anyway due to the
1474      verify-after-signing feature. */
1475   rc = fpr? check_against_given_fingerprint (app, fpr, 3) : 0;
1476   if (rc)
1477     return rc;
1478
1479   rc = verify_chv2 (app, pincb, pincb_arg);
1480   if (!rc)
1481     rc = iso7816_internal_authenticate (app->slot, indata, indatalen,
1482                                         outdata, outdatalen);
1483   return rc;
1484 }
1485
1486
1487 static int 
1488 do_decipher (app_t app, const char *keyidstr,
1489              int (pincb)(void*, const char *, char **),
1490              void *pincb_arg,
1491              const void *indata, size_t indatalen,
1492              unsigned char **outdata, size_t *outdatalen )
1493 {
1494   int rc;
1495   unsigned char tmp_sn[20]; /* actually 16 but we use it also for the fpr. */
1496   const char *s;
1497   int n;
1498   const char *fpr = NULL;
1499
1500   if (!keyidstr || !*keyidstr || !indatalen)
1501     return gpg_error (GPG_ERR_INV_VALUE);
1502
1503   /* Check whether an OpenPGP card of any version has been requested. */
1504   if (strlen (keyidstr) < 32 || strncmp (keyidstr, "D27600012401", 12))
1505     return gpg_error (GPG_ERR_INV_ID);
1506   
1507   for (s=keyidstr, n=0; hexdigitp (s); s++, n++)
1508     ;
1509   if (n != 32)
1510     return gpg_error (GPG_ERR_INV_ID);
1511   else if (!*s)
1512     ; /* no fingerprint given: we allow this for now. */
1513   else if (*s == '/')
1514     fpr = s + 1; 
1515   else
1516     return gpg_error (GPG_ERR_INV_ID);
1517
1518   for (s=keyidstr, n=0; n < 16; s += 2, n++)
1519     tmp_sn[n] = xtoi_2 (s);
1520
1521   if (app->serialnolen != 16)
1522     return gpg_error (GPG_ERR_INV_CARD);
1523   if (memcmp (app->serialno, tmp_sn, 16))
1524     return gpg_error (GPG_ERR_WRONG_CARD);
1525
1526   /* If a fingerprint has been specified check it against the one on
1527      the card.  This is allows for a meaningful error message in case
1528      the key on the card has been replaced but the shadow information
1529      known to gpg was not updated.  If there is no fingerprint, the
1530      decryption will won't produce the right plaintext anyway. */
1531   rc = fpr? check_against_given_fingerprint (app, fpr, 2) : 0;
1532   if (rc)
1533     return rc;
1534
1535   rc = verify_chv2 (app, pincb, pincb_arg);
1536   if (!rc)
1537     rc = iso7816_decipher (app->slot, indata, indatalen, 0,
1538                            outdata, outdatalen);
1539   return rc;
1540 }
1541
1542
1543 /* Perform a simple verify operation for CHV1 and CHV2, so that
1544    further operations won't ask for CHV2 and it is possible to do a
1545    cheap check on the PIN: If there is something wrong with the PIN
1546    entry system, only the regular CHV will get blocked and not the
1547    dangerous CHV3.  KEYIDSTR is the usual card's serial number; an
1548    optional fingerprint part will be ignored. 
1549
1550    There is a special mode if the keyidstr is "<serialno>[CHV3]" with
1551    the "[CHV3]" being a literal string:  The Admin Pin is checked if
1552    and only if the retry counter is still at 3.
1553 */
1554 static int 
1555 do_check_pin (app_t app, const char *keyidstr,
1556               int (pincb)(void*, const char *, char **),
1557               void *pincb_arg)
1558 {
1559   unsigned char tmp_sn[20]; 
1560   const char *s;
1561   int n;
1562   int admin_pin = 0;
1563
1564   if (!keyidstr || !*keyidstr)
1565     return gpg_error (GPG_ERR_INV_VALUE);
1566
1567   /* Check whether an OpenPGP card of any version has been requested. */
1568   if (strlen (keyidstr) < 32 || strncmp (keyidstr, "D27600012401", 12))
1569     return gpg_error (GPG_ERR_INV_ID);
1570   
1571   for (s=keyidstr, n=0; hexdigitp (s); s++, n++)
1572     ;
1573   if (n != 32)
1574     return gpg_error (GPG_ERR_INV_ID);
1575   else if (!*s)
1576     ; /* No fingerprint given: we allow this for now. */
1577   else if (*s == '/')
1578     ; /* We ignore a fingerprint. */
1579   else if (!strcmp (s, "[CHV3]") )
1580     admin_pin = 1;
1581   else
1582     return gpg_error (GPG_ERR_INV_ID);
1583
1584   for (s=keyidstr, n=0; n < 16; s += 2, n++)
1585     tmp_sn[n] = xtoi_2 (s);
1586
1587   if (app->serialnolen != 16)
1588     return gpg_error (GPG_ERR_INV_CARD);
1589   if (memcmp (app->serialno, tmp_sn, 16))
1590     return gpg_error (GPG_ERR_WRONG_CARD);
1591   /* Yes, there is a race conditions: The user might pull the card
1592      right here and we won't notice that.  However this is not a
1593      problem and the check above is merely for a graceful failure
1594      between operations. */
1595
1596   if (admin_pin)
1597     {
1598       void *relptr;
1599       unsigned char *value;
1600       size_t valuelen;
1601       int count;
1602       
1603       relptr = get_one_do (app, 0x00C4, &value, &valuelen);
1604       if (!relptr || valuelen < 7)
1605         {
1606           log_error (_("error retrieving CHV status from card\n"));
1607           xfree (relptr);
1608           return gpg_error (GPG_ERR_CARD);
1609         }
1610       count = value[6];
1611       xfree (relptr);
1612
1613       if (!count)
1614         {
1615           log_info (_("card is permanently locked!\n"));
1616           return gpg_error (GPG_ERR_BAD_PIN);
1617         }
1618       else if (value[6] < 3)
1619         {
1620           log_info (_("verification of Admin PIN is currently prohibited "
1621                       "through this command\n"));
1622           return gpg_error (GPG_ERR_GENERAL);
1623         }
1624
1625       app->did_chv3 = 0; /* Force verification.  */
1626       return verify_chv3 (app, pincb, pincb_arg);
1627     }
1628   else
1629     return verify_chv2 (app, pincb, pincb_arg);
1630 }
1631
1632
1633
1634
1635 /* Select the OpenPGP application on the card in SLOT.  This function
1636    must be used before any other OpenPGP application functions. */
1637 int
1638 app_select_openpgp (app_t app)
1639 {
1640   static char const aid[] = { 0xD2, 0x76, 0x00, 0x01, 0x24, 0x01 };
1641   int slot = app->slot;
1642   int rc;
1643   unsigned char *buffer;
1644   size_t buflen;
1645   void *relptr;
1646   
1647   rc = iso7816_select_application (slot, aid, sizeof aid);
1648   if (!rc)
1649     {
1650       unsigned int manufacturer;
1651
1652       app->apptype = "OPENPGP";
1653
1654       app->did_chv1 = 0;
1655       app->did_chv2 = 0;
1656       app->did_chv3 = 0;
1657       app->app_local = NULL;
1658
1659       /* The OpenPGP card returns the serial number as part of the
1660          AID; because we prefer to use OpenPGP serial numbers, we
1661          replace a possibly already set one from a EF.GDO with this
1662          one.  Note, that for current OpenPGP cards, no EF.GDO exists
1663          and thus it won't matter at all. */
1664       rc = iso7816_get_data (slot, 0x004F, &buffer, &buflen);
1665       if (rc)
1666         goto leave;
1667       if (opt.verbose)
1668         {
1669           log_info ("AID: ");
1670           log_printhex ("", buffer, buflen);
1671         }
1672
1673       app->card_version = buffer[6] << 8;
1674       app->card_version |= buffer[7];
1675       manufacturer = (buffer[8]<<8 | buffer[9]);
1676
1677       xfree (app->serialno);
1678       app->serialno = buffer;
1679       app->serialnolen = buflen;
1680       buffer = NULL;
1681       app->app_local = xtrycalloc (1, sizeof *app->app_local);
1682       if (!app->app_local)
1683         {
1684           rc = gpg_error (gpg_err_code_from_errno (errno));
1685           goto leave;
1686         }
1687
1688       relptr = get_one_do (app, 0x00C4, &buffer, &buflen);
1689       if (!relptr)
1690         {
1691           log_error (_("can't access %s - invalid OpenPGP card?\n"),
1692                      "CHV Status Bytes");
1693           goto leave;
1694         }
1695       app->force_chv1 = (buflen && *buffer == 0);
1696       xfree (relptr);
1697
1698       relptr = get_one_do (app, 0x00C0, &buffer, &buflen);
1699       if (!relptr)
1700         {
1701           log_error (_("can't access %s - invalid OpenPGP card?\n"),
1702                      "Extended Capability Flags" );
1703           goto leave;
1704         }
1705       if (buflen)
1706         {
1707           app->app_local->extcap.get_challenge    = !!(*buffer & 0x40);
1708           app->app_local->extcap.key_import       = !!(*buffer & 0x20);
1709           app->app_local->extcap.change_force_chv = !!(*buffer & 0x10);
1710           app->app_local->extcap.private_dos      = !!(*buffer & 0x08);
1711         }
1712       xfree (relptr);
1713       
1714       /* Some of the first cards accidently don't set the
1715          CHANGE_FORCE_CHV bit but allow it anyway. */
1716       if (app->card_version <= 0x0100 && manufacturer == 1)
1717         app->app_local->extcap.change_force_chv = 1;
1718
1719       parse_login_data (app);
1720
1721       if (opt.verbose > 1)
1722         dump_all_do (slot);
1723
1724       app->fnc.deinit = do_deinit;
1725       app->fnc.learn_status = do_learn_status;
1726       app->fnc.readcert = NULL;
1727       app->fnc.getattr = do_getattr;
1728       app->fnc.setattr = do_setattr;
1729       app->fnc.genkey = do_genkey;
1730       app->fnc.sign = do_sign;
1731       app->fnc.auth = do_auth;
1732       app->fnc.decipher = do_decipher;
1733       app->fnc.change_pin = do_change_pin;
1734       app->fnc.check_pin = do_check_pin;
1735    }
1736
1737 leave:
1738   if (rc)
1739     do_deinit (app);
1740   return rc;
1741 }
1742
1743
1744
1745 /* This function is a hack to retrieve essential information about the
1746    card to be displayed by simple tools.  It mostly resembles what the
1747    LEARN command returns. All parameters return allocated strings or
1748    buffers or NULL if the data object is not available.  All returned
1749    values are sanitized. */
1750 int
1751 app_openpgp_cardinfo (app_t app,
1752                       char **serialno,
1753                       char **disp_name,
1754                       char **pubkey_url,
1755                       unsigned char **fpr1,
1756                       unsigned char **fpr2,
1757                       unsigned char **fpr3)
1758 {
1759   int rc;
1760   void *relptr;
1761   unsigned char *value;
1762   size_t valuelen;
1763
1764   if (serialno)
1765     {
1766       time_t dummy;
1767
1768       *serialno = NULL;
1769       rc = app_get_serial_and_stamp (app, serialno, &dummy);
1770       if (rc)
1771         {
1772           log_error (_("error getting serial number: %s\n"),
1773                      gpg_strerror (rc));
1774           return rc;
1775         }
1776     }
1777       
1778   if (disp_name)
1779     {
1780       *disp_name = NULL;
1781       relptr = get_one_do (app, 0x005B, &value, &valuelen);
1782       if (relptr)
1783         {
1784           *disp_name = make_printable_string (value, valuelen, 0);
1785           xfree (relptr);
1786         }
1787     }
1788
1789   if (pubkey_url)
1790     {
1791       *pubkey_url = NULL;
1792       relptr = get_one_do (app, 0x5F50, &value, &valuelen);
1793       if (relptr)
1794         {
1795           *pubkey_url = make_printable_string (value, valuelen, 0);
1796           xfree (relptr);
1797         }
1798     }
1799
1800   if (fpr1)
1801     *fpr1 = NULL;
1802   if (fpr2)
1803     *fpr2 = NULL;
1804   if (fpr3)
1805     *fpr3 = NULL;
1806   relptr = get_one_do (app, 0x00C5, &value, &valuelen);
1807   if (relptr && valuelen >= 60)
1808     {
1809       if (fpr1)
1810         {
1811           *fpr1 = xmalloc (20);
1812           memcpy (*fpr1, value +  0, 20);
1813         }
1814       if (fpr2)
1815         {
1816           *fpr2 = xmalloc (20);
1817           memcpy (*fpr2, value + 20, 20);
1818         }
1819       if (fpr3)
1820         {
1821           *fpr3 = xmalloc (20);
1822           memcpy (*fpr3, value + 40, 20);
1823         }
1824     }
1825   xfree (relptr);
1826
1827   return 0;
1828 }
1829
1830
1831
1832 /* This function is currently only used by the sc-copykeys program to
1833    store a key on the smartcard.  app_t ist the application handle,
1834    KEYNO is the number of the key and PINCB, PINCB_ARG are used to ask
1835    for the SO PIN.  TEMPLATE and TEMPLATE_LEN describe a buffer with
1836    the key template to store. CREATED_AT is the timestamp used to
1837    create the fingerprint. M, MLEN is the RSA modulus and E, ELEN the
1838    RSA public exponent. This function silently overwrites an existing
1839    key.*/
1840 int 
1841 app_openpgp_storekey (app_t app, int keyno,
1842                       unsigned char *template, size_t template_len,
1843                       time_t created_at,
1844                       const unsigned char *m, size_t mlen,
1845                       const unsigned char *e, size_t elen,
1846                       int (*pincb)(void*, const char *, char **),
1847                       void *pincb_arg)
1848 {
1849   int rc;
1850   unsigned char fprbuf[20];
1851
1852   if (keyno < 1 || keyno > 3)
1853     return gpg_error (GPG_ERR_INV_ID);
1854   keyno--;
1855
1856   rc = verify_chv3 (app, pincb, pincb_arg);
1857   if (rc)
1858     goto leave;
1859
1860   flush_cache (app);
1861
1862   rc = iso7816_put_data (app->slot,
1863                          (app->card_version > 0x0007? 0xE0 : 0xE9) + keyno,
1864                          template, template_len);
1865   if (rc)
1866     {
1867       log_error (_("failed to store the key: %s\n"), gpg_strerror (rc));
1868       rc = gpg_error (GPG_ERR_CARD);
1869       goto leave;
1870     }
1871  
1872 /*    log_printhex ("RSA n:", m, mlen);  */
1873 /*    log_printhex ("RSA e:", e, elen);  */
1874
1875   rc = store_fpr (app->slot, keyno, (u32)created_at,
1876                   m, mlen, e, elen, fprbuf, app->card_version);
1877
1878  leave:
1879   return rc;
1880 }
1881
1882
1883 /* Utility function for external tools: Read the public RSA key at
1884    KEYNO and return modulus and exponent in (M,MLEN) and (E,ELEN). */
1885 int 
1886 app_openpgp_readkey (app_t app, int keyno, unsigned char **m, size_t *mlen,
1887                      unsigned char **e, size_t *elen)
1888 {
1889   int rc;
1890   const unsigned char *keydata, *a;
1891   unsigned char *buffer;
1892   size_t buflen, keydatalen, alen;
1893
1894   *m = NULL;
1895   *e = NULL;
1896
1897   if (keyno < 1 || keyno > 3)
1898     return gpg_error (GPG_ERR_INV_ID);
1899   keyno--;
1900
1901   rc = iso7816_read_public_key(app->slot, 
1902                                keyno == 0? "\xB6" :
1903                                keyno == 1? "\xB8" : "\xA4",
1904                                2,
1905                                &buffer, &buflen);
1906   if (rc)
1907     {
1908       rc = gpg_error (GPG_ERR_CARD);
1909       log_error (_("reading the key failed\n"));
1910       goto leave;
1911     }
1912
1913   keydata = find_tlv (buffer, buflen, 0x7F49, &keydatalen);
1914   if (!keydata)
1915     {
1916       log_error (_("response does not contain the public key data\n"));
1917       rc = gpg_error (GPG_ERR_CARD);
1918       goto leave;
1919     }
1920  
1921   a = find_tlv (keydata, keydatalen, 0x0081, &alen);
1922   if (!a)
1923     {
1924       log_error (_("response does not contain the RSA modulus\n"));
1925       rc = gpg_error (GPG_ERR_CARD);
1926       goto leave;
1927     }
1928   *mlen = alen;
1929   *m = xmalloc (alen);
1930   memcpy (*m, a, alen);
1931   
1932   a = find_tlv (keydata, keydatalen, 0x0082, &alen);
1933   if (!a)
1934     {
1935       log_error (_("response does not contain the RSA public exponent\n"));
1936       rc = gpg_error (GPG_ERR_CARD);
1937       goto leave;
1938     }
1939   *elen = alen;
1940   *e = xmalloc (alen);
1941   memcpy (*e, a, alen);
1942
1943  leave:
1944   xfree (buffer);
1945   if (rc)
1946     { 
1947       xfree (*m); *m = NULL;
1948       xfree (*e); *e = NULL;
1949     }
1950   return rc;
1951 }