* card.c (card_open, card_close): Adjusted for changes in OpenSC.
[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 #if SC_MAX_SEC_ATTR_SIZE < 36
32 # error This is not the patched OpenSC version
33 #endif
34
35 #include "scdaemon.h"
36 #include "card-common.h"
37
38 /* Map the SC error codes to the GNUPG ones */
39 int
40 map_sc_err (int rc)
41 {
42   switch (rc)
43     {
44     case 0: rc = 0; break;
45     case SC_ERROR_CMD_TOO_SHORT:         rc = GNUPG_Card_Error; break;
46     case SC_ERROR_CMD_TOO_LONG:          rc = GNUPG_Card_Error; break;
47     case SC_ERROR_NOT_SUPPORTED:         rc = GNUPG_Not_Supported; break;
48     case SC_ERROR_TRANSMIT_FAILED:       rc = GNUPG_Card_Error; break;
49     case SC_ERROR_FILE_NOT_FOUND:        rc = GNUPG_Card_Error; break;
50     case SC_ERROR_INVALID_ARGUMENTS:     rc = GNUPG_Card_Error; break;
51     case SC_ERROR_PKCS15_APP_NOT_FOUND:  rc = GNUPG_No_PKCS15_App; break;
52     case SC_ERROR_REQUIRED_PARAMETER_NOT_FOUND: rc = GNUPG_Card_Error; break;
53     case SC_ERROR_OUT_OF_MEMORY:         rc = GNUPG_Out_Of_Core; break;
54     case SC_ERROR_NO_READERS_FOUND:      rc = GNUPG_Card_Error; break;
55     case SC_ERROR_OBJECT_NOT_VALID:      rc = GNUPG_Card_Error; break;
56     case SC_ERROR_ILLEGAL_RESPONSE:      rc = GNUPG_Card_Error; break;
57     case SC_ERROR_PIN_CODE_INCORRECT:    rc = GNUPG_Card_Error; break;
58     case SC_ERROR_SECURITY_STATUS_NOT_SATISFIED: rc = GNUPG_Card_Error; break;
59     case SC_ERROR_CONNECTING_TO_RES_MGR: rc = GNUPG_Card_Error; break;
60     case SC_ERROR_INVALID_ASN1_OBJECT:   rc = GNUPG_Card_Error; break;
61     case SC_ERROR_BUFFER_TOO_SMALL:      rc = GNUPG_Card_Error; break;
62     case SC_ERROR_CARD_NOT_PRESENT:      rc = GNUPG_Card_Not_Present; break;
63     case SC_ERROR_RESOURCE_MANAGER:      rc = GNUPG_Card_Error; break;
64     case SC_ERROR_CARD_REMOVED:          rc = GNUPG_Card_Removed; break;
65     case SC_ERROR_INVALID_PIN_LENGTH:    rc = GNUPG_Card_Error; break;
66     case SC_ERROR_UNKNOWN_SMARTCARD:     rc = GNUPG_Card_Error; break;
67     case SC_ERROR_UNKNOWN_REPLY:         rc = GNUPG_Card_Error; break;
68     case SC_ERROR_OBJECT_NOT_FOUND:      rc = GNUPG_Card_Error; break;
69     case SC_ERROR_CARD_RESET:            rc = GNUPG_Card_Reset; break;
70     case SC_ERROR_ASN1_OBJECT_NOT_FOUND: rc = GNUPG_Card_Error; break;
71     case SC_ERROR_ASN1_END_OF_CONTENTS:  rc = GNUPG_Card_Error; break;
72     case SC_ERROR_TOO_MANY_OBJECTS:      rc = GNUPG_Card_Error; break;
73     case SC_ERROR_INVALID_CARD:          rc = GNUPG_Invalid_Card; break;
74     case SC_ERROR_WRONG_LENGTH:          rc = GNUPG_Card_Error; break;
75     case SC_ERROR_RECORD_NOT_FOUND:      rc = GNUPG_Card_Error; break;
76     case SC_ERROR_INTERNAL:              rc = GNUPG_Card_Error; break;
77     default: rc = GNUPG_Card_Error; break;
78     }
79   return rc;
80 }
81
82 /* Get the keygrip from CERT, return 0 on success */
83 int
84 card_help_get_keygrip (KsbaCert cert, unsigned char *array)
85 {
86   GCRY_SEXP s_pkey;
87   int rc;
88   KsbaSexp p;
89   size_t n;
90   
91   p = ksba_cert_get_public_key (cert);
92   if (!p)
93     return -1; /* oops */
94   n = gcry_sexp_canon_len (p, 0, NULL, NULL);
95   if (!n)
96     return -1; /* libksba did not return a proper S-expression */
97   rc = gcry_sexp_sscan ( &s_pkey, NULL, p, n);
98   xfree (p);
99   if (rc)
100     return -1; /* can't parse that S-expression */
101   array = gcry_pk_get_keygrip (s_pkey, array);
102   gcry_sexp_release (s_pkey);
103   if (!array)
104     return -1; /* failed to calculate the keygrip */
105   return 0;
106 }
107
108
109
110
111
112
113 \f
114 /* Create a new context for the card and figures out some basic
115    information of the card.  Detects whgether a PKCS_15 application is
116    stored.
117
118    Common errors: GNUPG_Card_Not_Present */
119 int
120 card_open (CARD *rcard)
121 {
122   CARD card;
123   int rc;
124
125   card = xtrycalloc (1, sizeof *card);
126   if (!card)
127     return GNUPG_Out_Of_Core;
128   card->reader = 0;
129   
130   rc = sc_establish_context (&card->ctx, "scdaemon");
131   if (rc)
132     {
133       log_error ("failed to establish SC context: %s\n", sc_strerror (rc));
134       rc = map_sc_err (rc);
135       goto leave;
136     }
137   if (card->reader >= card->ctx->reader_count)
138     {
139       log_error ("no card reader available\n");
140       rc = GNUPG_Card_Error;
141     }
142   card->ctx->error_file = log_get_stream ();
143   if (opt.debug)
144     {
145        card->ctx->debug_file = log_get_stream ();
146     }
147   if (sc_detect_card_presence (card->ctx->reader[card->reader], 0) != 1)
148     {
149       rc = GNUPG_Card_Not_Present;
150       goto leave;
151     }
152
153   rc = sc_connect_card (card->ctx->reader[card->reader], 0, &card->scard);
154   if (rc)
155     {
156       log_error ("failed to connect card in reader %d: %s\n",
157                  card->reader, sc_strerror (rc));
158       rc = map_sc_err (rc);
159       goto leave;
160     }
161   if (opt.verbose)
162     log_info ("connected to card in reader %d using driver `%s'\n",
163               card->reader, card->scard->driver->name);
164
165   rc = sc_lock (card->scard);
166   if (rc)
167     {
168       log_error ("can't lock card in reader %d: %s\n",
169                  card->reader, sc_strerror (rc));
170       rc = map_sc_err (rc);
171       goto leave;
172     }
173
174     
175  leave:
176   if (rc)
177     card_close (card);
178   else
179     *rcard = card;
180   return rc;
181 }
182
183
184 /* Close a card and release all resources */
185 void
186 card_close (CARD card)
187 {
188   if (card)
189     {
190       if (card->p15card)
191         {
192           sc_pkcs15_unbind (card->p15card);
193           card->p15card = NULL;
194         }
195       if (card->scard)
196         {
197           sc_unlock (card->scard);
198           sc_disconnect_card (card->scard, 0);
199           card->scard = NULL;
200         }
201       if (card->ctx)
202         {
203           sc_release_context (card->ctx);
204           card->ctx = NULL;
205         }
206       xfree (card);
207     }      
208 }
209
210
211
212 /* Retrieve the serial number and the time of the last update of the
213    card.  The serial number is returned as a malloced string (hex
214    encoded) in SERIAL and the time of update is returned in STAMP.
215    If no update time is available the returned value is 0.  The serial
216    is mandatory for a PKCS_15 application and an error will be
217    returned if this value is not availbale.  For non-PKCS-15 cards a
218    serial number is constructed by other means. Caller must free
219    SERIAL unless the function returns an error. */
220 int 
221 card_get_serial_and_stamp (CARD card, char **serial, time_t *stamp)
222 {
223   char *s;
224   int rc;
225   struct sc_path path;
226   struct sc_file *file;
227   unsigned char buf[12];
228   int i;
229
230   if (!card || !serial || !stamp)
231     return GNUPG_Invalid_Value;
232
233   *serial = NULL;
234   *stamp = 0; /* not available */
235
236   if (!card->fnc.initialized)
237     {
238       card->fnc.initialized = 1;
239       /* The first use of this card tries to figure out the type of the card 
240          and sets up the function pointers. */
241       rc = sc_pkcs15_bind (card->scard, &card->p15card);
242       if (rc)
243         {
244           if (rc != SC_ERROR_PKCS15_APP_NOT_FOUND)
245             log_error ("binding of existing PKCS-15 failed in reader %d: %s\n",
246                        card->reader, sc_strerror (rc));
247           card->p15card = NULL;
248           rc = 0;
249         }
250       if (card->p15card)
251         card_p15_bind (card);
252       else
253         card_dinsig_bind (card);
254       card->fnc.initialized = 1;
255     }
256       
257
258   /* We should lookup the iso 7812-1 and 8583-3 - argh ISO
259      practice is suppressing innovation - IETF rules!  So we
260      always get the serialnumber from the 2F00 GDO file.  */
261   sc_format_path ("3F002F02", &path);
262   rc = sc_select_file (card->scard, &path, &file);
263   if (rc)
264     {
265       log_error ("sc_select_file failed: %s\n", sc_strerror (rc));
266       return GNUPG_Card_Error;
267     }
268   if (file->type != SC_FILE_TYPE_WORKING_EF
269       || file->ef_structure != SC_FILE_EF_TRANSPARENT)
270     {
271       log_error ("wrong type or structure of GDO file\n");
272       sc_file_free (file);
273       return GNUPG_Card_Error;
274     }
275   if (file->size != 12)
276     { /* FIXME: Use a real parser */
277       log_error ("unsupported size of GDO file\n");
278       sc_file_free (file);
279       return GNUPG_Card_Error;
280     }
281       
282   rc = sc_read_binary (card->scard, 0, buf, DIM (buf), 0);
283   sc_file_free (file);
284   if (rc < 0) 
285     {
286       log_error ("error reading GDO file: %s\n", sc_strerror (rc));
287       return GNUPG_Card_Error;
288     }
289   if (rc != file->size)
290     {
291       log_error ("short read on GDO file\n");
292       return GNUPG_Card_Error;
293     }
294   if (buf[0] != 0x5a || buf[1] != 10)
295     {
296       log_error ("invalid structure of GDO file\n");
297       return GNUPG_Card_Error;
298     }
299   *serial = s = xtrymalloc (21);
300   if (!*serial)
301     return GNUPG_Out_Of_Core;
302   for (i=0; i < 10; i++, s += 2)
303     sprintf (s, "%02X", buf[2+i]);
304   return 0;
305 }
306
307
308 /* Enumerate all keypairs on the card and return the Keygrip as well
309    as the internal identification of the key.  KEYGRIP must be a
310    caller provided buffer with a size of 20 bytes which will receive
311    the KEYGRIP of the keypair.  If KEYID is not NULL, it returns the
312    ID field of the key in allocated memory; this is a string without
313    spaces.  The function returns -1 when all keys have been
314    enumerated.  Note that the error GNUPG_Missing_Certificate may be
315    returned if there is just the private key but no public key (ie.e a
316    certificate) available.  Applications might want to continue
317    enumerating after this error.*/
318 int
319 card_enum_keypairs (CARD card, int idx,
320                     unsigned char *keygrip,
321                     char **keyid)
322 {
323   int rc;
324
325   if (keyid)
326     *keyid = NULL;
327
328   if (!card || !keygrip)
329     return GNUPG_Invalid_Value;
330   if (idx < 0)
331     return GNUPG_Invalid_Index;
332   if (!card->fnc.initialized)
333     return GNUPG_Card_Not_Initialized;
334   if (!card->fnc.enum_keypairs)
335     return GNUPG_Unsupported_Operation;
336   rc = card->fnc.enum_keypairs (card, idx, keygrip, keyid);
337   if (opt.verbose)
338     log_info ("card operation enum_keypairs result: %s\n",
339               gnupg_strerror (rc));
340   return rc;
341 }
342
343
344 /* Read the certificate identified by CERTIDSTR which is the
345    hexadecimal encoded ID of the certificate, prefixed with the string
346    "3F005015.". The certificate is return in DER encoded form in CERT
347    and NCERT. */
348 int
349 card_read_cert (CARD card, const char *certidstr,
350                 unsigned char **cert, size_t *ncert)
351 {
352   int rc;
353
354   if (!card || !certidstr || !cert || !ncert)
355     return GNUPG_Invalid_Value;
356   if (!card->fnc.initialized)
357     return GNUPG_Card_Not_Initialized;
358   if (!card->fnc.read_cert)
359     return GNUPG_Unsupported_Operation;
360   rc = card->fnc.read_cert (card, certidstr, cert, ncert);
361   if (opt.verbose)
362     log_info ("card operation read_cert result: %s\n", gnupg_strerror (rc));
363   return rc;
364 }
365
366
367 /* Create the signature and return the allocated result in OUTDATA.
368    If a PIN is required the PINCB will be used to ask for the PIN; it
369    should return the PIN in an allocated buffer and put it into PIN.  */
370 int 
371 card_sign (CARD card, const char *keyidstr, int hashalgo,
372            int (pincb)(void*, const char *, char **),
373            void *pincb_arg,
374            const void *indata, size_t indatalen,
375            void **outdata, size_t *outdatalen )
376 {
377   int rc;
378
379   if (!card || !indata || !indatalen || !outdata || !outdatalen || !pincb)
380     return GNUPG_Invalid_Value;
381   if (!card->fnc.initialized)
382     return GNUPG_Card_Not_Initialized;
383   if (!card->fnc.sign)
384     return GNUPG_Unsupported_Operation;
385   rc =  card->fnc.sign (card, keyidstr, hashalgo,
386                         pincb, pincb_arg,
387                         indata, indatalen,
388                         outdata, outdatalen);
389   if (opt.verbose)
390     log_info ("card operation sign result: %s\n", gnupg_strerror (rc));
391   return rc;
392 }
393
394
395 /* Create the signature and return the allocated result in OUTDATA.
396    If a PIN is required the PINCB will be used to ask for the PIN; it
397    should return the PIN in an allocated buffer and put it into PIN.  */
398 int 
399 card_decipher (CARD card, const char *keyidstr,
400                int (pincb)(void*, const char *, char **),
401                void *pincb_arg,
402                const void *indata, size_t indatalen,
403                void **outdata, size_t *outdatalen )
404 {
405   int rc;
406
407   if (!card || !indata || !indatalen || !outdata || !outdatalen || !pincb)
408     return GNUPG_Invalid_Value;
409   if (!card->fnc.initialized)
410     return GNUPG_Card_Not_Initialized;
411   if (!card->fnc.decipher)
412     return GNUPG_Unsupported_Operation;
413   rc =  card->fnc.decipher (card, keyidstr,
414                             pincb, pincb_arg,
415                             indata, indatalen,
416                             outdata, outdatalen);
417   if (opt.verbose)
418     log_info ("card operation decipher result: %s\n", gnupg_strerror (rc));
419   return rc;
420 }