* call-agent.c (start_agent): Make copies of old locales and check
[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       goto leave;
142     }
143   card->ctx->error_file = log_get_stream ();
144   card->ctx->debug = opt.debug_sc;
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 2F02 GDO file.  */
261   /* FIXME: in case we can't parse the 2F02 EF and we have a P15 card,
262      we should get the serial number from the respective P15 file */
263   sc_format_path ("3F002F02", &path);
264   rc = sc_select_file (card->scard, &path, &file);
265   if (rc)
266     {
267       log_error ("sc_select_file failed: %s\n", sc_strerror (rc));
268       return GNUPG_Card_Error;
269     }
270   if (file->type != SC_FILE_TYPE_WORKING_EF
271       || file->ef_structure != SC_FILE_EF_TRANSPARENT)
272     {
273       log_error ("wrong type or structure of GDO file\n");
274       sc_file_free (file);
275       return GNUPG_Card_Error;
276     }
277   if (file->size != 12)
278     { /* FIXME: Use a real parser */
279       log_error ("unsupported size of GDO file\n");
280       sc_file_free (file);
281       return GNUPG_Card_Error;
282     }
283       
284   rc = sc_read_binary (card->scard, 0, buf, DIM (buf), 0);
285   sc_file_free (file);
286   if (rc < 0) 
287     {
288       log_error ("error reading GDO file: %s\n", sc_strerror (rc));
289       return GNUPG_Card_Error;
290     }
291   if (rc != file->size)
292     {
293       log_error ("short read on GDO file\n");
294       return GNUPG_Card_Error;
295     }
296   if (buf[0] != 0x5a || buf[1] != 10)
297     {
298       log_error ("invalid structure of GDO file\n");
299       return GNUPG_Card_Error;
300     }
301   *serial = s = xtrymalloc (21);
302   if (!*serial)
303     return GNUPG_Out_Of_Core;
304   for (i=0; i < 10; i++, s += 2)
305     sprintf (s, "%02X", buf[2+i]);
306   return 0;
307 }
308
309
310 /* Enumerate all keypairs on the card and return the Keygrip as well
311    as the internal identification of the key.  KEYGRIP must be a
312    caller provided buffer with a size of 20 bytes which will receive
313    the KEYGRIP of the keypair.  If KEYID is not NULL, it returns the
314    ID field of the key in allocated memory; this is a string without
315    spaces.  The function returns -1 when all keys have been
316    enumerated.  Note that the error GNUPG_Missing_Certificate may be
317    returned if there is just the private key but no public key (ie.e a
318    certificate) available.  Applications might want to continue
319    enumerating after this error.*/
320 int
321 card_enum_keypairs (CARD card, int idx,
322                     unsigned char *keygrip,
323                     char **keyid)
324 {
325   int rc;
326
327   if (keyid)
328     *keyid = NULL;
329
330   if (!card || !keygrip)
331     return GNUPG_Invalid_Value;
332   if (idx < 0)
333     return GNUPG_Invalid_Index;
334   if (!card->fnc.initialized)
335     return GNUPG_Card_Not_Initialized;
336   if (!card->fnc.enum_keypairs)
337     return GNUPG_Unsupported_Operation;
338   rc = card->fnc.enum_keypairs (card, idx, keygrip, keyid);
339   if (opt.verbose)
340     log_info ("card operation enum_keypairs result: %s\n",
341               gnupg_strerror (rc));
342   return rc;
343 }
344
345
346 /* Read the certificate identified by CERTIDSTR which is the
347    hexadecimal encoded ID of the certificate, prefixed with the string
348    "3F005015.". The certificate is return in DER encoded form in CERT
349    and NCERT. */
350 int
351 card_read_cert (CARD card, const char *certidstr,
352                 unsigned char **cert, size_t *ncert)
353 {
354   int rc;
355
356   if (!card || !certidstr || !cert || !ncert)
357     return GNUPG_Invalid_Value;
358   if (!card->fnc.initialized)
359     return GNUPG_Card_Not_Initialized;
360   if (!card->fnc.read_cert)
361     return GNUPG_Unsupported_Operation;
362   rc = card->fnc.read_cert (card, certidstr, cert, ncert);
363   if (opt.verbose)
364     log_info ("card operation read_cert result: %s\n", gnupg_strerror (rc));
365   return rc;
366 }
367
368
369 /* Create the signature and return the allocated result in OUTDATA.
370    If a PIN is required the PINCB will be used to ask for the PIN; it
371    should return the PIN in an allocated buffer and put it into PIN.  */
372 int 
373 card_sign (CARD card, const char *keyidstr, int hashalgo,
374            int (pincb)(void*, const char *, char **),
375            void *pincb_arg,
376            const void *indata, size_t indatalen,
377            void **outdata, size_t *outdatalen )
378 {
379   int rc;
380
381   if (!card || !indata || !indatalen || !outdata || !outdatalen || !pincb)
382     return GNUPG_Invalid_Value;
383   if (!card->fnc.initialized)
384     return GNUPG_Card_Not_Initialized;
385   if (!card->fnc.sign)
386     return GNUPG_Unsupported_Operation;
387   rc =  card->fnc.sign (card, keyidstr, hashalgo,
388                         pincb, pincb_arg,
389                         indata, indatalen,
390                         outdata, outdatalen);
391   if (opt.verbose)
392     log_info ("card operation sign result: %s\n", gnupg_strerror (rc));
393   return rc;
394 }
395
396
397 /* Create the signature and return the allocated result in OUTDATA.
398    If a PIN is required the PINCB will be used to ask for the PIN; it
399    should return the PIN in an allocated buffer and put it into PIN.  */
400 int 
401 card_decipher (CARD card, const char *keyidstr,
402                int (pincb)(void*, const char *, char **),
403                void *pincb_arg,
404                const void *indata, size_t indatalen,
405                void **outdata, size_t *outdatalen )
406 {
407   int rc;
408
409   if (!card || !indata || !indatalen || !outdata || !outdatalen || !pincb)
410     return GNUPG_Invalid_Value;
411   if (!card->fnc.initialized)
412     return GNUPG_Card_Not_Initialized;
413   if (!card->fnc.decipher)
414     return GNUPG_Unsupported_Operation;
415   rc =  card->fnc.decipher (card, keyidstr,
416                             pincb, pincb_arg,
417                             indata, indatalen,
418                             outdata, outdatalen);
419   if (opt.verbose)
420     log_info ("card operation decipher result: %s\n", gnupg_strerror (rc));
421   return rc;
422 }