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