* card.c (card_get_serial_and_stamp): Use the tokeinfo serial
[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->scard)
166         {
167           sc_unlock (card->scard);
168           sc_disconnect_card (card->scard, 0);
169           card->scard = NULL;
170         }
171       if (card->ctx)
172         {
173           sc_release_context (card->ctx);
174           card->ctx = NULL;
175         }
176       xfree (card);
177     }      
178 }
179
180 /* Locate a simple TLV encoded data object in BUFFER of LENGTH and
181    return a pointer to value as well as its length in NBYTES.  Return
182    NULL if it was not found.  Note, that the function does not check
183    whether the value fits into the provided buffer. */
184 static const char *
185 find_simple_tlv (const unsigned char *buffer, size_t length,
186                  int tag, size_t *nbytes)
187 {
188   const char *s = buffer;
189   size_t n = length;
190   size_t len;
191     
192   for (;;)
193     {
194       buffer = s;
195       if (n < 2)
196         return NULL; /* buffer too short for tag and length. */
197       len = s[1];
198       s += 2; n -= 2;
199       if (len == 255)
200         {
201           if (n < 2)
202             return NULL; /* we expected 2 more bytes with the length. */
203           len = (s[0] << 8) | s[1];
204           s += 2; n -= 2;
205         }
206       if (*buffer == tag)
207         {
208           *nbytes = len;
209           return s;
210         }
211       if (len > n)
212         return NULL; /* buffer too short to skip to the next tag. */
213       s += len; n -= len;
214     }
215 }
216
217 /* Find the ICC Serial Number within the provided BUFFER of LENGTH
218    (which should contain the GDO file) and return it as a hex encoded
219    string and allocated string in SERIAL.  Return an error code when
220    the ICCSN was not found. */
221 static int
222 find_iccsn (const unsigned char *buffer, size_t length, char **serial)
223 {
224   size_t n;
225   const unsigned char *s;
226   char *p;
227
228   s = find_simple_tlv (buffer, length, 0x5A, &n);
229   if (!s)
230     return GNUPG_Card_Error;
231   length -= s - buffer;
232   if (n > length)
233     {
234       /* Oops, it does not fit into the buffer.  This is an invalid
235          encoding (or the buffer is too short.  However, I have some
236          test cards with such an invalid encoding and therefore I use
237          this ugly workaround to return something I can further
238          experiment with. */
239       if (n == 0x0D && length+1 == n)
240         {
241           log_debug ("enabling BMI testcard workaround\n");
242           n--;
243         }
244       else
245         return GNUPG_Card_Error; /* Bad encoding; does not fit into buffer. */
246     }
247   if (!n)
248     return GNUPG_Card_Error; /* Well, that is too short. */
249
250   *serial = p = xtrymalloc (2*n+1);
251   if (!*serial)
252     return GNUPG_Out_Of_Core;
253   for (; n; n--, p += 2, s++)
254     sprintf (p, "%02X", *s);
255   *p = 0;
256   return 0;
257 }
258
259
260 /* Retrieve the serial number and the time of the last update of the
261    card.  The serial number is returned as a malloced string (hex
262    encoded) in SERIAL and the time of update is returned in STAMP.
263    If no update time is available the returned value is 0.  The serial
264    is mandatory for a PKCS_15 application and an error will be
265    returned if this value is not availbale.  For non-PKCS-15 cards a
266    serial number is constructed by other means. Caller must free
267    SERIAL unless the function returns an error. */
268 int 
269 card_get_serial_and_stamp (CARD card, char **serial, time_t *stamp)
270 {
271   int rc;
272   struct sc_path path;
273   struct sc_file *file;
274   unsigned char buf[256];
275   int buflen;
276
277   if (!card || !serial || !stamp)
278     return GNUPG_Invalid_Value;
279
280   *serial = NULL;
281   *stamp = 0; /* not available */
282
283   if (!card->fnc.initialized)
284     {
285       card->fnc.initialized = 1;
286       /* The first use of this card tries to figure out the type of the card 
287          and sets up the function pointers. */
288       rc = sc_pkcs15_bind (card->scard, &card->p15card);
289       if (rc)
290         {
291           if (rc != SC_ERROR_PKCS15_APP_NOT_FOUND)
292             log_error ("binding of existing PKCS-15 failed in reader %d: %s\n",
293                        card->reader, sc_strerror (rc));
294           card->p15card = NULL;
295           rc = 0;
296         }
297       if (card->p15card)
298         card_p15_bind (card);
299       else
300         card_dinsig_bind (card);
301       card->fnc.initialized = 1;
302     }
303       
304
305   /* We should lookup the iso 7812-1 and 8583-3 - argh ISO
306      practice is suppressing innovation - IETF rules!  So we
307      always get the serialnumber from the 2F02 GDO file.  */
308   /* FIXME: in case we can't parse the 2F02 EF and we have a P15 card,
309      we should get the serial number from the respective P15 file */
310   sc_format_path ("3F002F02", &path);
311   rc = sc_select_file (card->scard, &path, &file);
312   if (rc)
313     {
314       log_error ("sc_select_file failed: %s\n", sc_strerror (rc));
315       return GNUPG_Card_Error;
316     }
317   if (file->type != SC_FILE_TYPE_WORKING_EF
318       || file->ef_structure != SC_FILE_EF_TRANSPARENT)
319     {
320       log_error ("wrong type or structure of GDO file\n");
321       sc_file_free (file);
322       return GNUPG_Card_Error;
323     }
324
325   if (!file->size || file->size >= DIM(buf) )
326     { /* FIXME: Use a real parser */
327       log_error ("unsupported size of GDO file (%d)\n", file->size);
328       sc_file_free (file);
329       return GNUPG_Card_Error;
330     }
331   buflen = file->size;
332       
333   rc = sc_read_binary (card->scard, 0, buf, buflen, 0);
334   sc_file_free (file);
335   if (rc < 0) 
336     {
337       log_error ("error reading GDO file: %s\n", sc_strerror (rc));
338       return GNUPG_Card_Error;
339     }
340   if (rc != buflen)
341     {
342       log_error ("short read on GDO file\n");
343       return GNUPG_Card_Error;
344     }
345
346   rc = find_iccsn (buf, buflen, serial);
347   if (rc == GNUPG_Card_Error)
348     log_error ("invalid structure of GDO file\n");
349   if (!rc && card->p15card && !strcmp (*serial, "D27600000000000000000000"))
350     { /* This is a German card with a silly serial number.  Try to get
351          the serial number from the EF(TokenInfo). We indicate such a
352          serial number by the using the prefix: "FF0100". */
353       const char *efser = card->p15card->serial_number;
354       char *p;
355
356       if (!efser)
357         efser = "";
358         
359       xfree (*serial);
360       *serial = NULL;
361       p = xtrymalloc (strlen (efser) + 7);
362       if (!p)
363           rc = GNUPG_Out_Of_Core;
364       else
365         {
366           strcpy (p, "FF0100");
367           strcpy (p+6, efser);
368           *serial = p;
369         }
370     }
371   else if (!rc && **serial == 'F' && (*serial)[1] == 'F')
372     { /* The serial number starts with our special prefix.  This
373          requires that we put our default prefix "FF0000" in front. */
374       char *p = xtrymalloc (strlen (*serial) + 7);
375       if (!p)
376         {
377           xfree (*serial);
378           *serial = NULL;
379           rc = GNUPG_Out_Of_Core;
380         }
381       else
382         {
383           strcpy (p, "FF0000");
384           strcpy (p+6, *serial);
385           xfree (*serial);
386           *serial = p;
387         }
388     }
389   return rc;
390 }
391
392
393 /* Enumerate all keypairs on the card and return the Keygrip as well
394    as the internal identification of the key.  KEYGRIP must be a
395    caller provided buffer with a size of 20 bytes which will receive
396    the KEYGRIP of the keypair.  If KEYID is not NULL, it returns the
397    ID field of the key in allocated memory; this is a string without
398    spaces.  The function returns -1 when all keys have been
399    enumerated.  Note that the error GNUPG_Missing_Certificate may be
400    returned if there is just the private key but no public key (ie.e a
401    certificate) available.  Applications might want to continue
402    enumerating after this error.*/
403 int
404 card_enum_keypairs (CARD card, int idx,
405                     unsigned char *keygrip,
406                     char **keyid)
407 {
408   int rc;
409
410   if (keyid)
411     *keyid = NULL;
412
413   if (!card || !keygrip)
414     return GNUPG_Invalid_Value;
415   if (idx < 0)
416     return GNUPG_Invalid_Index;
417   if (!card->fnc.initialized)
418     return GNUPG_Card_Not_Initialized;
419   if (!card->fnc.enum_keypairs)
420     return GNUPG_Unsupported_Operation;
421   rc = card->fnc.enum_keypairs (card, idx, keygrip, keyid);
422   if (opt.verbose)
423     log_info ("card operation enum_keypairs result: %s\n",
424               gnupg_strerror (rc));
425   return rc;
426 }
427
428
429 /* Read the certificate identified by CERTIDSTR which is the
430    hexadecimal encoded ID of the certificate, prefixed with the string
431    "3F005015.". The certificate is return in DER encoded form in CERT
432    and NCERT. */
433 int
434 card_read_cert (CARD card, const char *certidstr,
435                 unsigned char **cert, size_t *ncert)
436 {
437   int rc;
438
439   if (!card || !certidstr || !cert || !ncert)
440     return GNUPG_Invalid_Value;
441   if (!card->fnc.initialized)
442     return GNUPG_Card_Not_Initialized;
443   if (!card->fnc.read_cert)
444     return GNUPG_Unsupported_Operation;
445   rc = card->fnc.read_cert (card, certidstr, cert, ncert);
446   if (opt.verbose)
447     log_info ("card operation read_cert result: %s\n", gnupg_strerror (rc));
448   return rc;
449 }
450
451
452 /* Create the signature and return the allocated result in OUTDATA.
453    If a PIN is required the PINCB will be used to ask for the PIN; it
454    should return the PIN in an allocated buffer and put it into PIN.  */
455 int 
456 card_sign (CARD card, const char *keyidstr, int hashalgo,
457            int (pincb)(void*, const char *, char **),
458            void *pincb_arg,
459            const void *indata, size_t indatalen,
460            void **outdata, size_t *outdatalen )
461 {
462   int rc;
463
464   if (!card || !indata || !indatalen || !outdata || !outdatalen || !pincb)
465     return GNUPG_Invalid_Value;
466   if (!card->fnc.initialized)
467     return GNUPG_Card_Not_Initialized;
468   if (!card->fnc.sign)
469     return GNUPG_Unsupported_Operation;
470   rc =  card->fnc.sign (card, keyidstr, hashalgo,
471                         pincb, pincb_arg,
472                         indata, indatalen,
473                         outdata, outdatalen);
474   if (opt.verbose)
475     log_info ("card operation sign result: %s\n", gnupg_strerror (rc));
476   return rc;
477 }
478
479
480 /* Create the signature and return the allocated result in OUTDATA.
481    If a PIN is required the PINCB will be used to ask for the PIN; it
482    should return the PIN in an allocated buffer and put it into PIN.  */
483 int 
484 card_decipher (CARD card, const char *keyidstr,
485                int (pincb)(void*, const char *, char **),
486                void *pincb_arg,
487                const void *indata, size_t indatalen,
488                void **outdata, size_t *outdatalen )
489 {
490   int rc;
491
492   if (!card || !indata || !indatalen || !outdata || !outdatalen || !pincb)
493     return GNUPG_Invalid_Value;
494   if (!card->fnc.initialized)
495     return GNUPG_Card_Not_Initialized;
496   if (!card->fnc.decipher)
497     return GNUPG_Unsupported_Operation;
498   rc =  card->fnc.decipher (card, keyidstr,
499                             pincb, pincb_arg,
500                             indata, indatalen,
501                             outdata, outdatalen);
502   if (opt.verbose)
503     log_info ("card operation decipher result: %s\n", gnupg_strerror (rc));
504   return rc;
505 }