2003-09-28 Timo Schulz <twoaday@freakmail.de>
[gnupg.git] / g10 / app-openpgp.c
1 /* app-openpgp.c - The OpenPGP card application.
2  *      Copyright (C) 2003 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
21 #include <config.h>
22 #ifdef ENABLE_CARD_SUPPORT
23 /* 
24    Note, that most of this code has been taken from 1.9.x branch
25    and is maintained over there if at all possible.  Thus, if you make
26    changes here, please check that a similar change has been commited
27    to the 1.9.x branch.
28 */
29 #include <errno.h>
30 #include <stdio.h>
31 #include <stdlib.h>
32 #include <string.h>
33 #include <assert.h>
34 #include <time.h>
35
36 #include "options.h"
37 #include "errors.h"
38 #include "memory.h"
39 #include "util.h"
40 #include "i18n.h"
41
42 #include "iso7816.h"
43 #include "cardglue.h"
44 #include "app-common.h"
45
46 static struct {
47   int tag;
48   int constructed;
49   int get_from;  /* Constructed DO with this DO or 0 for direct access. */
50   int binary;
51   char *desc;
52 } data_objects[] = {
53   { 0x005E, 0,    0, 1, "Login Data" },
54   { 0x5F50, 0,    0, 0, "URL" },
55   { 0x0065, 1,    0, 1, "Cardholder Related Data"},
56   { 0x005B, 0, 0x65, 0, "Name" },
57   { 0x5F2D, 0, 0x65, 0, "Language preferences" },
58   { 0x5F35, 0, 0x65, 0, "Sex" },
59   { 0x006E, 1,    0, 1, "Application Related Data" },
60   { 0x004F, 0, 0x6E, 1, "AID" },
61   { 0x0073, 1,    0, 1, "Discretionary Data Objects" },
62   { 0x0047, 0, 0x6E, 1, "Card Capabilities" },
63   { 0x00C0, 0, 0x6E, 1, "Extended Card Capabilities" },
64   { 0x00C1, 0, 0x6E, 1, "Algorithm Attributes Signature" },
65   { 0x00C2, 0, 0x6E, 1, "Algorithm Attributes Decryption" },
66   { 0x00C3, 0, 0x6E, 1, "Algorithm Attributes Authentication" },
67   { 0x00C4, 0, 0x6E, 1, "CHV Status Bytes" },
68   { 0x00C5, 0, 0x6E, 1, "Fingerprints" },
69   { 0x00C6, 0, 0x6E, 1, "CA Fingerprints" },
70   { 0x007A, 1,    0, 1, "Security Support Template" },
71   { 0x0093, 0, 0x7A, 1, "Digital Signature Counter" },
72   { 0 }
73 };
74
75
76 static unsigned long get_sig_counter (APP app);
77
78
79
80 /* Locate a TLV encoded data object in BUFFER of LENGTH and
81    return a pointer to value as well as its length in NBYTES.  Return
82    NULL if it was not found.  Note, that the function does not check
83    whether the value fits into the provided buffer. 
84
85    FIXME: Move this to an extra file, it is mostly duplicated from card.c.
86 */
87 static const unsigned char *
88 find_tlv (const unsigned char *buffer, size_t length,
89           int tag, size_t *nbytes, int nestlevel)
90 {
91   const unsigned char *s = buffer;
92   size_t n = length;
93   size_t len;
94   int this_tag;
95   int composite;
96     
97   for (;;)
98     {
99       buffer = s;
100       if (n < 2)
101         return NULL; /* buffer definitely too short for tag and length. */
102       if (!*s || *s == 0xff)
103         { /* Skip optional filler between TLV objects. */
104           s++;
105           n--;
106           continue;
107         }
108       composite = !!(*s & 0x20);
109       if ((*s & 0x1f) == 0x1f)
110         { /* more tag bytes to follow */
111           s++;
112           n--;
113           if (n < 2)
114             return NULL; /* buffer definitely too short for tag and length. */
115           if ((*s & 0x1f) == 0x1f)
116             return NULL; /* We support only up to 2 bytes. */
117           this_tag = (s[-1] << 8) | (s[0] & 0x7f);
118         }
119       else
120         this_tag = s[0];
121       len = s[1];
122       s += 2; n -= 2;
123       if (len < 0x80)
124         ;
125       else if (len == 0x81)
126         { /* One byte length follows. */
127           if (!n)
128             return NULL; /* we expected 1 more bytes with the length. */
129           len = s[0];
130           s++; n--;
131         }
132       else if (len == 0x82)
133         { /* Two byte length follows. */
134           if (n < 2)
135             return NULL; /* we expected 2 more bytes with the length. */
136           len = (s[0] << 8) | s[1];
137           s += 2; n -= 2;
138         }
139       else
140         return NULL; /* APDU limit is 65535, thus it does not make
141                         sense to assume longer length fields. */
142
143       if (composite && nestlevel < 100)
144         { /* Dive into this composite DO after checking for too deep
145              nesting. */
146           const unsigned char *tmp_s;
147           size_t tmp_len;
148           
149           tmp_s = find_tlv (s, len, tag, &tmp_len, nestlevel+1);
150           if (tmp_s)
151             {
152               *nbytes = tmp_len;
153               return tmp_s;
154             }
155         }
156
157       if (this_tag == tag)
158         {
159           *nbytes = len;
160           return s;
161         }
162       if (len > n)
163         return NULL; /* buffer too short to skip to the next tag. */
164       s += len; n -= len;
165     }
166 }
167
168
169 /* Get the DO identified by TAG from the card in SLOT and return a
170    buffer with its content in RESULT and NBYTES.  The return value is
171    NULL if not found or a pointer which must be used to release the
172    buffer holding value. */
173 static void *
174 get_one_do (int slot, int tag, unsigned char **result, size_t *nbytes)
175 {
176   int rc, i;
177   unsigned char *buffer;
178   size_t buflen;
179   unsigned char *value;
180   size_t valuelen;
181
182   *result = NULL;
183   *nbytes = 0;
184   for (i=0; data_objects[i].tag && data_objects[i].tag != tag; i++)
185     ;
186
187   value = NULL;
188   rc = -1;
189   if (data_objects[i].tag && data_objects[i].get_from)
190     {
191       rc = iso7816_get_data (slot, data_objects[i].get_from,
192                              &buffer, &buflen);
193       if (!rc)
194         {
195           const unsigned char *s;
196
197           s = find_tlv (buffer, buflen, tag, &valuelen, 0);
198           if (!s)
199             value = NULL; /* not found */
200           else if (valuelen > buflen - (s - buffer))
201             {
202               log_error ("warning: constructed DO too short\n");
203               value = NULL;
204               xfree (buffer); buffer = NULL;
205             }
206           else
207             value = buffer + (s - buffer);
208         }
209     }
210
211   if (!value) /* Not in a constructed DO, try simple. */
212     {
213       rc = iso7816_get_data (slot, tag, &buffer, &buflen);
214       if (!rc)
215         {
216           value = buffer;
217           valuelen = buflen;
218         }
219     }
220
221   if (!rc)
222     {
223       *nbytes = valuelen;
224       *result = value;
225       return buffer;
226     }
227   return NULL;
228 }
229
230
231 static void
232 dump_all_do (int slot)
233 {
234   int rc, i, j;
235   unsigned char *buffer;
236   size_t buflen;
237   
238   for (i=0; data_objects[i].tag; i++)
239     {
240       if (data_objects[i].get_from)
241         continue;
242
243       rc = iso7816_get_data (slot, data_objects[i].tag, &buffer, &buflen);
244       if (gpg_err_code (rc) == GPG_ERR_NO_OBJ)
245         ;
246       else if (rc) 
247         log_info ("DO `%s' not available: %s\n",
248                   data_objects[i].desc, gpg_strerror (rc));
249       else
250         {
251           if (data_objects[i].binary)
252             {
253               log_info ("DO `%s': ", data_objects[i].desc);
254               log_printhex ("", buffer, buflen);
255             }
256           else
257             log_info ("DO `%s': `%.*s'\n",
258                       data_objects[i].desc,
259                       (int)buflen, buffer); /* FIXME: sanitize */
260
261           if (data_objects[i].constructed)
262             {
263               for (j=0; data_objects[j].tag; j++)
264                 {
265                   const unsigned char *value;
266                   size_t valuelen;
267                   
268                   if (j==i || data_objects[i].tag != data_objects[j].get_from)
269                     continue;
270                   value = find_tlv (buffer, buflen,
271                                     data_objects[j].tag, &valuelen, 0);
272                   if (!value)
273                     ; /* not found */
274                   else if (valuelen > buflen - (value - buffer))
275                     log_error ("warning: constructed DO too short\n");
276                   else
277                     {
278                       if (data_objects[j].binary)
279                         {
280                           log_info ("DO `%s': ", data_objects[j].desc);
281                           log_printhex ("", value, valuelen);
282                         }
283                       else
284                         log_info ("DO `%s': `%.*s'\n",
285                                   data_objects[j].desc,
286                                   (int)valuelen, value); /* FIXME: sanitize */
287                     }
288                 }
289             }
290         }
291       xfree (buffer); buffer = NULL;
292     }
293 }
294
295
296 /* Count the number of bits, assuming the A represents an unsigned big
297    integer of length LEN bytes. */
298 static unsigned int
299 count_bits (const unsigned char *a, size_t len)
300 {
301   unsigned int n = len * 8;
302   int i;
303
304   for (; len && !*a; len--, a++, n -=8)
305     ;
306   if (len)
307     {
308       for (i=7; i && !(*a & (1<<i)); i--)
309         n--;
310     }
311   return n;
312 }
313
314 /* Note, that FPR must be at least 20 bytes. */
315 static int 
316 store_fpr (int slot, int keynumber, u32 timestamp,
317            const unsigned char *m, size_t mlen,
318            const unsigned char *e, size_t elen, 
319            unsigned char *fpr, unsigned int card_version)
320 {
321   unsigned int n, nbits;
322   unsigned char *buffer, *p;
323   int rc;
324   
325   for (; mlen && !*m; mlen--, m++) /* strip leading zeroes */
326     ;
327   for (; elen && !*e; elen--, e++) /* strip leading zeroes */
328     ;
329
330   n = 6 + 2 + mlen + 2 + elen;
331   p = buffer = xtrymalloc (3 + n);
332   if (!buffer)
333     return out_of_core ();
334   
335   *p++ = 0x99;     /* ctb */
336   *p++ = n >> 8;   /* 2 byte length header */
337   *p++ = n;
338   *p++ = 4;        /* key packet version */
339   *p++ = timestamp >> 24;
340   *p++ = timestamp >> 16;
341   *p++ = timestamp >>  8;
342   *p++ = timestamp;
343   *p++ = 1; /* RSA */
344   nbits = count_bits (m, mlen);
345   *p++ = nbits >> 8;
346   *p++ = nbits;
347   memcpy (p, m, mlen); p += mlen;
348   nbits = count_bits (e, elen);
349   *p++ = nbits >> 8;
350   *p++ = nbits;
351   memcpy (p, e, elen); p += elen;
352     
353   log_printhex ("fprbuf:", buffer, n+3);
354   gcry_md_hash_buffer (GCRY_MD_SHA1, fpr, buffer, n+3);
355
356   xfree (buffer);
357
358   rc = iso7816_put_data (slot, (card_version > 0x0007? 0xC7 : 0xC6)
359                                + keynumber, fpr, 20);
360   if (rc)
361     log_error ("failed to store the fingerprint: %s\n",gpg_strerror (rc));
362
363   return rc;
364 }
365
366        
367 static void
368 send_fpr_if_not_null (CTRL ctrl, const char *keyword,
369                       int number, const unsigned char *fpr)
370 {                      
371   int i;
372   char buf[41];
373   char numbuf[25];
374
375   for (i=0; i < 20 && !fpr[i]; i++)
376     ;
377   if (i==20)
378     return; /* All zero. */
379   for (i=0; i< 20; i++)
380     sprintf (buf+2*i, "%02X", fpr[i]);
381   if (number == -1)
382     *numbuf = 0; /* Don't print the key number */
383   else
384     sprintf (numbuf, "%d", number);
385   send_status_info (ctrl, keyword,
386                     numbuf, (size_t)strlen(numbuf),
387                     buf, (size_t)strlen (buf), NULL, 0);
388 }
389
390 static void
391 send_key_data (CTRL ctrl, const char *name, 
392                const unsigned char *a, size_t alen)
393 {
394   char *p, *buf = xmalloc (alen*2+1);
395   
396   for (p=buf; alen; a++, alen--, p += 2)
397     sprintf (p, "%02X", *a);
398
399   send_status_info (ctrl, "KEY-DATA",
400                     name, (size_t)strlen(name), 
401                     buf, (size_t)strlen (buf),
402                     NULL, 0);
403   xfree (buf);
404 }
405
406
407
408 static int
409 do_learn_status (APP app, CTRL ctrl)
410 {
411   void *relptr;
412   unsigned char *value;
413   size_t valuelen;
414   int i;
415
416   relptr = get_one_do (app->slot, 0x005B, &value, &valuelen);
417   if (relptr)
418     {
419       send_status_info (ctrl, "DISP-NAME", value, valuelen, NULL, 0);
420       xfree (relptr);
421     }
422   relptr = get_one_do (app->slot, 0x5F2D, &value, &valuelen);
423   if (relptr)
424     {
425       send_status_info (ctrl, "DISP-LANG", value, valuelen, NULL, 0);
426       xfree (relptr);
427     }
428   relptr = get_one_do (app->slot, 0x5F35, &value, &valuelen);
429   if (relptr)
430     {
431       send_status_info (ctrl, "DISP-SEX", value, valuelen, NULL, 0);
432       xfree (relptr);
433     }
434   relptr = get_one_do (app->slot, 0x5F50, &value, &valuelen);
435   if (relptr)
436     {
437       send_status_info (ctrl, "PUBKEY-URL", value, valuelen, NULL, 0);
438       xfree (relptr);
439     }
440   relptr = get_one_do (app->slot, 0x005E, &value, &valuelen);
441   if (relptr)
442     {
443       send_status_info (ctrl, "LOGIN-DATA", value, valuelen, NULL, 0);
444       xfree (relptr);
445     }
446
447   relptr = get_one_do (app->slot, 0x00C5, &value, &valuelen);
448   if (relptr && valuelen >= 60)
449     {
450       for (i=0; i < 3; i++)
451         send_fpr_if_not_null (ctrl, "KEY-FPR", i+1, value+i*20);
452     }
453   xfree (relptr);
454   relptr = get_one_do (app->slot, 0x00C6, &value, &valuelen);
455   if (relptr && valuelen >= 60)
456     {
457       for (i=0; i < 3; i++)
458         send_fpr_if_not_null (ctrl, "CA-FPR", i+1, value+i*20);
459     }
460   xfree (relptr);
461   relptr = get_one_do (app->slot, 0x00C4, &value, &valuelen);
462   if (relptr)
463     {
464       char numbuf[7*23];
465
466       for (i=0,*numbuf=0; i < valuelen && i < 7; i++)
467         sprintf (numbuf+strlen (numbuf), " %d", value[i]); 
468       send_status_info (ctrl, "CHV-STATUS", numbuf, strlen (numbuf), NULL, 0);
469       xfree (relptr);
470     }
471
472   {
473     unsigned long ul = get_sig_counter (app);
474     char numbuf[23];
475
476     sprintf (numbuf, "%lu", ul);
477     send_status_info (ctrl, "SIG-COUNTER", numbuf, strlen (numbuf), NULL, 0);
478   }
479   return 0;
480 }
481
482
483 /* Handle the SETATTR operation. All arguments are already basically
484    checked. */
485 static int 
486 do_setattr (APP app, const char *name,
487             int (*pincb)(void*, const char *, char **),
488             void *pincb_arg,
489             const unsigned char *value, size_t valuelen)
490 {
491   gpg_error_t rc;
492   int idx;
493   static struct {
494     const char *name;
495     int tag;
496   } table[] = {
497     { "DISP-NAME",    0x005B },
498     { "LOGIN-DATA",   0x005E },
499     { "DISP-LANG",    0x5F2D },
500     { "DISP-SEX",     0x5F35 },
501     { "PUBKEY-URL",   0x5F50 },
502     { "CHV-STATUS-1", 0x00C4 },
503     { "CA-FPR-1",     0x00CA },
504     { "CA-FPR-2",     0x00CB },
505     { "CA-FPR-3",     0x00CC },
506     { NULL, 0 }
507   };
508
509
510   for (idx=0; table[idx].name && strcmp (table[idx].name, name); idx++)
511     ;
512   if (!table[idx].name)
513     return gpg_error (GPG_ERR_INV_NAME); 
514
515   if (!app->did_chv3)
516     {
517       char *pinvalue;
518
519       rc = pincb (pincb_arg, "Admin PIN (CHV3)",
520                   &pinvalue);
521 /*        pinvalue = xstrdup ("12345678"); */
522 /*        rc = 0; */
523       if (rc)
524         {
525           log_info ("PIN callback returned error: %s\n", gpg_strerror (rc));
526           return rc;
527         }
528
529       rc = iso7816_verify (app->slot, 0x83, pinvalue, strlen (pinvalue));
530       xfree (pinvalue);
531       if (rc)
532         {
533           log_error ("verify CHV3 failed: %s\n", gpg_strerror (rc));
534           rc = gpg_error (GPG_ERR_GENERAL);
535           return rc;
536         }
537       app->did_chv3 = 1;
538     }
539
540   rc = iso7816_put_data (app->slot, table[idx].tag, value, valuelen);
541   if (rc)
542     log_error ("failed to set `%s': %s\n", table[idx].name, gpg_strerror (rc));
543   /* FIXME: If this fails we should *once* try again after
544      doing a verify command, so that in case of a problem with
545      tracking the verify operation we have a fallback. */
546
547   return rc;
548 }
549
550 /* Handle the PASSWD command. */
551 static int 
552 do_change_pin (APP app, CTRL ctrl,  const char *chvnostr, int reset_mode,
553                int (*pincb)(void*, const char *, char **),
554                void *pincb_arg)
555 {
556   int rc = 0;
557   int chvno = atoi (chvnostr);
558   char *pinvalue;
559
560   if (reset_mode && chvno == 3)
561     {
562       rc = gpg_error (GPG_ERR_INV_ID);
563       goto leave;
564     }
565   else if (reset_mode || chvno == 3)
566     {
567       rc = pincb (pincb_arg, "Admin PIN", &pinvalue); 
568       if (rc)
569         {
570           log_error ("error getting PIN: %s\n", gpg_strerror (rc));
571           goto leave;
572         }
573       rc = iso7816_verify (app->slot, 0x83, pinvalue, strlen (pinvalue));
574       xfree (pinvalue);
575       if (rc)
576         {
577           log_error ("verify CHV3 failed: rc=%s\n", gpg_strerror (rc));
578           goto leave;
579         }
580     }
581   else if (chvno == 1)
582     {
583       rc = pincb (pincb_arg, "Signature PIN", &pinvalue); 
584       if (rc)
585         {
586           log_error ("error getting PIN: %s\n", gpg_strerror (rc));
587           goto leave;
588         }
589       rc = iso7816_verify (app->slot, 0x81, pinvalue, strlen (pinvalue));
590       xfree (pinvalue);
591       if (rc)
592         {
593           log_error ("verify CHV1 failed: rc=%s\n", gpg_strerror (rc));
594           goto leave;
595         }
596     }
597   else if (chvno == 2)
598     {
599       rc = pincb (pincb_arg, "Decryption PIN", &pinvalue); 
600       if (rc)
601         {
602           log_error ("error getting PIN: %s\n", gpg_strerror (rc));
603           goto leave;
604         }
605       rc = iso7816_verify (app->slot, 0x82, pinvalue, strlen (pinvalue));
606       xfree (pinvalue);
607       if (rc)
608         {
609           log_error ("verify CHV2 failed: rc=%s\n", gpg_strerror (rc));
610           goto leave;
611         }
612     }
613   else
614     {
615       rc = gpg_error (GPG_ERR_INV_ID);
616       goto leave;
617     }
618
619   
620   rc = pincb (pincb_arg, chvno == 1? "New Signature PIN" :
621                          chvno == 2? "New Decryption PIN" :
622                          chvno == 3? "New Admin PIN" : "?", &pinvalue); 
623   if (rc)
624     {
625       log_error ("error getting new PIN: %s\n", gpg_strerror (rc));
626       goto leave;
627     }
628
629   if (reset_mode)
630     rc = iso7816_reset_retry_counter (app->slot, 0x80 + chvno,
631                                       pinvalue, strlen (pinvalue));
632   else
633     rc = iso7816_change_reference_data (app->slot, 0x80 + chvno,
634                                         NULL, 0,
635                                         pinvalue, strlen (pinvalue));
636   xfree (pinvalue);
637
638
639  leave:
640   return rc;
641 }
642
643
644
645 /* Handle the GENKEY command. */
646 static int 
647 do_genkey (APP app, CTRL ctrl,  const char *keynostr, unsigned int flags,
648           int (*pincb)(void*, const char *, char **),
649           void *pincb_arg)
650 {
651   int rc;
652   int i;
653   char numbuf[30];
654   unsigned char fprbuf[20];
655   const unsigned char *fpr;
656   const unsigned char *keydata, *m, *e;
657   unsigned char *buffer;
658   size_t buflen, keydatalen, n, mlen, elen;
659   time_t created_at;
660   int keyno = atoi (keynostr);
661   int force = (flags & 1);
662   time_t start_at;
663
664   if (keyno < 1 || keyno > 3)
665     return gpg_error (GPG_ERR_INV_ID);
666   keyno--;
667
668   rc = iso7816_get_data (app->slot, 0x006E, &buffer, &buflen);
669   if (rc)
670     {
671       log_error ("error reading application data\n");
672       return gpg_error (GPG_ERR_GENERAL);
673     }
674   fpr = find_tlv (buffer, buflen, 0x00C5, &n, 0);
675   if (!fpr || n != 60)
676     {
677       rc = gpg_error (GPG_ERR_GENERAL);
678       log_error ("error reading fingerprint DO\n");
679       goto leave;
680     }
681   fpr += 20*keyno;
682   for (i=0; i < 20 && !fpr[i]; i++)
683     ;
684   if (i!=20 && !force)
685     {
686       rc = gpg_error (GPG_ERR_EEXIST);
687       log_error ("key already exists\n");
688       goto leave;
689     }
690   else if (i!=20)
691     log_info ("existing key will be replaced\n");
692   else
693     log_info ("generating new key\n");
694
695   {
696     char *pinvalue;
697     rc = pincb (pincb_arg, "Admin PIN", &pinvalue); 
698     if (rc)
699       {
700         log_error ("error getting PIN: %s\n", gpg_strerror (rc));
701         return rc;
702       }
703     rc = iso7816_verify (app->slot, 0x83, pinvalue, strlen (pinvalue));
704     xfree (pinvalue);
705   }
706   if (rc)
707     {
708       log_error ("verify CHV3 failed: rc=%s\n", gpg_strerror (rc));
709       goto leave;
710     }
711
712   xfree (buffer); buffer = NULL;
713 #if 1
714   log_info ("please wait while key is being generated ...\n");
715   start_at = time (NULL);
716   rc = iso7816_generate_keypair 
717 #else
718 #warning key generation temporary replaced by reading an existing key.
719   rc = iso7816_read_public_key
720 #endif
721                               (app->slot, 
722                                  keyno == 0? "\xB6" :
723                                  keyno == 1? "\xB8" : "\xA4",
724                                  2,
725                                  &buffer, &buflen);
726   if (rc)
727     {
728       rc = gpg_error (GPG_ERR_CARD);
729       log_error ("generating key failed\n");
730       goto leave;
731     }
732   log_info ("key generation completed (%d seconds)\n",
733             (int)(time (NULL) - start_at));
734   keydata = find_tlv (buffer, buflen, 0x7F49, &keydatalen, 0);
735   if (!keydata)
736     {
737       rc = gpg_error (GPG_ERR_CARD);
738       log_error ("response does not contain the public key data\n");
739       goto leave;
740     }
741  
742   m = find_tlv (keydata, keydatalen, 0x0081, &mlen, 0);
743   if (!m)
744     {
745       rc = gpg_error (GPG_ERR_CARD);
746       log_error ("response does not contain the RSA modulus\n");
747       goto leave;
748     }
749 /*    log_printhex ("RSA n:", m, mlen); */
750   send_key_data (ctrl, "n", m, mlen);
751
752   e = find_tlv (keydata, keydatalen, 0x0082, &elen, 0);
753   if (!e)
754     {
755       rc = gpg_error (GPG_ERR_CARD);
756       log_error ("response does not contain the RSA public exponent\n");
757       goto leave;
758     }
759 /*    log_printhex ("RSA e:", e, elen); */
760   send_key_data (ctrl, "e", e, elen);
761
762   created_at = gnupg_get_time ();
763   sprintf (numbuf, "%lu", (unsigned long)created_at);
764   send_status_info (ctrl, "KEY-CREATED-AT",
765                     numbuf, (size_t)strlen(numbuf), NULL, 0);
766
767   rc = store_fpr (app->slot, keyno, (u32)created_at,
768                   m, mlen, e, elen, fprbuf, app->card_version);
769   if (rc)
770     goto leave;
771   send_fpr_if_not_null (ctrl, "KEY-FPR", -1, fprbuf);
772
773
774  leave:
775   xfree (buffer);
776   return rc;
777 }
778
779
780 static unsigned long
781 get_sig_counter (APP app)
782 {
783   void *relptr;
784   unsigned char *value;
785   size_t valuelen;
786   unsigned long ul;
787
788   relptr = get_one_do (app->slot, 0x0093, &value, &valuelen);
789   if (!relptr)
790     return 0;
791   if (valuelen == 3 )
792     ul = (value[0] << 16) | (value[1] << 8) | value[2];
793   else
794     {
795       log_error ("invalid structure of OpenPGP card (DO 0x93)\n");
796       ul = 0;
797     }
798   xfree (relptr);
799   return ul;
800 }
801
802 static int
803 compare_fingerprint (APP app, int keyno, unsigned char *sha1fpr)
804 {
805   const unsigned char *fpr;
806   unsigned char *buffer;
807   size_t buflen, n;
808   int rc, i;
809   
810   assert (keyno >= 1 && keyno <= 3);
811
812   rc = iso7816_get_data (app->slot, 0x006E, &buffer, &buflen);
813   if (rc)
814     {
815       log_error ("error reading application data\n");
816       return gpg_error (GPG_ERR_GENERAL);
817     }
818   fpr = find_tlv (buffer, buflen, 0x00C5, &n, 0);
819   if (!fpr || n != 60)
820     {
821       xfree (buffer);
822       log_error ("error reading fingerprint DO\n");
823       return gpg_error (GPG_ERR_GENERAL);
824     }
825   fpr += (keyno-1)*20;
826   for (i=0; i < 20; i++)
827     if (sha1fpr[i] != fpr[i])
828       {
829         xfree (buffer);
830         return gpg_error (GPG_ERR_WRONG_SECKEY);
831       }
832   xfree (buffer);
833   return 0;
834 }
835
836
837
838 /* Compute a digital signature on INDATA which is expected to be the
839    raw message digest. For this application the KEYIDSTR consists of
840    the serialnumber and the fingerprint delimited by a slash.
841
842    Note that this fucntion may return the error code
843    GPG_ERR_WRONG_CARD to indicate that the card currently present does
844    not match the one required for the requested action (e.g. the
845    serial number does not match). */
846 static int 
847 do_sign (APP app, const char *keyidstr, int hashalgo,
848          int (*pincb)(void*, const char *, char **),
849          void *pincb_arg,
850          const void *indata, size_t indatalen,
851          unsigned char **outdata, size_t *outdatalen )
852 {
853   static unsigned char sha1_prefix[15] = /* Object ID is 1.3.14.3.2.26 */
854   { 0x30, 0x21, 0x30, 0x09, 0x06, 0x05, 0x2b, 0x0e, 0x03,
855     0x02, 0x1a, 0x05, 0x00, 0x04, 0x14 };
856   static unsigned char rmd160_prefix[15] = /* Object ID is 1.3.36.3.2.1 */
857   { 0x30, 0x21, 0x30, 0x09, 0x06, 0x05, 0x2b, 0x24, 0x03,
858     0x02, 0x01, 0x05, 0x00, 0x04, 0x14 };
859   int rc;
860   unsigned char data[35];
861   unsigned char tmp_sn[20]; /* actually 16 but we use it also for the fpr. */
862   const char *s;
863   int n;
864   const char *fpr = NULL;
865   unsigned long sigcount;
866
867   if (!keyidstr || !*keyidstr)
868     return gpg_error (GPG_ERR_INV_VALUE);
869   if (indatalen != 20)
870     return gpg_error (GPG_ERR_INV_VALUE);
871
872   /* Check whether an OpenPGP card of any version has been requested. */
873   if (strlen (keyidstr) < 32 || strncmp (keyidstr, "D27600012401", 12))
874     return gpg_error (GPG_ERR_INV_ID);
875   
876   for (s=keyidstr, n=0; hexdigitp (s); s++, n++)
877     ;
878   if (n != 32)
879     return gpg_error (GPG_ERR_INV_ID);
880   else if (!*s)
881     ; /* no fingerprint given: we allow this for now. */
882   else if (*s == '/')
883     fpr = s + 1; 
884   else
885     return gpg_error (GPG_ERR_INV_ID);
886
887   for (s=keyidstr, n=0; n < 16; s += 2, n++)
888     tmp_sn[n] = xtoi_2 (s);
889
890   if (app->serialnolen != 16)
891     return gpg_error (GPG_ERR_INV_CARD);
892   if (memcmp (app->serialno, tmp_sn, 16))
893     return gpg_error (GPG_ERR_WRONG_CARD);
894
895   /* If a fingerprint has been specified check it against the one on
896      the card.  This is allows for a meaningful error message in case
897      the key on the card has been replaced but the shadow information
898      known to gpg was not updated.  If there is no fingerprint, gpg
899      will detect a bogus signature anyway due to the
900      verify-after-signing feature. */
901   if (fpr)
902     {
903       for (s=fpr, n=0; hexdigitp (s); s++, n++)
904         ;
905       if (n != 40)
906         return gpg_error (GPG_ERR_INV_ID);
907       else if (!*s)
908         ; /* okay */
909       else
910         return gpg_error (GPG_ERR_INV_ID);
911
912       for (s=fpr, n=0; n < 20; s += 2, n++)
913         tmp_sn[n] = xtoi_2 (s);
914       rc = compare_fingerprint (app, 1, tmp_sn);
915       if (rc)
916         return rc;
917     }
918
919   if (hashalgo == GCRY_MD_SHA1)
920     memcpy (data, sha1_prefix, 15);
921   else if (hashalgo == GCRY_MD_RMD160)
922     memcpy (data, rmd160_prefix, 15);
923   else 
924     return gpg_error (GPG_ERR_UNSUPPORTED_ALGORITHM);
925   memcpy (data+15, indata, indatalen);
926
927   sigcount = get_sig_counter (app);
928   log_info ("signatures created so far: %lu\n", sigcount);
929
930   /* FIXME: Check whether we are really required to enter the PIN for
931      each signature. There is a DO for this. */
932   if (!app->did_chv1 || 1) 
933     {
934       char *pinvalue;
935
936       {
937         char *prompt;
938         if (asprintf (&prompt, "Signature PIN [sigs done: %lu]", sigcount) < 0)
939           return gpg_error_from_errno (errno);
940         rc = pincb (pincb_arg, prompt, &pinvalue); 
941         free (prompt);
942       }
943 /*        pinvalue = xstrdup ("123456"); */
944 /*        rc = 0; */
945       if (rc)
946         {
947           log_info ("PIN callback returned error: %s\n", gpg_strerror (rc));
948           return rc;
949         }
950
951       rc = iso7816_verify (app->slot, 0x81, pinvalue, strlen (pinvalue));
952       xfree (pinvalue);
953       if (rc)
954         {
955           log_error ("verify CHV1 failed\n");
956           rc = gpg_error (GPG_ERR_GENERAL);
957           return rc;
958         }
959       app->did_chv1 = 1;
960     }
961
962   rc = iso7816_compute_ds (app->slot, data, 35, outdata, outdatalen);
963   return rc;
964 }
965
966 /* Compute a digital signature using the INTERNAL AUTHENTICATE command
967    on INDATA which is expected to be the raw message digest. For this
968    application the KEYIDSTR consists of the serialnumber and the
969    fingerprint delimited by a slash.
970
971    Note that this fucntion may return the error code
972    GPG_ERR_WRONG_CARD to indicate that the card currently present does
973    not match the one required for the requested action (e.g. the
974    serial number does not match). */
975 static int 
976 do_auth (APP app, const char *keyidstr,
977          int (*pincb)(void*, const char *, char **),
978          void *pincb_arg,
979          const void *indata, size_t indatalen,
980          unsigned char **outdata, size_t *outdatalen )
981 {
982   int rc;
983   unsigned char tmp_sn[20]; /* actually 16 but we use it also for the fpr. */
984   const char *s;
985   int n;
986   const char *fpr = NULL;
987
988   if (!keyidstr || !*keyidstr)
989     return gpg_error (GPG_ERR_INV_VALUE);
990   if (indatalen > 50) /* For a 1024 bit key. */
991     return gpg_error (GPG_ERR_INV_VALUE);
992
993   /* Check whether an OpenPGP card of any version has been requested. */
994   if (strlen (keyidstr) < 32 || strncmp (keyidstr, "D27600012401", 12))
995     return gpg_error (GPG_ERR_INV_ID);
996   
997   for (s=keyidstr, n=0; hexdigitp (s); s++, n++)
998     ;
999   if (n != 32)
1000     return gpg_error (GPG_ERR_INV_ID);
1001   else if (!*s)
1002     ; /* no fingerprint given: we allow this for now. */
1003   else if (*s == '/')
1004     fpr = s + 1; 
1005   else
1006     return gpg_error (GPG_ERR_INV_ID);
1007
1008   for (s=keyidstr, n=0; n < 16; s += 2, n++)
1009     tmp_sn[n] = xtoi_2 (s);
1010
1011   if (app->serialnolen != 16)
1012     return gpg_error (GPG_ERR_INV_CARD);
1013   if (memcmp (app->serialno, tmp_sn, 16))
1014     return gpg_error (GPG_ERR_WRONG_CARD);
1015
1016   /* If a fingerprint has been specified check it against the one on
1017      the card.  This is allows for a meaningful error message in case
1018      the key on the card has been replaced but the shadow information
1019      known to gpg was not updated.  If there is no fingerprint, gpg
1020      will detect a bogus signature anyway due to the
1021      verify-after-signing feature. */
1022   if (fpr)
1023     {
1024       for (s=fpr, n=0; hexdigitp (s); s++, n++)
1025         ;
1026       if (n != 40)
1027         return gpg_error (GPG_ERR_INV_ID);
1028       else if (!*s)
1029         ; /* okay */
1030       else
1031         return gpg_error (GPG_ERR_INV_ID);
1032
1033       for (s=fpr, n=0; n < 20; s += 2, n++)
1034         tmp_sn[n] = xtoi_2 (s);
1035       rc = compare_fingerprint (app, 3, tmp_sn);
1036       if (rc)
1037         return rc;
1038     }
1039
1040   if (!app->did_chv2) 
1041     {
1042       char *pinvalue;
1043
1044       rc = pincb (pincb_arg, "Authentication/Decryption PIN", &pinvalue); 
1045       if (rc)
1046         {
1047           log_info ("PIN callback returned error: %s\n", gpg_strerror (rc));
1048           return rc;
1049         }
1050
1051       rc = iso7816_verify (app->slot, 0x82, pinvalue, strlen (pinvalue));
1052       xfree (pinvalue);
1053       if (rc)
1054         {
1055           log_error ("verify CHV2 failed\n");
1056           rc = gpg_error (GPG_ERR_GENERAL);
1057           return rc;
1058         }
1059       app->did_chv2 = 1;
1060     }
1061
1062   rc = iso7816_internal_authenticate (app->slot, indata, indatalen,
1063                                       outdata, outdatalen);
1064   return rc;
1065 }
1066
1067
1068 static int 
1069 do_decipher (APP app, const char *keyidstr,
1070              int (pincb)(void*, const char *, char **),
1071              void *pincb_arg,
1072              const void *indata, size_t indatalen,
1073              unsigned char **outdata, size_t *outdatalen )
1074 {
1075   int rc;
1076   unsigned char tmp_sn[20]; /* actually 16 but we use it also for the fpr. */
1077   const char *s;
1078   int n;
1079   const char *fpr = NULL;
1080
1081   if (!keyidstr || !*keyidstr || !indatalen)
1082     return gpg_error (GPG_ERR_INV_VALUE);
1083
1084   /* Check whether an OpenPGP card of any version has been requested. */
1085   if (strlen (keyidstr) < 32 || strncmp (keyidstr, "D27600012401", 12))
1086     return gpg_error (GPG_ERR_INV_ID);
1087   
1088   for (s=keyidstr, n=0; hexdigitp (s); s++, n++)
1089     ;
1090   if (n != 32)
1091     return gpg_error (GPG_ERR_INV_ID);
1092   else if (!*s)
1093     ; /* no fingerprint given: we allow this for now. */
1094   else if (*s == '/')
1095     fpr = s + 1; 
1096   else
1097     return gpg_error (GPG_ERR_INV_ID);
1098
1099   for (s=keyidstr, n=0; n < 16; s += 2, n++)
1100     tmp_sn[n] = xtoi_2 (s);
1101
1102   if (app->serialnolen != 16)
1103     return gpg_error (GPG_ERR_INV_CARD);
1104   if (memcmp (app->serialno, tmp_sn, 16))
1105     return gpg_error (GPG_ERR_WRONG_CARD);
1106
1107   /* If a fingerprint has been specified check it against the one on
1108      the card.  This is allows for a meaningful error message in case
1109      the key on the card has been replaced but the shadow information
1110      known to gpg was not updated.  If there is no fingerprint, the
1111      decryption will won't produce the right plaintext anyway. */
1112   if (fpr)
1113     {
1114       for (s=fpr, n=0; hexdigitp (s); s++, n++)
1115         ;
1116       if (n != 40)
1117         return gpg_error (GPG_ERR_INV_ID);
1118       else if (!*s)
1119         ; /* okay */
1120       else
1121         return gpg_error (GPG_ERR_INV_ID);
1122
1123       for (s=fpr, n=0; n < 20; s += 2, n++)
1124         tmp_sn[n] = xtoi_2 (s);
1125       rc = compare_fingerprint (app, 2, tmp_sn);
1126       if (rc)
1127         return rc;
1128     }
1129
1130   if (!app->did_chv2) 
1131     {
1132       char *pinvalue;
1133
1134       rc = pincb (pincb_arg, "Decryption PIN", &pinvalue); 
1135 /*        pinvalue = xstrdup ("123456"); */
1136 /*        rc = 0; */
1137       if (rc)
1138         {
1139           log_info ("PIN callback returned error: %s\n", gpg_strerror (rc));
1140           return rc;
1141         }
1142
1143       rc = iso7816_verify (app->slot, 0x82, pinvalue, strlen (pinvalue));
1144       xfree (pinvalue);
1145       if (rc)
1146         {
1147           log_error ("verify CHV2 failed\n");
1148           rc = gpg_error (GPG_ERR_GENERAL);
1149           return rc;
1150         }
1151       app->did_chv2 = 1;
1152     }
1153   
1154   rc = iso7816_decipher (app->slot, indata, indatalen, outdata, outdatalen);
1155   return rc;
1156 }
1157
1158
1159
1160
1161 /* Select the OpenPGP application on the card in SLOT.  This function
1162    must be used before any other OpenPGP application functions. */
1163 int
1164 app_select_openpgp (APP app, unsigned char **sn, size_t *snlen)
1165 {
1166   static char const aid[] = { 0xD2, 0x76, 0x00, 0x01, 0x24, 0x01 };
1167   int slot = app->slot;
1168   int rc;
1169   unsigned char *buffer;
1170   size_t buflen;
1171   
1172   rc = iso7816_select_application (slot, aid, sizeof aid);
1173   if (!rc)
1174     {
1175       rc = iso7816_get_data (slot, 0x004F, &buffer, &buflen);
1176       if (rc)
1177         goto leave;
1178       if (opt.verbose)
1179         {
1180           log_info ("got AID: ");
1181           log_printhex ("", buffer, buflen);
1182         }
1183
1184       if (sn)
1185         {
1186           *sn = buffer;
1187           *snlen = buflen;
1188           app->card_version = buffer[6] << 8;
1189           app->card_version |= buffer[7];
1190         }
1191       else
1192         xfree (buffer);
1193
1194       if (opt.verbose > 1)
1195         dump_all_do (slot);
1196
1197       app->fnc.learn_status = do_learn_status;
1198       app->fnc.setattr = do_setattr;
1199       app->fnc.genkey = do_genkey;
1200       app->fnc.sign = do_sign;
1201       app->fnc.auth = do_auth;
1202       app->fnc.decipher = do_decipher;
1203       app->fnc.change_pin = do_change_pin;
1204    }
1205
1206 leave:
1207   return rc;
1208 }
1209
1210
1211
1212 /* This function is a hack to retrieve essential information about the
1213    card to be displayed by simple tools.  It mostly resembles what the
1214    LEARN command returns. All parameters return allocated strings or
1215    buffers or NULL if the data object is not available.  All returned
1216    values are sanitized. */
1217 int
1218 app_openpgp_cardinfo (APP app,
1219                       char **serialno,
1220                       char **disp_name,
1221                       char **pubkey_url,
1222                       unsigned char **fpr1,
1223                       unsigned char **fpr2,
1224                       unsigned char **fpr3)
1225 {
1226   int rc;
1227   void *relptr;
1228   unsigned char *value;
1229   size_t valuelen;
1230
1231   if (serialno)
1232     {
1233       time_t dummy;
1234
1235       *serialno = NULL;
1236       rc = app_get_serial_and_stamp (app, serialno, &dummy);
1237       if (rc)
1238         {
1239           log_error ("error getting serial number: %s\n", gpg_strerror (rc));
1240           return rc;
1241         }
1242     }
1243       
1244   if (disp_name)
1245     {
1246       *disp_name = NULL;
1247       relptr = get_one_do (app->slot, 0x005B, &value, &valuelen);
1248       if (relptr)
1249         {
1250           *disp_name = make_printable_string (value, valuelen, 0);
1251           xfree (relptr);
1252         }
1253     }
1254
1255   if (pubkey_url)
1256     {
1257       *pubkey_url = NULL;
1258       relptr = get_one_do (app->slot, 0x5F50, &value, &valuelen);
1259       if (relptr)
1260         {
1261           *pubkey_url = make_printable_string (value, valuelen, 0);
1262           xfree (relptr);
1263         }
1264     }
1265
1266   if (fpr1)
1267     *fpr1 = NULL;
1268   if (fpr2)
1269     *fpr2 = NULL;
1270   if (fpr3)
1271     *fpr3 = NULL;
1272   relptr = get_one_do (app->slot, 0x00C5, &value, &valuelen);
1273   if (relptr && valuelen >= 60)
1274     {
1275       if (fpr1)
1276         {
1277           *fpr1 = xmalloc (20);
1278           memcpy (*fpr1, value +  0, 20);
1279         }
1280       if (fpr2)
1281         {
1282           *fpr2 = xmalloc (20);
1283           memcpy (*fpr2, value + 20, 20);
1284         }
1285       if (fpr3)
1286         {
1287           *fpr3 = xmalloc (20);
1288           memcpy (*fpr3, value + 40, 20);
1289         }
1290     }
1291   xfree (relptr);
1292
1293   return 0;
1294 }
1295
1296
1297
1298 /* This function is currently only used by the sc-copykeys program to
1299    store a key on the smartcard.  APP ist the application handle,
1300    KEYNO is the number of the key and PINCB, PINCB_ARG are used to ask
1301    for the SO PIN.  TEMPLATE and TEMPLATE_LEN describe a buffer with
1302    the key template to store. CREATED_AT is the timestamp used to
1303    create the fingerprint. M, MLEN is the RSA modulus and E, ELEN the
1304    RSA public exponent. This function silently overwrites an existing
1305    key.*/
1306 int 
1307 app_openpgp_storekey (APP app, int keyno,
1308                       unsigned char *template, size_t template_len,
1309                       time_t created_at,
1310                       const unsigned char *m, size_t mlen,
1311                       const unsigned char *e, size_t elen,
1312                       int (*pincb)(void*, const char *, char **),
1313                       void *pincb_arg)
1314 {
1315   int rc;
1316   unsigned char fprbuf[20];
1317
1318   if (keyno < 1 || keyno > 3)
1319     return gpg_error (GPG_ERR_INV_ID);
1320   keyno--;
1321
1322   {
1323     char *pinvalue;
1324     rc = pincb (pincb_arg, "Admin PIN", &pinvalue); 
1325     if (rc)
1326       {
1327         log_error ("error getting PIN: %s\n", gpg_strerror (rc));
1328         return rc;
1329       }
1330     rc = iso7816_verify (app->slot, 0x83, pinvalue, strlen (pinvalue));
1331     xfree (pinvalue);
1332   }
1333   if (rc)
1334     {
1335       log_error ("verify CHV3 failed: rc=%s\n", gpg_strerror (rc));
1336       goto leave;
1337     }
1338
1339   rc = iso7816_put_data (app->slot,
1340                          (app->card_version > 0x0007? 0xE0 : 0xE9) + keyno,
1341                          template, template_len);
1342   if (rc)
1343     {
1344       log_error ("failed to store the key: rc=%s\n", gpg_strerror (rc));
1345       rc = gpg_error (GPG_ERR_CARD);
1346       goto leave;
1347     }
1348  
1349 /*    log_printhex ("RSA n:", m, mlen);  */
1350 /*    log_printhex ("RSA e:", e, elen);  */
1351
1352   rc = store_fpr (app->slot, keyno, (u32)created_at,
1353                   m, mlen, e, elen, fprbuf, app->card_version);
1354
1355  leave:
1356   return rc;
1357 }
1358
1359
1360 /* Utility function for external tools: Read the public RSA key at
1361    KEYNO and return modulus and exponent in (M,MLEN) and (E,ELEN). */
1362 int 
1363 app_openpgp_readkey (APP app, int keyno, unsigned char **m, size_t *mlen,
1364                      unsigned char **e, size_t *elen)
1365 {
1366   int rc;
1367   const unsigned char *keydata, *a;
1368   unsigned char *buffer;
1369   size_t buflen, keydatalen, alen;
1370
1371   *m = NULL;
1372   *e = NULL;
1373
1374   if (keyno < 1 || keyno > 3)
1375     return gpg_error (GPG_ERR_INV_ID);
1376   keyno--;
1377
1378   rc = iso7816_read_public_key(app->slot, 
1379                                keyno == 0? "\xB6" :
1380                                keyno == 1? "\xB8" : "\xA4",
1381                                2,
1382                                &buffer, &buflen);
1383   if (rc)
1384     {
1385       rc = gpg_error (GPG_ERR_CARD);
1386       log_error ("reading key failed\n");
1387       goto leave;
1388     }
1389
1390   keydata = find_tlv (buffer, buflen, 0x7F49, &keydatalen, 0);
1391   if (!keydata)
1392     {
1393       log_error ("response does not contain the public key data\n");
1394       rc = gpg_error (GPG_ERR_CARD);
1395       goto leave;
1396     }
1397  
1398   a = find_tlv (keydata, keydatalen, 0x0081, &alen, 0);
1399   if (!a)
1400     {
1401       log_error ("response does not contain the RSA modulus\n");
1402       rc = gpg_error (GPG_ERR_CARD);
1403       goto leave;
1404     }
1405   *mlen = alen;
1406   *m = xmalloc (alen);
1407   memcpy (*m, a, alen);
1408   
1409   a = find_tlv (keydata, keydatalen, 0x0082, &alen, 0);
1410   if (!e)
1411     {
1412       log_error ("response does not contain the RSA public exponent\n");
1413       rc = gpg_error (GPG_ERR_CARD);
1414       goto leave;
1415     }
1416   *elen = alen;
1417   *e = xmalloc (alen);
1418   memcpy (*e, a, alen);
1419
1420  leave:
1421   xfree (buffer);
1422   if (rc)
1423     { 
1424       xfree (*m); *m = NULL;
1425       xfree (*e); *e = NULL;
1426     }
1427   return rc;
1428 }
1429
1430 #endif /*ENABLE_CARD_SUPPORT*/