9e0f060e5df93bbaa2162bc9dc5dfd87541f8af9
[gnupg.git] / scd / card.c
1 /* card.c - SCdaemon card functions
2  *      Copyright (C) 2002 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 <time.h>
27
28 #include <opensc/pkcs15.h>
29 #include <ksba.h>
30
31 #include "scdaemon.h"
32 #include "card-common.h"
33
34 /* Map the SC error codes to the GNUPG ones */
35 int
36 map_sc_err (int rc)
37 {
38   switch (rc)
39     {
40     case 0: rc = 0; break;
41     case SC_ERROR_NOT_SUPPORTED:         rc = GNUPG_Not_Supported; break;
42     case SC_ERROR_PKCS15_APP_NOT_FOUND:  rc = GNUPG_No_PKCS15_App; break;
43     case SC_ERROR_OUT_OF_MEMORY:         rc = GNUPG_Out_Of_Core; break;
44     case SC_ERROR_CARD_NOT_PRESENT:      rc = GNUPG_Card_Not_Present; break;
45     case SC_ERROR_CARD_REMOVED:          rc = GNUPG_Card_Removed; break;
46     case SC_ERROR_INVALID_CARD:          rc = GNUPG_Invalid_Card; break;
47     default: rc = GNUPG_Card_Error; break;
48     }
49   return rc;
50 }
51
52 /* Get the keygrip from CERT, return 0 on success */
53 int
54 card_help_get_keygrip (KsbaCert cert, unsigned char *array)
55 {
56   GCRY_SEXP s_pkey;
57   int rc;
58   KsbaSexp p;
59   size_t n;
60   
61   p = ksba_cert_get_public_key (cert);
62   if (!p)
63     return -1; /* oops */
64   n = gcry_sexp_canon_len (p, 0, NULL, NULL);
65   if (!n)
66     return -1; /* libksba did not return a proper S-expression */
67   rc = gcry_sexp_sscan ( &s_pkey, NULL, p, n);
68   xfree (p);
69   if (rc)
70     return -1; /* can't parse that S-expression */
71   array = gcry_pk_get_keygrip (s_pkey, array);
72   gcry_sexp_release (s_pkey);
73   if (!array)
74     return -1; /* failed to calculate the keygrip */
75   return 0;
76 }
77
78
79
80
81
82
83 \f
84 /* Create a new context for the card and figures out some basic
85    information of the card.  Detects whgether a PKCS_15 application is
86    stored.
87
88    Common errors: GNUPG_Card_Not_Present */
89 int
90 card_open (CARD *rcard)
91 {
92   CARD card;
93   int rc;
94
95   card = xtrycalloc (1, sizeof *card);
96   if (!card)
97     return GNUPG_Out_Of_Core;
98   card->reader = 0;
99   
100   rc = sc_establish_context (&card->ctx, "scdaemon");
101   if (rc)
102     {
103       log_error ("failed to establish SC context: %s\n", sc_strerror (rc));
104       rc = map_sc_err (rc);
105       goto leave;
106     }
107   if (card->reader >= card->ctx->reader_count)
108     {
109       log_error ("no card reader available\n");
110       rc = GNUPG_Card_Error;
111       goto leave;
112     }
113   card->ctx->error_file = log_get_stream ();
114   card->ctx->debug = opt.debug_sc;
115   card->ctx->debug_file = log_get_stream ();
116
117   if (sc_detect_card_presence (card->ctx->reader[card->reader], 0) != 1)
118     {
119       rc = GNUPG_Card_Not_Present;
120       goto leave;
121     }
122
123   rc = sc_connect_card (card->ctx->reader[card->reader], 0, &card->scard);
124   if (rc)
125     {
126       log_error ("failed to connect card in reader %d: %s\n",
127                  card->reader, sc_strerror (rc));
128       rc = map_sc_err (rc);
129       goto leave;
130     }
131   if (opt.verbose)
132     log_info ("connected to card in reader %d using driver `%s'\n",
133               card->reader, card->scard->driver->name);
134
135   rc = sc_lock (card->scard);
136   if (rc)
137     {
138       log_error ("can't lock card in reader %d: %s\n",
139                  card->reader, sc_strerror (rc));
140       rc = map_sc_err (rc);
141       goto leave;
142     }
143
144     
145  leave:
146   if (rc)
147     card_close (card);
148   else
149     *rcard = card;
150   return rc;
151 }
152
153
154 /* Close a card and release all resources */
155 void
156 card_close (CARD card)
157 {
158   if (card)
159     {
160       if (card->p15card)
161         {
162           sc_pkcs15_unbind (card->p15card);
163           card->p15card = NULL;
164         }
165       if (card->p15priv)
166         p15_release_private_data (card);
167       if (card->scard)
168         {
169           sc_unlock (card->scard);
170           sc_disconnect_card (card->scard, 0);
171           card->scard = NULL;
172         }
173       if (card->ctx)
174         {
175           sc_release_context (card->ctx);
176           card->ctx = NULL;
177         }
178       xfree (card);
179     }      
180 }
181
182 /* Locate a simple TLV encoded data object in BUFFER of LENGTH and
183    return a pointer to value as well as its length in NBYTES.  Return
184    NULL if it was not found.  Note, that the function does not check
185    whether the value fits into the provided buffer. */
186 static const char *
187 find_simple_tlv (const unsigned char *buffer, size_t length,
188                  int tag, size_t *nbytes)
189 {
190   const char *s = buffer;
191   size_t n = length;
192   size_t len;
193     
194   for (;;)
195     {
196       buffer = s;
197       if (n < 2)
198         return NULL; /* buffer too short for tag and length. */
199       len = s[1];
200       s += 2; n -= 2;
201       if (len == 255)
202         {
203           if (n < 2)
204             return NULL; /* we expected 2 more bytes with the length. */
205           len = (s[0] << 8) | s[1];
206           s += 2; n -= 2;
207         }
208       if (*buffer == tag)
209         {
210           *nbytes = len;
211           return s;
212         }
213       if (len > n)
214         return NULL; /* buffer too short to skip to the next tag. */
215       s += len; n -= len;
216     }
217 }
218
219 /* Find the ICC Serial Number within the provided BUFFER of LENGTH
220    (which should contain the GDO file) and return it as a hex encoded
221    string and allocated string in SERIAL.  Return an error code when
222    the ICCSN was not found. */
223 static int
224 find_iccsn (const unsigned char *buffer, size_t length, char **serial)
225 {
226   size_t n;
227   const unsigned char *s;
228   char *p;
229
230   s = find_simple_tlv (buffer, length, 0x5A, &n);
231   if (!s)
232     return GNUPG_Card_Error;
233   length -= s - buffer;
234   if (n > length)
235     {
236       /* Oops, it does not fit into the buffer.  This is an invalid
237          encoding (or the buffer is too short.  However, I have some
238          test cards with such an invalid encoding and therefore I use
239          this ugly workaround to return something I can further
240          experiment with. */
241       if (n == 0x0D && length+1 == n)
242         {
243           log_debug ("enabling BMI testcard workaround\n");
244           n--;
245         }
246       else
247         return GNUPG_Card_Error; /* Bad encoding; does not fit into buffer. */
248     }
249   if (!n)
250     return GNUPG_Card_Error; /* Well, that is too short. */
251
252   *serial = p = xtrymalloc (2*n+1);
253   if (!*serial)
254     return GNUPG_Out_Of_Core;
255   for (; n; n--, p += 2, s++)
256     sprintf (p, "%02X", *s);
257   *p = 0;
258   return 0;
259 }
260
261
262 /* Retrieve the serial number and the time of the last update of the
263    card.  The serial number is returned as a malloced string (hex
264    encoded) in SERIAL and the time of update is returned in STAMP.
265    If no update time is available the returned value is 0.  The serial
266    is mandatory for a PKCS_15 application and an error will be
267    returned if this value is not availbale.  For non-PKCS-15 cards a
268    serial number is constructed by other means. Caller must free
269    SERIAL unless the function returns an error. */
270 int 
271 card_get_serial_and_stamp (CARD card, char **serial, time_t *stamp)
272 {
273   int rc;
274   struct sc_path path;
275   struct sc_file *file;
276   unsigned char buf[256];
277   int buflen;
278
279   if (!card || !serial || !stamp)
280     return GNUPG_Invalid_Value;
281
282   *serial = NULL;
283   *stamp = 0; /* not available */
284
285   if (!card->fnc.initialized)
286     {
287       card->fnc.initialized = 1;
288       /* The first use of this card tries to figure out the type of the card 
289          and sets up the function pointers. */
290       rc = sc_pkcs15_bind (card->scard, &card->p15card);
291       if (rc)
292         {
293           if (rc != SC_ERROR_PKCS15_APP_NOT_FOUND)
294             log_error ("binding of existing PKCS-15 failed in reader %d: %s\n",
295                        card->reader, sc_strerror (rc));
296           card->p15card = NULL;
297           rc = 0;
298         }
299       if (card->p15card)
300         card_p15_bind (card);
301       else
302         card_dinsig_bind (card);
303       card->fnc.initialized = 1;
304     }
305       
306
307   /* We should lookup the iso 7812-1 and 8583-3 - argh ISO
308      practice is suppressing innovation - IETF rules!  So we
309      always get the serialnumber from the 2F02 GDO file.  */
310   /* FIXME: in case we can't parse the 2F02 EF and we have a P15 card,
311      we should get the serial number from the respective P15 file */
312   sc_format_path ("3F002F02", &path);
313   rc = sc_select_file (card->scard, &path, &file);
314   if (rc)
315     {
316       log_error ("sc_select_file failed: %s\n", sc_strerror (rc));
317       return GNUPG_Card_Error;
318     }
319   if (file->type != SC_FILE_TYPE_WORKING_EF
320       || file->ef_structure != SC_FILE_EF_TRANSPARENT)
321     {
322       log_error ("wrong type or structure of GDO file\n");
323       sc_file_free (file);
324       return GNUPG_Card_Error;
325     }
326
327   if (!file->size || file->size >= DIM(buf) )
328     { /* FIXME: Use a real parser */
329       log_error ("unsupported size of GDO file (%d)\n", file->size);
330       sc_file_free (file);
331       return GNUPG_Card_Error;
332     }
333   buflen = file->size;
334       
335   rc = sc_read_binary (card->scard, 0, buf, buflen, 0);
336   sc_file_free (file);
337   if (rc < 0) 
338     {
339       log_error ("error reading GDO file: %s\n", sc_strerror (rc));
340       return GNUPG_Card_Error;
341     }
342   if (rc != buflen)
343     {
344       log_error ("short read on GDO file\n");
345       return GNUPG_Card_Error;
346     }
347
348   rc = find_iccsn (buf, buflen, serial);
349   if (rc == GNUPG_Card_Error)
350     log_error ("invalid structure of GDO file\n");
351   if (!rc && card->p15card && !strcmp (*serial, "D27600000000000000000000"))
352     { /* This is a German card with a silly serial number.  Try to get
353          the serial number from the EF(TokenInfo). We indicate such a
354          serial number by the using the prefix: "FF0100". */
355       const char *efser = card->p15card->serial_number;
356       char *p;
357
358       if (!efser)
359         efser = "";
360         
361       xfree (*serial);
362       *serial = NULL;
363       p = xtrymalloc (strlen (efser) + 7);
364       if (!p)
365           rc = GNUPG_Out_Of_Core;
366       else
367         {
368           strcpy (p, "FF0100");
369           strcpy (p+6, efser);
370           *serial = p;
371         }
372     }
373   else if (!rc && **serial == 'F' && (*serial)[1] == 'F')
374     { /* The serial number starts with our special prefix.  This
375          requires that we put our default prefix "FF0000" in front. */
376       char *p = xtrymalloc (strlen (*serial) + 7);
377       if (!p)
378         {
379           xfree (*serial);
380           *serial = NULL;
381           rc = GNUPG_Out_Of_Core;
382         }
383       else
384         {
385           strcpy (p, "FF0000");
386           strcpy (p+6, *serial);
387           xfree (*serial);
388           *serial = p;
389         }
390     }
391   return rc;
392 }
393
394
395 /* Enumerate all keypairs on the card and return the Keygrip as well
396    as the internal identification of the key.  KEYGRIP must be a
397    caller provided buffer with a size of 20 bytes which will receive
398    the KEYGRIP of the keypair.  If KEYID is not NULL, it returns the
399    ID field of the key in allocated memory; this is a string without
400    spaces.  The function returns -1 when all keys have been
401    enumerated.  Note that the error GNUPG_Missing_Certificate may be
402    returned if there is just the private key but no public key (ie.e a
403    certificate) available.  Applications might want to continue
404    enumerating after this error.*/
405 int
406 card_enum_keypairs (CARD card, int idx,
407                     unsigned char *keygrip,
408                     char **keyid)
409 {
410   int rc;
411
412   if (keyid)
413     *keyid = NULL;
414
415   if (!card || !keygrip)
416     return GNUPG_Invalid_Value;
417   if (idx < 0)
418     return GNUPG_Invalid_Index;
419   if (!card->fnc.initialized)
420     return GNUPG_Card_Not_Initialized;
421   if (!card->fnc.enum_keypairs)
422     return GNUPG_Unsupported_Operation;
423   rc = card->fnc.enum_keypairs (card, idx, keygrip, keyid);
424   if (opt.verbose)
425     log_info ("card operation enum_keypairs result: %s\n",
426               gnupg_strerror (rc));
427   return rc;
428 }
429
430
431 /* Enumerate all trusted certificates available on the card, return
432    their ID in CERT and the type in CERTTYPE.  Types of certificates
433    are:
434       0   := Unknown
435       100 := Regular X.509 cert
436       101 := Trusted X.509 cert
437       102 := Useful X.509 cert
438  */
439 int
440 card_enum_certs (CARD card, int idx, char **certid, int *certtype)
441 {
442   int rc;
443
444   if (certid)
445     *certid = NULL;
446
447   if (!card)
448     return GNUPG_Invalid_Value;
449   if (idx < 0)
450     return GNUPG_Invalid_Index;
451   if (!card->fnc.initialized)
452     return GNUPG_Card_Not_Initialized;
453   if (!card->fnc.enum_certs)
454     return GNUPG_Unsupported_Operation;
455   rc = card->fnc.enum_certs (card, idx, certid, certtype);
456   if (opt.verbose)
457     log_info ("card operation enum_certs result: %s\n",
458               gnupg_strerror (rc));
459   return rc;
460 }
461
462
463
464 /* Read the certificate identified by CERTIDSTR which is the
465    hexadecimal encoded ID of the certificate, prefixed with the string
466    "3F005015.". The certificate is return in DER encoded form in CERT
467    and NCERT. */
468 int
469 card_read_cert (CARD card, const char *certidstr,
470                 unsigned char **cert, size_t *ncert)
471 {
472   int rc;
473
474   if (!card || !certidstr || !cert || !ncert)
475     return GNUPG_Invalid_Value;
476   if (!card->fnc.initialized)
477     return GNUPG_Card_Not_Initialized;
478   if (!card->fnc.read_cert)
479     return GNUPG_Unsupported_Operation;
480   rc = card->fnc.read_cert (card, certidstr, cert, ncert);
481   if (opt.verbose)
482     log_info ("card operation read_cert result: %s\n", gnupg_strerror (rc));
483   return rc;
484 }
485
486
487 /* Create the signature and return the allocated result in OUTDATA.
488    If a PIN is required the PINCB will be used to ask for the PIN; it
489    should return the PIN in an allocated buffer and put it into PIN.  */
490 int 
491 card_sign (CARD card, const char *keyidstr, int hashalgo,
492            int (pincb)(void*, const char *, char **),
493            void *pincb_arg,
494            const void *indata, size_t indatalen,
495            void **outdata, size_t *outdatalen )
496 {
497   int rc;
498
499   if (!card || !indata || !indatalen || !outdata || !outdatalen || !pincb)
500     return GNUPG_Invalid_Value;
501   if (!card->fnc.initialized)
502     return GNUPG_Card_Not_Initialized;
503   if (!card->fnc.sign)
504     return GNUPG_Unsupported_Operation;
505   rc =  card->fnc.sign (card, keyidstr, hashalgo,
506                         pincb, pincb_arg,
507                         indata, indatalen,
508                         outdata, outdatalen);
509   if (opt.verbose)
510     log_info ("card operation sign result: %s\n", gnupg_strerror (rc));
511   return rc;
512 }
513
514
515 /* Create the signature and return the allocated result in OUTDATA.
516    If a PIN is required the PINCB will be used to ask for the PIN; it
517    should return the PIN in an allocated buffer and put it into PIN.  */
518 int 
519 card_decipher (CARD card, const char *keyidstr,
520                int (pincb)(void*, const char *, char **),
521                void *pincb_arg,
522                const void *indata, size_t indatalen,
523                void **outdata, size_t *outdatalen )
524 {
525   int rc;
526
527   if (!card || !indata || !indatalen || !outdata || !outdatalen || !pincb)
528     return GNUPG_Invalid_Value;
529   if (!card->fnc.initialized)
530     return GNUPG_Card_Not_Initialized;
531   if (!card->fnc.decipher)
532     return GNUPG_Unsupported_Operation;
533   rc =  card->fnc.decipher (card, keyidstr,
534                             pincb, pincb_arg,
535                             indata, indatalen,
536                             outdata, outdatalen);
537   if (opt.verbose)
538     log_info ("card operation decipher result: %s\n", gnupg_strerror (rc));
539   return rc;
540 }