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