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