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