Line data Source code
1 : /*
2 : * Copyright (c) 2004 - 2008 Kungliga Tekniska Högskolan
3 : * (Royal Institute of Technology, Stockholm, Sweden).
4 : * All rights reserved.
5 : *
6 : * Redistribution and use in source and binary forms, with or without
7 : * modification, are permitted provided that the following conditions
8 : * are met:
9 : *
10 : * 1. Redistributions of source code must retain the above copyright
11 : * notice, this list of conditions and the following disclaimer.
12 : *
13 : * 2. Redistributions in binary form must reproduce the above copyright
14 : * notice, this list of conditions and the following disclaimer in the
15 : * documentation and/or other materials provided with the distribution.
16 : *
17 : * 3. Neither the name of the Institute nor the names of its contributors
18 : * may be used to endorse or promote products derived from this software
19 : * without specific prior written permission.
20 : *
21 : * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND
22 : * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
23 : * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
24 : * ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE
25 : * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
26 : * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
27 : * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
28 : * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
29 : * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
30 : * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
31 : * SUCH DAMAGE.
32 : */
33 :
34 : #include "hx_locl.h"
35 :
36 : #ifdef HAVE_DLOPEN
37 :
38 : #include "ref/pkcs11.h"
39 :
40 : struct p11_slot {
41 : uint64_t flags;
42 : #define P11_SESSION 1
43 : #define P11_SESSION_IN_USE 2
44 : #define P11_LOGIN_REQ 4
45 : #define P11_LOGIN_DONE 8
46 : #define P11_TOKEN_PRESENT 16
47 : CK_SESSION_HANDLE session;
48 : CK_SLOT_ID id;
49 : CK_BBOOL token;
50 : char *name;
51 : hx509_certs certs;
52 : char *pin;
53 : struct {
54 : CK_MECHANISM_TYPE_PTR list;
55 : CK_ULONG num;
56 : CK_MECHANISM_INFO_PTR *infos;
57 : } mechs;
58 : };
59 :
60 : struct p11_module {
61 : void *dl_handle;
62 : CK_FUNCTION_LIST_PTR funcs;
63 : CK_ULONG num_slots;
64 : unsigned int ref;
65 : unsigned int selected_slot;
66 : struct p11_slot *slot;
67 : };
68 :
69 : #define P11FUNC(module,f,args) (*(module)->funcs->C_##f)args
70 :
71 : static int p11_get_session(hx509_context,
72 : struct p11_module *,
73 : struct p11_slot *,
74 : hx509_lock,
75 : CK_SESSION_HANDLE *);
76 : static int p11_put_session(struct p11_module *,
77 : struct p11_slot *,
78 : CK_SESSION_HANDLE);
79 : static void p11_release_module(struct p11_module *);
80 :
81 : static int p11_list_keys(hx509_context,
82 : struct p11_module *,
83 : struct p11_slot *,
84 : CK_SESSION_HANDLE,
85 : hx509_lock,
86 : hx509_certs *);
87 :
88 : /*
89 : *
90 : */
91 :
92 : struct p11_rsa {
93 : struct p11_module *p;
94 : struct p11_slot *slot;
95 : CK_OBJECT_HANDLE private_key;
96 : CK_OBJECT_HANDLE public_key;
97 : };
98 :
99 : static int
100 : p11_rsa_public_encrypt(int flen,
101 : const unsigned char *from,
102 : unsigned char *to,
103 : RSA *rsa,
104 : int padding)
105 : {
106 : return -1;
107 : }
108 :
109 : static int
110 : p11_rsa_public_decrypt(int flen,
111 : const unsigned char *from,
112 : unsigned char *to,
113 : RSA *rsa,
114 : int padding)
115 : {
116 : return -1;
117 : }
118 :
119 :
120 : static int
121 : p11_rsa_private_encrypt(int flen,
122 : const unsigned char *from,
123 : unsigned char *to,
124 : RSA *rsa,
125 : int padding)
126 : {
127 : struct p11_rsa *p11rsa = RSA_get_app_data(rsa);
128 : CK_OBJECT_HANDLE key = p11rsa->private_key;
129 : CK_SESSION_HANDLE session;
130 : CK_MECHANISM mechanism;
131 : CK_ULONG ck_sigsize;
132 : int ret;
133 :
134 : if (padding != RSA_PKCS1_PADDING)
135 : return -1;
136 :
137 : memset(&mechanism, 0, sizeof(mechanism));
138 : mechanism.mechanism = CKM_RSA_PKCS;
139 :
140 : ck_sigsize = RSA_size(rsa);
141 :
142 : ret = p11_get_session(NULL, p11rsa->p, p11rsa->slot, NULL, &session);
143 : if (ret)
144 : return -1;
145 :
146 : ret = P11FUNC(p11rsa->p, SignInit, (session, &mechanism, key));
147 : if (ret != CKR_OK) {
148 : p11_put_session(p11rsa->p, p11rsa->slot, session);
149 : return -1;
150 : }
151 :
152 : ret = P11FUNC(p11rsa->p, Sign,
153 : (session, (CK_BYTE *)(intptr_t)from, flen, to, &ck_sigsize));
154 : p11_put_session(p11rsa->p, p11rsa->slot, session);
155 : if (ret != CKR_OK)
156 : return -1;
157 :
158 : return ck_sigsize;
159 : }
160 :
161 : static int
162 : p11_rsa_private_decrypt(int flen, const unsigned char *from, unsigned char *to,
163 : RSA * rsa, int padding)
164 : {
165 : struct p11_rsa *p11rsa = RSA_get_app_data(rsa);
166 : CK_OBJECT_HANDLE key = p11rsa->private_key;
167 : CK_SESSION_HANDLE session;
168 : CK_MECHANISM mechanism;
169 : CK_ULONG ck_sigsize;
170 : int ret;
171 :
172 : if (padding != RSA_PKCS1_PADDING)
173 : return -1;
174 :
175 : memset(&mechanism, 0, sizeof(mechanism));
176 : mechanism.mechanism = CKM_RSA_PKCS;
177 :
178 : ck_sigsize = RSA_size(rsa);
179 :
180 : ret = p11_get_session(NULL, p11rsa->p, p11rsa->slot, NULL, &session);
181 : if (ret)
182 : return -1;
183 :
184 : ret = P11FUNC(p11rsa->p, DecryptInit, (session, &mechanism, key));
185 : if (ret != CKR_OK) {
186 : p11_put_session(p11rsa->p, p11rsa->slot, session);
187 : return -1;
188 : }
189 :
190 : ret = P11FUNC(p11rsa->p, Decrypt,
191 : (session, (CK_BYTE *)(intptr_t)from, flen, to, &ck_sigsize));
192 : p11_put_session(p11rsa->p, p11rsa->slot, session);
193 : if (ret != CKR_OK)
194 : return -1;
195 :
196 : return ck_sigsize;
197 : }
198 :
199 : static int
200 : p11_rsa_init(RSA *rsa)
201 : {
202 : return 1;
203 : }
204 :
205 : static int
206 : p11_rsa_finish(RSA *rsa)
207 : {
208 : struct p11_rsa *p11rsa = RSA_get_app_data(rsa);
209 : p11_release_module(p11rsa->p);
210 : free(p11rsa);
211 : return 1;
212 : }
213 :
214 : static const RSA_METHOD p11_rsa_pkcs1_method = {
215 : "hx509 PKCS11 PKCS#1 RSA",
216 : p11_rsa_public_encrypt,
217 : p11_rsa_public_decrypt,
218 : p11_rsa_private_encrypt,
219 : p11_rsa_private_decrypt,
220 : NULL,
221 : NULL,
222 : p11_rsa_init,
223 : p11_rsa_finish,
224 : 0,
225 : NULL,
226 : NULL,
227 : NULL,
228 : NULL
229 : };
230 :
231 : /*
232 : *
233 : */
234 :
235 : static int
236 : p11_mech_info(hx509_context context,
237 : struct p11_module *p,
238 : struct p11_slot *slot,
239 : int num)
240 : {
241 : CK_ULONG i;
242 : int ret;
243 :
244 : ret = P11FUNC(p, GetMechanismList, (slot->id, NULL_PTR, &i));
245 : if (ret) {
246 : hx509_set_error_string(context, 0, HX509_PKCS11_NO_MECH,
247 : "Failed to get mech list count for slot %d",
248 : num);
249 : return HX509_PKCS11_NO_MECH;
250 : }
251 : if (i == 0) {
252 : hx509_set_error_string(context, 0, HX509_PKCS11_NO_MECH,
253 : "no mech supported for slot %d", num);
254 : return HX509_PKCS11_NO_MECH;
255 : }
256 : slot->mechs.list = calloc(i, sizeof(slot->mechs.list[0]));
257 : if (slot->mechs.list == NULL) {
258 : hx509_set_error_string(context, 0, ENOMEM,
259 : "out of memory");
260 : return ENOMEM;
261 : }
262 : slot->mechs.num = i;
263 : ret = P11FUNC(p, GetMechanismList, (slot->id, slot->mechs.list, &i));
264 : if (ret) {
265 : hx509_set_error_string(context, 0, HX509_PKCS11_NO_MECH,
266 : "Failed to get mech list for slot %d",
267 : num);
268 : return HX509_PKCS11_NO_MECH;
269 : }
270 : assert(i == slot->mechs.num);
271 :
272 : slot->mechs.infos = calloc(i, sizeof(*slot->mechs.infos));
273 : if (slot->mechs.list == NULL) {
274 : hx509_set_error_string(context, 0, ENOMEM,
275 : "out of memory");
276 : return ENOMEM;
277 : }
278 :
279 : for (i = 0; i < slot->mechs.num; i++) {
280 : slot->mechs.infos[i] = calloc(1, sizeof(*(slot->mechs.infos[0])));
281 : if (slot->mechs.infos[i] == NULL) {
282 : hx509_set_error_string(context, 0, ENOMEM,
283 : "out of memory");
284 : return ENOMEM;
285 : }
286 : ret = P11FUNC(p, GetMechanismInfo, (slot->id, slot->mechs.list[i],
287 : slot->mechs.infos[i]));
288 : if (ret) {
289 : hx509_set_error_string(context, 0, HX509_PKCS11_NO_MECH,
290 : "Failed to get mech info for slot %d",
291 : num);
292 : return HX509_PKCS11_NO_MECH;
293 : }
294 : }
295 :
296 : return 0;
297 : }
298 :
299 : static int
300 : p11_init_slot(hx509_context context,
301 : struct p11_module *p,
302 : hx509_lock lock,
303 : CK_SLOT_ID id,
304 : int num,
305 : struct p11_slot *slot)
306 : {
307 : CK_SESSION_HANDLE session;
308 : CK_SLOT_INFO slot_info;
309 : CK_TOKEN_INFO token_info;
310 : size_t i;
311 : int ret;
312 :
313 : slot->certs = NULL;
314 : slot->id = id;
315 :
316 : ret = P11FUNC(p, GetSlotInfo, (slot->id, &slot_info));
317 : if (ret) {
318 : hx509_set_error_string(context, 0, HX509_PKCS11_TOKEN_CONFUSED,
319 : "Failed to init PKCS11 slot %d",
320 : num);
321 : return HX509_PKCS11_TOKEN_CONFUSED;
322 : }
323 :
324 : for (i = sizeof(slot_info.slotDescription) - 1; i > 0; i--) {
325 : char c = slot_info.slotDescription[i];
326 : if (c == ' ' || c == '\t' || c == '\n' || c == '\r' || c == '\0')
327 : continue;
328 : i++;
329 : break;
330 : }
331 :
332 : ret = asprintf(&slot->name, "%.*s", (int)i,
333 : slot_info.slotDescription);
334 : if (ret == -1)
335 : return ENOMEM;
336 :
337 : if ((slot_info.flags & CKF_TOKEN_PRESENT) == 0)
338 : return 0;
339 :
340 : ret = P11FUNC(p, GetTokenInfo, (slot->id, &token_info));
341 : if (ret) {
342 : hx509_set_error_string(context, 0, HX509_PKCS11_NO_TOKEN,
343 : "Failed to init PKCS11 slot %d "
344 : "with error 0x%08x",
345 : num, ret);
346 : return HX509_PKCS11_NO_TOKEN;
347 : }
348 : slot->flags |= P11_TOKEN_PRESENT;
349 :
350 : if (token_info.flags & CKF_LOGIN_REQUIRED)
351 : slot->flags |= P11_LOGIN_REQ;
352 :
353 : ret = p11_get_session(context, p, slot, lock, &session);
354 : if (ret)
355 : return ret;
356 :
357 : ret = p11_mech_info(context, p, slot, num);
358 : if (ret)
359 : goto out;
360 :
361 : ret = p11_list_keys(context, p, slot, session, lock, &slot->certs);
362 : out:
363 : p11_put_session(p, slot, session);
364 :
365 : return ret;
366 : }
367 :
368 : static int
369 : p11_get_session(hx509_context context,
370 : struct p11_module *p,
371 : struct p11_slot *slot,
372 : hx509_lock lock,
373 : CK_SESSION_HANDLE *psession)
374 : {
375 : CK_RV ret;
376 :
377 : if (slot->flags & P11_SESSION_IN_USE)
378 : _hx509_abort("slot already in session");
379 :
380 : if (slot->flags & P11_SESSION) {
381 : slot->flags |= P11_SESSION_IN_USE;
382 : *psession = slot->session;
383 : return 0;
384 : }
385 :
386 : ret = P11FUNC(p, OpenSession, (slot->id,
387 : CKF_SERIAL_SESSION,
388 : NULL,
389 : NULL,
390 : &slot->session));
391 : if (ret != CKR_OK) {
392 : if (context)
393 : hx509_set_error_string(context, 0, HX509_PKCS11_OPEN_SESSION,
394 : "Failed to OpenSession for slot id %d "
395 : "with error: 0x%08x",
396 : (int)slot->id, ret);
397 : return HX509_PKCS11_OPEN_SESSION;
398 : }
399 :
400 : slot->flags |= P11_SESSION;
401 :
402 : /*
403 : * If we have have to login, and haven't tried before and have a
404 : * prompter or known to work pin code.
405 : *
406 : * This code is very conversative and only uses the prompter in
407 : * the hx509_lock, the reason is that it's bad to try many
408 : * passwords on a pkcs11 token, it might lock up and have to be
409 : * unlocked by a administrator.
410 : *
411 : * XXX try harder to not use pin several times on the same card.
412 : */
413 :
414 : if ( (slot->flags & P11_LOGIN_REQ)
415 : && (slot->flags & P11_LOGIN_DONE) == 0
416 : && (lock || slot->pin))
417 : {
418 : hx509_prompt prompt;
419 : char pin[20];
420 : char *str;
421 :
422 : if (slot->pin == NULL) {
423 :
424 : memset(&prompt, 0, sizeof(prompt));
425 :
426 : ret = asprintf(&str, "PIN code for %s: ", slot->name);
427 : if (ret == -1 || str == NULL) {
428 : if (context)
429 : hx509_set_error_string(context, 0, ENOMEM, "out of memory");
430 : return ENOMEM;
431 : }
432 : prompt.prompt = str;
433 : prompt.type = HX509_PROMPT_TYPE_PASSWORD;
434 : prompt.reply.data = pin;
435 : prompt.reply.length = sizeof(pin);
436 :
437 : ret = hx509_lock_prompt(lock, &prompt);
438 : if (ret) {
439 : free(str);
440 : if (context)
441 : hx509_set_error_string(context, 0, ret,
442 : "Failed to get pin code for slot "
443 : "id %d with error: %d",
444 : (int)slot->id, ret);
445 : return ret;
446 : }
447 : free(str);
448 : } else {
449 : strlcpy(pin, slot->pin, sizeof(pin));
450 : }
451 :
452 : ret = P11FUNC(p, Login, (slot->session, CKU_USER,
453 : (unsigned char*)pin, strlen(pin)));
454 : if (ret != CKR_OK) {
455 : if (context)
456 : hx509_set_error_string(context, 0, HX509_PKCS11_LOGIN,
457 : "Failed to login on slot id %d "
458 : "with error: 0x%08x",
459 : (int)slot->id, ret);
460 : switch(ret) {
461 : case CKR_PIN_LOCKED:
462 : return HX509_PKCS11_PIN_LOCKED;
463 : case CKR_PIN_EXPIRED:
464 : return HX509_PKCS11_PIN_EXPIRED;
465 : case CKR_PIN_INCORRECT:
466 : return HX509_PKCS11_PIN_INCORRECT;
467 : case CKR_USER_PIN_NOT_INITIALIZED:
468 : return HX509_PKCS11_PIN_NOT_INITIALIZED;
469 : default:
470 : return HX509_PKCS11_LOGIN;
471 : }
472 : } else
473 : slot->flags |= P11_LOGIN_DONE;
474 :
475 : if (slot->pin == NULL) {
476 : slot->pin = strdup(pin);
477 : if (slot->pin == NULL) {
478 : if (context)
479 : hx509_set_error_string(context, 0, ENOMEM,
480 : "out of memory");
481 : return ENOMEM;
482 : }
483 : }
484 : } else
485 : slot->flags |= P11_LOGIN_DONE;
486 :
487 : slot->flags |= P11_SESSION_IN_USE;
488 :
489 : *psession = slot->session;
490 :
491 : return 0;
492 : }
493 :
494 : static int
495 : p11_put_session(struct p11_module *p,
496 : struct p11_slot *slot,
497 : CK_SESSION_HANDLE session)
498 : {
499 : if ((slot->flags & P11_SESSION_IN_USE) == 0)
500 : _hx509_abort("slot not in session");
501 : slot->flags &= ~P11_SESSION_IN_USE;
502 :
503 : return 0;
504 : }
505 :
506 : static int
507 : iterate_entries(hx509_context context,
508 : struct p11_module *p, struct p11_slot *slot,
509 : CK_SESSION_HANDLE session,
510 : CK_ATTRIBUTE *search_data, int num_search_data,
511 : CK_ATTRIBUTE *query, int num_query,
512 : int (*func)(hx509_context,
513 : struct p11_module *, struct p11_slot *,
514 : CK_SESSION_HANDLE session,
515 : CK_OBJECT_HANDLE object,
516 : void *, CK_ATTRIBUTE *, int), void *ptr)
517 : {
518 : CK_OBJECT_HANDLE object;
519 : CK_ULONG object_count;
520 : int ret, ret2, i;
521 :
522 : ret = P11FUNC(p, FindObjectsInit, (session, search_data, num_search_data));
523 : if (ret != CKR_OK) {
524 : return -1;
525 : }
526 : while (1) {
527 : ret = P11FUNC(p, FindObjects, (session, &object, 1, &object_count));
528 : if (ret != CKR_OK) {
529 : return -1;
530 : }
531 : if (object_count == 0)
532 : break;
533 :
534 : for (i = 0; i < num_query; i++)
535 : query[i].pValue = NULL;
536 :
537 : ret = P11FUNC(p, GetAttributeValue,
538 : (session, object, query, num_query));
539 : if (ret != CKR_OK) {
540 : return -1;
541 : }
542 : for (i = 0; i < num_query; i++) {
543 : query[i].pValue = malloc(query[i].ulValueLen);
544 : if (query[i].pValue == NULL) {
545 : ret = ENOMEM;
546 : goto out;
547 : }
548 : }
549 : ret = P11FUNC(p, GetAttributeValue,
550 : (session, object, query, num_query));
551 : if (ret != CKR_OK) {
552 : ret = -1;
553 : goto out;
554 : }
555 :
556 : ret = (*func)(context, p, slot, session, object, ptr, query, num_query);
557 : if (ret)
558 : goto out;
559 :
560 : for (i = 0; i < num_query; i++) {
561 : if (query[i].pValue)
562 : free(query[i].pValue);
563 : query[i].pValue = NULL;
564 : }
565 : }
566 : out:
567 :
568 : for (i = 0; i < num_query; i++) {
569 : if (query[i].pValue)
570 : free(query[i].pValue);
571 : query[i].pValue = NULL;
572 : }
573 :
574 : ret2 = P11FUNC(p, FindObjectsFinal, (session));
575 : if (ret2 != CKR_OK) {
576 : return ret2;
577 : }
578 :
579 : return ret;
580 : }
581 :
582 : static BIGNUM *
583 : getattr_bn(struct p11_module *p,
584 : struct p11_slot *slot,
585 : CK_SESSION_HANDLE session,
586 : CK_OBJECT_HANDLE object,
587 : unsigned int type)
588 : {
589 : CK_ATTRIBUTE query;
590 : BIGNUM *bn;
591 : int ret;
592 :
593 : query.type = type;
594 : query.pValue = NULL;
595 : query.ulValueLen = 0;
596 :
597 : ret = P11FUNC(p, GetAttributeValue,
598 : (session, object, &query, 1));
599 : if (ret != CKR_OK)
600 : return NULL;
601 :
602 : query.pValue = malloc(query.ulValueLen);
603 :
604 : ret = P11FUNC(p, GetAttributeValue,
605 : (session, object, &query, 1));
606 : if (ret != CKR_OK) {
607 : free(query.pValue);
608 : return NULL;
609 : }
610 : bn = BN_bin2bn(query.pValue, query.ulValueLen, NULL);
611 : free(query.pValue);
612 :
613 : return bn;
614 : }
615 :
616 : static int
617 : collect_private_key(hx509_context context,
618 : struct p11_module *p, struct p11_slot *slot,
619 : CK_SESSION_HANDLE session,
620 : CK_OBJECT_HANDLE object,
621 : void *ptr, CK_ATTRIBUTE *query, int num_query)
622 : {
623 : struct hx509_collector *collector = ptr;
624 : hx509_private_key key;
625 : heim_octet_string localKeyId;
626 : int ret;
627 : RSA *rsa;
628 : struct p11_rsa *p11rsa;
629 :
630 : localKeyId.data = query[0].pValue;
631 : localKeyId.length = query[0].ulValueLen;
632 :
633 : ret = hx509_private_key_init(&key, NULL, NULL);
634 : if (ret)
635 : return ret;
636 :
637 : rsa = RSA_new();
638 : if (rsa == NULL)
639 : _hx509_abort("out of memory");
640 :
641 : /*
642 : * The exponent and modulus should always be present according to
643 : * the pkcs11 specification, but some smartcards leaves it out,
644 : * let ignore any failure to fetch it.
645 : */
646 : rsa->n = getattr_bn(p, slot, session, object, CKA_MODULUS);
647 : rsa->e = getattr_bn(p, slot, session, object, CKA_PUBLIC_EXPONENT);
648 :
649 : p11rsa = calloc(1, sizeof(*p11rsa));
650 : if (p11rsa == NULL)
651 : _hx509_abort("out of memory");
652 :
653 : p11rsa->p = p;
654 : p11rsa->slot = slot;
655 : p11rsa->private_key = object;
656 :
657 : if (p->ref == 0)
658 : _hx509_abort("pkcs11 ref == 0 on alloc");
659 : p->ref++;
660 : if (p->ref == UINT_MAX)
661 : _hx509_abort("pkcs11 ref == UINT_MAX on alloc");
662 :
663 : RSA_set_method(rsa, &p11_rsa_pkcs1_method);
664 : ret = RSA_set_app_data(rsa, p11rsa);
665 : if (ret != 1)
666 : _hx509_abort("RSA_set_app_data");
667 :
668 : hx509_private_key_assign_rsa(key, rsa);
669 :
670 : ret = _hx509_collector_private_key_add(context,
671 : collector,
672 : hx509_signature_rsa(),
673 : key,
674 : NULL,
675 : &localKeyId);
676 :
677 : if (ret) {
678 : hx509_private_key_free(&key);
679 : return ret;
680 : }
681 : return 0;
682 : }
683 :
684 : static void
685 : p11_cert_release(hx509_cert cert, void *ctx)
686 : {
687 : struct p11_module *p = ctx;
688 : p11_release_module(p);
689 : }
690 :
691 :
692 : static int
693 : collect_cert(hx509_context context,
694 : struct p11_module *p, struct p11_slot *slot,
695 : CK_SESSION_HANDLE session,
696 : CK_OBJECT_HANDLE object,
697 : void *ptr, CK_ATTRIBUTE *query, int num_query)
698 : {
699 : struct hx509_collector *collector = ptr;
700 : heim_error_t error = NULL;
701 : hx509_cert cert;
702 : int ret;
703 :
704 : if ((CK_LONG)query[0].ulValueLen == -1 ||
705 : (CK_LONG)query[1].ulValueLen == -1)
706 : {
707 : return 0;
708 : }
709 :
710 : cert = hx509_cert_init_data(context, query[1].pValue,
711 : query[1].ulValueLen, &error);
712 : if (cert == NULL) {
713 : ret = heim_error_get_code(error);
714 : heim_release(error);
715 : return ret;
716 : }
717 :
718 : if (p->ref == 0)
719 : _hx509_abort("pkcs11 ref == 0 on alloc");
720 : p->ref++;
721 : if (p->ref == UINT_MAX)
722 : _hx509_abort("pkcs11 ref to high");
723 :
724 : _hx509_cert_set_release(cert, p11_cert_release, p);
725 :
726 : {
727 : heim_octet_string data;
728 :
729 : data.data = query[0].pValue;
730 : data.length = query[0].ulValueLen;
731 :
732 : _hx509_set_cert_attribute(context,
733 : cert,
734 : &asn1_oid_id_pkcs_9_at_localKeyId,
735 : &data);
736 : }
737 :
738 : if ((CK_LONG)query[2].ulValueLen != -1) {
739 : char *str;
740 :
741 : ret = asprintf(&str, "%.*s",
742 : (int)query[2].ulValueLen, (char *)query[2].pValue);
743 : if (ret != -1 && str) {
744 : hx509_cert_set_friendly_name(cert, str);
745 : free(str);
746 : }
747 : }
748 :
749 : ret = _hx509_collector_certs_add(context, collector, cert);
750 : hx509_cert_free(cert);
751 :
752 : return ret;
753 : }
754 :
755 :
756 : static int
757 : p11_list_keys(hx509_context context,
758 : struct p11_module *p,
759 : struct p11_slot *slot,
760 : CK_SESSION_HANDLE session,
761 : hx509_lock lock,
762 : hx509_certs *certs)
763 : {
764 : struct hx509_collector *collector;
765 : CK_OBJECT_CLASS key_class;
766 : CK_ATTRIBUTE search_data[] = {
767 : {CKA_CLASS, NULL, 0},
768 : };
769 : CK_ATTRIBUTE query_data[3] = {
770 : {CKA_ID, NULL, 0},
771 : {CKA_VALUE, NULL, 0},
772 : {CKA_LABEL, NULL, 0}
773 : };
774 : int ret;
775 :
776 : search_data[0].pValue = &key_class;
777 : search_data[0].ulValueLen = sizeof(key_class);
778 :
779 : if (lock == NULL)
780 : lock = _hx509_empty_lock;
781 :
782 : ret = _hx509_collector_alloc(context, lock, &collector);
783 : if (ret)
784 : return ret;
785 :
786 : key_class = CKO_PRIVATE_KEY;
787 : ret = iterate_entries(context, p, slot, session,
788 : search_data, 1,
789 : query_data, 1,
790 : collect_private_key, collector);
791 : if (ret)
792 : goto out;
793 :
794 : key_class = CKO_CERTIFICATE;
795 : ret = iterate_entries(context, p, slot, session,
796 : search_data, 1,
797 : query_data, 3,
798 : collect_cert, collector);
799 : if (ret)
800 : goto out;
801 :
802 : ret = _hx509_collector_collect_certs(context, collector, &slot->certs);
803 :
804 : out:
805 : _hx509_collector_free(collector);
806 :
807 : return ret;
808 : }
809 :
810 :
811 : static int
812 : p11_init(hx509_context context,
813 : hx509_certs certs, void **data, int flags,
814 : const char *residue, hx509_lock lock)
815 : {
816 : CK_C_GetFunctionList getFuncs;
817 : struct p11_module *p;
818 : char *list, *str;
819 : int ret;
820 :
821 : *data = NULL;
822 :
823 : if (flags & HX509_CERTS_NO_PRIVATE_KEYS) {
824 : hx509_set_error_string(context, 0, ENOTSUP,
825 : "PKCS#11 store does not support "
826 : "HX509_CERTS_NO_PRIVATE_KEYS flag");
827 : return ENOTSUP;
828 : }
829 :
830 : if (residue == NULL || residue[0] == '\0') {
831 : hx509_set_error_string(context, 0, EINVAL,
832 : "PKCS#11 store not specified");
833 : return EINVAL;
834 : }
835 : list = strdup(residue);
836 : if (list == NULL)
837 : return ENOMEM;
838 :
839 : p = calloc(1, sizeof(*p));
840 : if (p == NULL) {
841 : free(list);
842 : return ENOMEM;
843 : }
844 :
845 : p->ref = 1;
846 : p->selected_slot = 0;
847 :
848 : str = strchr(list, ',');
849 : if (str)
850 : *str++ = '\0';
851 : while (str) {
852 : char *strnext;
853 : strnext = strchr(str, ',');
854 : if (strnext)
855 : *strnext++ = '\0';
856 : if (strncasecmp(str, "slot=", 5) == 0)
857 : p->selected_slot = atoi(str + 5);
858 : str = strnext;
859 : }
860 :
861 : p->dl_handle = dlopen(list, RTLD_NOW | RTLD_LOCAL | RTLD_GROUP);
862 : if (p->dl_handle == NULL) {
863 : ret = HX509_PKCS11_LOAD;
864 : hx509_set_error_string(context, 0, ret,
865 : "Failed to open %s: %s", list, dlerror());
866 : goto out;
867 : }
868 :
869 : getFuncs = (CK_C_GetFunctionList) dlsym(p->dl_handle, "C_GetFunctionList");
870 : if (getFuncs == NULL) {
871 : ret = HX509_PKCS11_LOAD;
872 : hx509_set_error_string(context, 0, ret,
873 : "C_GetFunctionList missing in %s: %s",
874 : list, dlerror());
875 : goto out;
876 : }
877 :
878 : ret = (*getFuncs)(&p->funcs);
879 : if (ret) {
880 : ret = HX509_PKCS11_LOAD;
881 : hx509_set_error_string(context, 0, ret,
882 : "C_GetFunctionList failed in %s", list);
883 : goto out;
884 : }
885 :
886 : ret = P11FUNC(p, Initialize, (NULL_PTR));
887 : if (ret != CKR_OK) {
888 : ret = HX509_PKCS11_TOKEN_CONFUSED;
889 : hx509_set_error_string(context, 0, ret,
890 : "Failed initialize the PKCS11 module");
891 : goto out;
892 : }
893 :
894 : ret = P11FUNC(p, GetSlotList, (FALSE, NULL, &p->num_slots));
895 : if (ret) {
896 : ret = HX509_PKCS11_TOKEN_CONFUSED;
897 : hx509_set_error_string(context, 0, ret,
898 : "Failed to get number of PKCS11 slots");
899 : goto out;
900 : }
901 :
902 : if (p->num_slots == 0) {
903 : ret = HX509_PKCS11_NO_SLOT;
904 : hx509_set_error_string(context, 0, ret,
905 : "Selected PKCS11 module have no slots");
906 : goto out;
907 : }
908 :
909 :
910 : {
911 : CK_SLOT_ID_PTR slot_ids;
912 : int num_tokens = 0;
913 : size_t i;
914 :
915 : slot_ids = malloc(p->num_slots * sizeof(*slot_ids));
916 : if (slot_ids == NULL) {
917 : hx509_clear_error_string(context);
918 : ret = ENOMEM;
919 : goto out;
920 : }
921 :
922 : ret = P11FUNC(p, GetSlotList, (FALSE, slot_ids, &p->num_slots));
923 : if (ret) {
924 : free(slot_ids);
925 : hx509_set_error_string(context, 0, HX509_PKCS11_TOKEN_CONFUSED,
926 : "Failed getting slot-list from "
927 : "PKCS11 module");
928 : ret = HX509_PKCS11_TOKEN_CONFUSED;
929 : goto out;
930 : }
931 :
932 : p->slot = calloc(p->num_slots, sizeof(p->slot[0]));
933 : if (p->slot == NULL) {
934 : free(slot_ids);
935 : hx509_set_error_string(context, 0, ENOMEM,
936 : "Failed to get memory for slot-list");
937 : ret = ENOMEM;
938 : goto out;
939 : }
940 :
941 : for (i = 0; i < p->num_slots; i++) {
942 : if ((p->selected_slot != 0) && (slot_ids[i] != (p->selected_slot - 1)))
943 : continue;
944 : ret = p11_init_slot(context, p, lock, slot_ids[i], i, &p->slot[i]);
945 : if (!ret) {
946 : if (p->slot[i].flags & P11_TOKEN_PRESENT)
947 : num_tokens++;
948 : }
949 : }
950 : free(slot_ids);
951 : if (ret)
952 : goto out;
953 : if (num_tokens == 0) {
954 : ret = HX509_PKCS11_NO_TOKEN;
955 : goto out;
956 : }
957 : }
958 :
959 : free(list);
960 :
961 : *data = p;
962 :
963 : return 0;
964 : out:
965 : if (list)
966 : free(list);
967 : p11_release_module(p);
968 : return ret;
969 : }
970 :
971 : static void
972 : p11_release_module(struct p11_module *p)
973 : {
974 : size_t i;
975 :
976 : if (p->ref == 0)
977 : _hx509_abort("pkcs11 ref to low");
978 : if (--p->ref > 0)
979 : return;
980 :
981 : for (i = 0; i < p->num_slots; i++) {
982 : if (p->slot[i].flags & P11_SESSION_IN_USE)
983 : _hx509_abort("pkcs11 module release while session in use");
984 : if (p->slot[i].flags & P11_SESSION) {
985 : P11FUNC(p, CloseSession, (p->slot[i].session));
986 : }
987 :
988 : if (p->slot[i].name)
989 : free(p->slot[i].name);
990 : if (p->slot[i].pin) {
991 : memset(p->slot[i].pin, 0, strlen(p->slot[i].pin));
992 : free(p->slot[i].pin);
993 : }
994 : if (p->slot[i].mechs.num) {
995 : free(p->slot[i].mechs.list);
996 :
997 : if (p->slot[i].mechs.infos) {
998 : size_t j;
999 :
1000 : for (j = 0 ; j < p->slot[i].mechs.num ; j++)
1001 : free(p->slot[i].mechs.infos[j]);
1002 : free(p->slot[i].mechs.infos);
1003 : }
1004 : }
1005 : }
1006 : free(p->slot);
1007 :
1008 : if (p->funcs)
1009 : P11FUNC(p, Finalize, (NULL));
1010 :
1011 : if (p->dl_handle)
1012 : dlclose(p->dl_handle);
1013 :
1014 : memset(p, 0, sizeof(*p));
1015 : free(p);
1016 : }
1017 :
1018 : static int
1019 : p11_free(hx509_certs certs, void *data)
1020 : {
1021 : struct p11_module *p = data;
1022 : size_t i;
1023 :
1024 : for (i = 0; i < p->num_slots; i++) {
1025 : if (p->slot[i].certs)
1026 : hx509_certs_free(&p->slot[i].certs);
1027 : }
1028 : p11_release_module(p);
1029 : return 0;
1030 : }
1031 :
1032 : struct p11_cursor {
1033 : hx509_certs certs;
1034 : void *cursor;
1035 : };
1036 :
1037 : static int
1038 : p11_iter_start(hx509_context context,
1039 : hx509_certs certs, void *data, void **cursor)
1040 : {
1041 : struct p11_module *p = data;
1042 : struct p11_cursor *c;
1043 : int ret;
1044 : size_t i;
1045 :
1046 : c = malloc(sizeof(*c));
1047 : if (c == NULL) {
1048 : hx509_clear_error_string(context);
1049 : return ENOMEM;
1050 : }
1051 : ret = hx509_certs_init(context, "MEMORY:pkcs11-iter", 0, NULL, &c->certs);
1052 : if (ret) {
1053 : free(c);
1054 : return ret;
1055 : }
1056 :
1057 : for (i = 0 ; i < p->num_slots; i++) {
1058 : if (p->slot[i].certs == NULL)
1059 : continue;
1060 : ret = hx509_certs_merge(context, c->certs, p->slot[i].certs);
1061 : if (ret) {
1062 : hx509_certs_free(&c->certs);
1063 : free(c);
1064 : return ret;
1065 : }
1066 : }
1067 :
1068 : ret = hx509_certs_start_seq(context, c->certs, &c->cursor);
1069 : if (ret) {
1070 : hx509_certs_free(&c->certs);
1071 : free(c);
1072 : return 0;
1073 : }
1074 : *cursor = c;
1075 :
1076 : return 0;
1077 : }
1078 :
1079 : static int
1080 : p11_iter(hx509_context context,
1081 : hx509_certs certs, void *data, void *cursor, hx509_cert *cert)
1082 : {
1083 : struct p11_cursor *c = cursor;
1084 : return hx509_certs_next_cert(context, c->certs, c->cursor, cert);
1085 : }
1086 :
1087 : static int
1088 : p11_iter_end(hx509_context context,
1089 : hx509_certs certs, void *data, void *cursor)
1090 : {
1091 : struct p11_cursor *c = cursor;
1092 : int ret;
1093 : ret = hx509_certs_end_seq(context, c->certs, c->cursor);
1094 : hx509_certs_free(&c->certs);
1095 : free(c);
1096 : return ret;
1097 : }
1098 :
1099 : #define MECHFLAG(x) { "unknown-flag-" #x, x }
1100 : static struct units mechflags[] = {
1101 : MECHFLAG(0x80000000),
1102 : MECHFLAG(0x40000000),
1103 : MECHFLAG(0x20000000),
1104 : MECHFLAG(0x10000000),
1105 : MECHFLAG(0x08000000),
1106 : MECHFLAG(0x04000000),
1107 : {"ec-compress", 0x2000000 },
1108 : {"ec-uncompress", 0x1000000 },
1109 : {"ec-namedcurve", 0x0800000 },
1110 : {"ec-ecparameters", 0x0400000 },
1111 : {"ec-f-2m", 0x0200000 },
1112 : {"ec-f-p", 0x0100000 },
1113 : {"derive", 0x0080000 },
1114 : {"unwrap", 0x0040000 },
1115 : {"wrap", 0x0020000 },
1116 : {"genereate-key-pair", 0x0010000 },
1117 : {"generate", 0x0008000 },
1118 : {"verify-recover", 0x0004000 },
1119 : {"verify", 0x0002000 },
1120 : {"sign-recover", 0x0001000 },
1121 : {"sign", 0x0000800 },
1122 : {"digest", 0x0000400 },
1123 : {"decrypt", 0x0000200 },
1124 : {"encrypt", 0x0000100 },
1125 : MECHFLAG(0x00080),
1126 : MECHFLAG(0x00040),
1127 : MECHFLAG(0x00020),
1128 : MECHFLAG(0x00010),
1129 : MECHFLAG(0x00008),
1130 : MECHFLAG(0x00004),
1131 : MECHFLAG(0x00002),
1132 : {"hw", 0x0000001 },
1133 : { NULL, 0x0000000 }
1134 : };
1135 : #undef MECHFLAG
1136 :
1137 : static int
1138 : p11_printinfo(hx509_context context,
1139 : hx509_certs certs,
1140 : void *data,
1141 : int (*func)(void *, const char *),
1142 : void *ctx)
1143 : {
1144 : struct p11_module *p = data;
1145 : size_t i, j;
1146 :
1147 : _hx509_pi_printf(func, ctx, "pkcs11 driver with %d slot%s",
1148 : p->num_slots, p->num_slots > 1 ? "s" : "");
1149 :
1150 : for (i = 0; i < p->num_slots; i++) {
1151 : struct p11_slot *s = &p->slot[i];
1152 :
1153 : _hx509_pi_printf(func, ctx, "slot %d: id: %d name: %s flags: %08x",
1154 : i, (int)s->id, s->name, s->flags);
1155 :
1156 : _hx509_pi_printf(func, ctx, "number of supported mechanisms: %lu",
1157 : (unsigned long)s->mechs.num);
1158 : for (j = 0; j < s->mechs.num; j++) {
1159 : const char *mechname = "unknown";
1160 : char flags[256], unknownname[40];
1161 : #define MECHNAME(s,n) case s: mechname = n; break
1162 : switch(s->mechs.list[j]) {
1163 : MECHNAME(CKM_RSA_PKCS_KEY_PAIR_GEN, "rsa-pkcs-key-pair-gen");
1164 : MECHNAME(CKM_RSA_PKCS, "rsa-pkcs");
1165 : MECHNAME(CKM_RSA_X_509, "rsa-x-509");
1166 : MECHNAME(CKM_MD5_RSA_PKCS, "md5-rsa-pkcs");
1167 : MECHNAME(CKM_SHA1_RSA_PKCS, "sha1-rsa-pkcs");
1168 : MECHNAME(CKM_SHA256_RSA_PKCS, "sha256-rsa-pkcs");
1169 : MECHNAME(CKM_SHA384_RSA_PKCS, "sha384-rsa-pkcs");
1170 : MECHNAME(CKM_SHA512_RSA_PKCS, "sha512-rsa-pkcs");
1171 : MECHNAME(CKM_RIPEMD160_RSA_PKCS, "ripemd160-rsa-pkcs");
1172 : MECHNAME(CKM_RSA_PKCS_OAEP, "rsa-pkcs-oaep");
1173 : MECHNAME(CKM_SHA512_HMAC, "sha512-hmac");
1174 : MECHNAME(CKM_SHA512, "sha512");
1175 : MECHNAME(CKM_SHA384_HMAC, "sha384-hmac");
1176 : MECHNAME(CKM_SHA384, "sha384");
1177 : MECHNAME(CKM_SHA256_HMAC, "sha256-hmac");
1178 : MECHNAME(CKM_SHA256, "sha256");
1179 : MECHNAME(CKM_SHA_1, "sha1");
1180 : MECHNAME(CKM_MD5, "md5");
1181 : MECHNAME(CKM_RIPEMD160, "ripemd-160");
1182 : MECHNAME(CKM_DES_ECB, "des-ecb");
1183 : MECHNAME(CKM_DES_CBC, "des-cbc");
1184 : MECHNAME(CKM_AES_ECB, "aes-ecb");
1185 : MECHNAME(CKM_AES_CBC, "aes-cbc");
1186 : MECHNAME(CKM_DH_PKCS_PARAMETER_GEN, "dh-pkcs-parameter-gen");
1187 : default:
1188 : snprintf(unknownname, sizeof(unknownname),
1189 : "unknown-mech-%lu",
1190 : (unsigned long)s->mechs.list[j]);
1191 : mechname = unknownname;
1192 : break;
1193 : }
1194 : #undef MECHNAME
1195 : unparse_flags(s->mechs.infos[j]->flags, mechflags,
1196 : flags, sizeof(flags));
1197 :
1198 : _hx509_pi_printf(func, ctx, " %s: %s", mechname, flags);
1199 : }
1200 : }
1201 :
1202 : return 0;
1203 : }
1204 :
1205 : static struct hx509_keyset_ops keyset_pkcs11 = {
1206 : "PKCS11",
1207 : 0,
1208 : p11_init,
1209 : NULL,
1210 : p11_free,
1211 : NULL,
1212 : NULL,
1213 : p11_iter_start,
1214 : p11_iter,
1215 : p11_iter_end,
1216 : p11_printinfo,
1217 : NULL,
1218 : NULL,
1219 : NULL
1220 : };
1221 :
1222 : #endif /* HAVE_DLOPEN */
1223 :
1224 : HX509_LIB_FUNCTION void HX509_LIB_CALL
1225 792004 : _hx509_ks_pkcs11_register(hx509_context context)
1226 : {
1227 : #ifdef HAVE_DLOPEN
1228 : _hx509_ks_register(context, &keyset_pkcs11);
1229 : #endif
1230 792004 : }
|
