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