* card-common.h (struct p15_private_s): Forward declaration. Add
[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 /* Read the certificate identified by CERTIDSTR which is the
432    hexadecimal encoded ID of the certificate, prefixed with the string
433    "3F005015.". The certificate is return in DER encoded form in CERT
434    and NCERT. */
435 int
436 card_read_cert (CARD card, const char *certidstr,
437                 unsigned char **cert, size_t *ncert)
438 {
439   int rc;
440
441   if (!card || !certidstr || !cert || !ncert)
442     return GNUPG_Invalid_Value;
443   if (!card->fnc.initialized)
444     return GNUPG_Card_Not_Initialized;
445   if (!card->fnc.read_cert)
446     return GNUPG_Unsupported_Operation;
447   rc = card->fnc.read_cert (card, certidstr, cert, ncert);
448   if (opt.verbose)
449     log_info ("card operation read_cert result: %s\n", gnupg_strerror (rc));
450   return rc;
451 }
452
453
454 /* Create the signature and return the allocated result in OUTDATA.
455    If a PIN is required the PINCB will be used to ask for the PIN; it
456    should return the PIN in an allocated buffer and put it into PIN.  */
457 int 
458 card_sign (CARD card, const char *keyidstr, int hashalgo,
459            int (pincb)(void*, const char *, char **),
460            void *pincb_arg,
461            const void *indata, size_t indatalen,
462            void **outdata, size_t *outdatalen )
463 {
464   int rc;
465
466   if (!card || !indata || !indatalen || !outdata || !outdatalen || !pincb)
467     return GNUPG_Invalid_Value;
468   if (!card->fnc.initialized)
469     return GNUPG_Card_Not_Initialized;
470   if (!card->fnc.sign)
471     return GNUPG_Unsupported_Operation;
472   rc =  card->fnc.sign (card, keyidstr, hashalgo,
473                         pincb, pincb_arg,
474                         indata, indatalen,
475                         outdata, outdatalen);
476   if (opt.verbose)
477     log_info ("card operation sign result: %s\n", gnupg_strerror (rc));
478   return rc;
479 }
480
481
482 /* Create the signature and return the allocated result in OUTDATA.
483    If a PIN is required the PINCB will be used to ask for the PIN; it
484    should return the PIN in an allocated buffer and put it into PIN.  */
485 int 
486 card_decipher (CARD card, const char *keyidstr,
487                int (pincb)(void*, const char *, char **),
488                void *pincb_arg,
489                const void *indata, size_t indatalen,
490                void **outdata, size_t *outdatalen )
491 {
492   int rc;
493
494   if (!card || !indata || !indatalen || !outdata || !outdatalen || !pincb)
495     return GNUPG_Invalid_Value;
496   if (!card->fnc.initialized)
497     return GNUPG_Card_Not_Initialized;
498   if (!card->fnc.decipher)
499     return GNUPG_Unsupported_Operation;
500   rc =  card->fnc.decipher (card, keyidstr,
501                             pincb, pincb_arg,
502                             indata, indatalen,
503                             outdata, outdatalen);
504   if (opt.verbose)
505     log_info ("card operation decipher result: %s\n", gnupg_strerror (rc));
506   return rc;
507 }