1 /*
2 * Copyright (C) Internet Systems Consortium, Inc. ("ISC")
3 *
4 * This Source Code Form is subject to the terms of the Mozilla Public
5 * License, v. 2.0. If a copy of the MPL was not distributed with this
6 * file, You can obtain one at http://mozilla.org/MPL/2.0/.
7 *
8 * See the COPYRIGHT file distributed with this work for additional
9 * information regarding copyright ownership.
10 */
11
12 /*! \file */
13
14 #if USE_PKCS11
15
16 #include <stdbool.h>
17
18 #include <isc/mem.h>
19 #include <isc/safe.h>
20 #include <isc/string.h>
21 #include <isc/util.h>
22
23 #include <pk11/constants.h>
24 #include <pk11/internal.h>
25 #include <pk11/pk11.h>
26 #include <pkcs11/pkcs11.h>
27
28 #include <dns/keyvalues.h>
29
30 #include <dst/result.h>
31
32 #include "dst_internal.h"
33 #include "dst_parse.h"
34 #include "dst_pkcs11.h"
35
36 /*
37 * FIPS 186-3 EDDSA keys:
38 * mechanisms:
39 * CKM_EDDSA,
40 * CKM_EC_EDWARDS_KEY_PAIR_GEN
41 * domain parameters:
42 * CKA_EC_PARAMS (choice with OID namedCurve)
43 * public keys:
44 * object class CKO_PUBLIC_KEY
45 * key type CKK_EC_EDWARDS
46 * attribute CKA_EC_PARAMS (choice with OID namedCurve)
47 * attribute CKA_EC_POINT (big int A)
48 * private keys:
49 * object class CKO_PRIVATE_KEY
50 * key type CKK_EC_EDWARDS
51 * attribute CKA_EC_PARAMS (choice with OID namedCurve)
52 * attribute CKA_VALUE (big int k)
53 * point format: 0x04 (octet-string) <size> <A>
54 */
55
56 #define TAG_OCTECT_STRING 0x04
57
58 #define DST_RET(a) \
59 { \
60 ret = a; \
61 goto err; \
62 }
63
64 static CK_BBOOL truevalue = TRUE;
65 static CK_BBOOL falsevalue = FALSE;
66
67 static void
68 pkcs11eddsa_destroy(dst_key_t *key);
69
70 static isc_result_t
pkcs11eddsa_createctx(dst_key_t * key,dst_context_t * dctx)71 pkcs11eddsa_createctx(dst_key_t *key, dst_context_t *dctx) {
72 isc_buffer_t *buf = NULL;
73
74 UNUSED(key);
75 REQUIRE(dctx->key->key_alg == DST_ALG_ED25519 ||
76 dctx->key->key_alg == DST_ALG_ED448);
77
78 isc_buffer_allocate(dctx->mctx, &buf, 16);
79 isc_buffer_setautorealloc(buf, true);
80 dctx->ctxdata.generic = buf;
81
82 return (ISC_R_SUCCESS);
83 }
84
85 static void
pkcs11eddsa_destroyctx(dst_context_t * dctx)86 pkcs11eddsa_destroyctx(dst_context_t *dctx) {
87 isc_buffer_t *buf = (isc_buffer_t *)dctx->ctxdata.generic;
88
89 REQUIRE(dctx->key->key_alg == DST_ALG_ED25519 ||
90 dctx->key->key_alg == DST_ALG_ED448);
91 if (buf != NULL) {
92 isc_buffer_free(&buf);
93 }
94 dctx->ctxdata.generic = NULL;
95 }
96
97 static isc_result_t
pkcs11eddsa_adddata(dst_context_t * dctx,const isc_region_t * data)98 pkcs11eddsa_adddata(dst_context_t *dctx, const isc_region_t *data) {
99 isc_buffer_t *buf = (isc_buffer_t *)dctx->ctxdata.generic;
100 isc_result_t result;
101
102 REQUIRE(dctx->key->key_alg == DST_ALG_ED25519 ||
103 dctx->key->key_alg == DST_ALG_ED448);
104
105 result = isc_buffer_copyregion(buf, data);
106 INSIST(result == ISC_R_SUCCESS);
107
108 return (result);
109 }
110
111 static isc_result_t
pkcs11eddsa_sign(dst_context_t * dctx,isc_buffer_t * sig)112 pkcs11eddsa_sign(dst_context_t *dctx, isc_buffer_t *sig) {
113 isc_buffer_t *buf = (isc_buffer_t *)dctx->ctxdata.generic;
114 CK_RV rv;
115 CK_MECHANISM mech = { CKM_EDDSA, NULL, 0 };
116 CK_OBJECT_HANDLE hKey = CK_INVALID_HANDLE;
117 CK_OBJECT_CLASS keyClass = CKO_PRIVATE_KEY;
118 CK_KEY_TYPE keyType = CKK_EC_EDWARDS;
119 CK_ATTRIBUTE keyTemplate[] = {
120 { CKA_CLASS, &keyClass, (CK_ULONG)sizeof(keyClass) },
121 { CKA_KEY_TYPE, &keyType, (CK_ULONG)sizeof(keyType) },
122 { CKA_TOKEN, &falsevalue, (CK_ULONG)sizeof(falsevalue) },
123 { CKA_PRIVATE, &falsevalue, (CK_ULONG)sizeof(falsevalue) },
124 { CKA_SIGN, &truevalue, (CK_ULONG)sizeof(truevalue) },
125 { CKA_EC_PARAMS, NULL, 0 },
126 { CKA_VALUE, NULL, 0 }
127 };
128 CK_ATTRIBUTE *attr;
129 CK_ULONG siglen;
130 CK_SLOT_ID slotid;
131 pk11_context_t *pk11_ctx;
132 dst_key_t *key = dctx->key;
133 pk11_object_t *ec = key->keydata.pkey;
134 isc_region_t t;
135 isc_region_t r;
136 isc_result_t ret = ISC_R_SUCCESS;
137 unsigned int i;
138
139 REQUIRE(key->key_alg == DST_ALG_ED25519 ||
140 key->key_alg == DST_ALG_ED448);
141 REQUIRE(ec != NULL);
142
143 switch (key->key_alg) {
144 case DST_ALG_ED25519:
145 siglen = DNS_SIG_ED25519SIZE;
146 break;
147 case DST_ALG_ED448:
148 siglen = DNS_SIG_ED448SIZE;
149 break;
150 default:
151 INSIST(0);
152 ISC_UNREACHABLE();
153 }
154
155 pk11_ctx = isc_mem_get(dctx->mctx, sizeof(*pk11_ctx));
156 memset(pk11_ctx, 0, sizeof(*pk11_ctx));
157 if (ec->ontoken && (dctx->use == DO_SIGN)) {
158 slotid = ec->slot;
159 } else {
160 slotid = pk11_get_best_token(OP_EDDSA);
161 }
162 ret = pk11_get_session(pk11_ctx, OP_EDDSA, true, false, ec->reqlogon,
163 NULL, slotid);
164 if (ret != ISC_R_SUCCESS) {
165 goto err;
166 }
167
168 isc_buffer_availableregion(sig, &r);
169 if (r.length < siglen) {
170 DST_RET(ISC_R_NOSPACE);
171 }
172
173 if (ec->ontoken && (ec->object != CK_INVALID_HANDLE)) {
174 pk11_ctx->ontoken = ec->ontoken;
175 pk11_ctx->object = ec->object;
176 goto token_key;
177 }
178
179 for (attr = pk11_attribute_first(ec); attr != NULL;
180 attr = pk11_attribute_next(ec, attr))
181 switch (attr->type) {
182 case CKA_EC_PARAMS:
183 INSIST(keyTemplate[5].type == attr->type);
184 keyTemplate[5].pValue = isc_mem_get(dctx->mctx,
185 attr->ulValueLen);
186 memmove(keyTemplate[5].pValue, attr->pValue,
187 attr->ulValueLen);
188 keyTemplate[5].ulValueLen = attr->ulValueLen;
189 break;
190 case CKA_VALUE:
191 INSIST(keyTemplate[6].type == attr->type);
192 keyTemplate[6].pValue = isc_mem_get(dctx->mctx,
193 attr->ulValueLen);
194 memmove(keyTemplate[6].pValue, attr->pValue,
195 attr->ulValueLen);
196 keyTemplate[6].ulValueLen = attr->ulValueLen;
197 break;
198 }
199 pk11_ctx->object = CK_INVALID_HANDLE;
200 pk11_ctx->ontoken = false;
201 PK11_RET(pkcs_C_CreateObject,
202 (pk11_ctx->session, keyTemplate, (CK_ULONG)7, &hKey),
203 ISC_R_FAILURE);
204
205 token_key:
206
207 PK11_RET(pkcs_C_SignInit,
208 (pk11_ctx->session, &mech,
209 pk11_ctx->ontoken ? pk11_ctx->object : hKey),
210 ISC_R_FAILURE);
211
212 isc_buffer_usedregion(buf, &t);
213
214 PK11_RET(pkcs_C_Sign,
215 (pk11_ctx->session, (CK_BYTE_PTR)t.base, (CK_ULONG)t.length,
216 (CK_BYTE_PTR)r.base, &siglen),
217 DST_R_SIGNFAILURE);
218
219 isc_buffer_add(sig, (unsigned int)siglen);
220
221 err:
222
223 if (hKey != CK_INVALID_HANDLE) {
224 (void)pkcs_C_DestroyObject(pk11_ctx->session, hKey);
225 }
226 for (i = 5; i <= 6; i++) {
227 if (keyTemplate[i].pValue != NULL) {
228 {
229 memset(keyTemplate[i].pValue, 0,
230 keyTemplate[i].ulValueLen);
231 isc_mem_put(dctx->mctx, keyTemplate[i].pValue,
232 keyTemplate[i].ulValueLen);
233 }
234 }
235 }
236 pk11_return_session(pk11_ctx);
237 memset(pk11_ctx, 0, sizeof(*pk11_ctx));
238 isc_mem_put(dctx->mctx, pk11_ctx, sizeof(*pk11_ctx));
239 isc_buffer_free(&buf);
240 dctx->ctxdata.generic = NULL;
241
242 return (ret);
243 }
244
245 static isc_result_t
pkcs11eddsa_verify(dst_context_t * dctx,const isc_region_t * sig)246 pkcs11eddsa_verify(dst_context_t *dctx, const isc_region_t *sig) {
247 isc_buffer_t *buf = (isc_buffer_t *)dctx->ctxdata.generic;
248 CK_RV rv;
249 CK_MECHANISM mech = { CKM_EDDSA, NULL, 0 };
250 CK_OBJECT_HANDLE hKey = CK_INVALID_HANDLE;
251 CK_OBJECT_CLASS keyClass = CKO_PUBLIC_KEY;
252 CK_KEY_TYPE keyType = CKK_EC_EDWARDS;
253 CK_ATTRIBUTE keyTemplate[] = {
254 { CKA_CLASS, &keyClass, (CK_ULONG)sizeof(keyClass) },
255 { CKA_KEY_TYPE, &keyType, (CK_ULONG)sizeof(keyType) },
256 { CKA_TOKEN, &falsevalue, (CK_ULONG)sizeof(falsevalue) },
257 { CKA_PRIVATE, &falsevalue, (CK_ULONG)sizeof(falsevalue) },
258 { CKA_VERIFY, &truevalue, (CK_ULONG)sizeof(truevalue) },
259 { CKA_EC_PARAMS, NULL, 0 },
260 { CKA_EC_POINT, NULL, 0 }
261 };
262 CK_ATTRIBUTE *attr;
263 CK_SLOT_ID slotid;
264 pk11_context_t *pk11_ctx;
265 dst_key_t *key = dctx->key;
266 pk11_object_t *ec = key->keydata.pkey;
267 isc_region_t t;
268 isc_result_t ret = ISC_R_SUCCESS;
269 unsigned int i;
270
271 REQUIRE(key->key_alg == DST_ALG_ED25519 ||
272 key->key_alg == DST_ALG_ED448);
273 REQUIRE(ec != NULL);
274
275 pk11_ctx = isc_mem_get(dctx->mctx, sizeof(*pk11_ctx));
276 memset(pk11_ctx, 0, sizeof(*pk11_ctx));
277 if (ec->ontoken && (dctx->use == DO_SIGN)) {
278 slotid = ec->slot;
279 } else {
280 slotid = pk11_get_best_token(OP_EDDSA);
281 }
282 ret = pk11_get_session(pk11_ctx, OP_EDDSA, true, false, ec->reqlogon,
283 NULL, slotid);
284 if (ret != ISC_R_SUCCESS) {
285 goto err;
286 }
287
288 for (attr = pk11_attribute_first(ec); attr != NULL;
289 attr = pk11_attribute_next(ec, attr))
290 switch (attr->type) {
291 case CKA_EC_PARAMS:
292 INSIST(keyTemplate[5].type == attr->type);
293 keyTemplate[5].pValue = isc_mem_get(dctx->mctx,
294 attr->ulValueLen);
295 memmove(keyTemplate[5].pValue, attr->pValue,
296 attr->ulValueLen);
297 keyTemplate[5].ulValueLen = attr->ulValueLen;
298 break;
299 case CKA_EC_POINT:
300 INSIST(keyTemplate[6].type == attr->type);
301 keyTemplate[6].pValue = isc_mem_get(dctx->mctx,
302 attr->ulValueLen);
303 memmove(keyTemplate[6].pValue, attr->pValue,
304 attr->ulValueLen);
305 keyTemplate[6].ulValueLen = attr->ulValueLen;
306 break;
307 }
308 pk11_ctx->object = CK_INVALID_HANDLE;
309 pk11_ctx->ontoken = false;
310 PK11_RET(pkcs_C_CreateObject,
311 (pk11_ctx->session, keyTemplate, (CK_ULONG)7, &hKey),
312 ISC_R_FAILURE);
313
314 PK11_RET(pkcs_C_VerifyInit, (pk11_ctx->session, &mech, hKey),
315 ISC_R_FAILURE);
316
317 isc_buffer_usedregion(buf, &t);
318
319 PK11_RET(pkcs_C_Verify,
320 (pk11_ctx->session, (CK_BYTE_PTR)t.base, (CK_ULONG)t.length,
321 (CK_BYTE_PTR)sig->base, (CK_ULONG)sig->length),
322 DST_R_VERIFYFAILURE);
323
324 err:
325
326 if (hKey != CK_INVALID_HANDLE) {
327 (void)pkcs_C_DestroyObject(pk11_ctx->session, hKey);
328 }
329 for (i = 5; i <= 6; i++) {
330 if (keyTemplate[i].pValue != NULL) {
331 {
332 memset(keyTemplate[i].pValue, 0,
333 keyTemplate[i].ulValueLen);
334 isc_mem_put(dctx->mctx, keyTemplate[i].pValue,
335 keyTemplate[i].ulValueLen);
336 }
337 }
338 }
339 pk11_return_session(pk11_ctx);
340 memset(pk11_ctx, 0, sizeof(*pk11_ctx));
341 isc_mem_put(dctx->mctx, pk11_ctx, sizeof(*pk11_ctx));
342 isc_buffer_free(&buf);
343 dctx->ctxdata.generic = NULL;
344
345 return (ret);
346 }
347
348 static bool
pkcs11eddsa_compare(const dst_key_t * key1,const dst_key_t * key2)349 pkcs11eddsa_compare(const dst_key_t *key1, const dst_key_t *key2) {
350 pk11_object_t *ec1, *ec2;
351 CK_ATTRIBUTE *attr1, *attr2;
352
353 ec1 = key1->keydata.pkey;
354 ec2 = key2->keydata.pkey;
355
356 if ((ec1 == NULL) && (ec2 == NULL)) {
357 return (true);
358 } else if ((ec1 == NULL) || (ec2 == NULL)) {
359 return (false);
360 }
361
362 attr1 = pk11_attribute_bytype(ec1, CKA_EC_PARAMS);
363 attr2 = pk11_attribute_bytype(ec2, CKA_EC_PARAMS);
364 if ((attr1 == NULL) && (attr2 == NULL)) {
365 return (true);
366 } else if ((attr1 == NULL) || (attr2 == NULL) ||
367 (attr1->ulValueLen != attr2->ulValueLen) ||
368 !isc_safe_memequal(attr1->pValue, attr2->pValue,
369 attr1->ulValueLen))
370 {
371 return (false);
372 }
373
374 attr1 = pk11_attribute_bytype(ec1, CKA_EC_POINT);
375 attr2 = pk11_attribute_bytype(ec2, CKA_EC_POINT);
376 if ((attr1 == NULL) && (attr2 == NULL)) {
377 return (true);
378 } else if ((attr1 == NULL) || (attr2 == NULL) ||
379 (attr1->ulValueLen != attr2->ulValueLen) ||
380 !isc_safe_memequal(attr1->pValue, attr2->pValue,
381 attr1->ulValueLen))
382 {
383 return (false);
384 }
385
386 attr1 = pk11_attribute_bytype(ec1, CKA_VALUE);
387 attr2 = pk11_attribute_bytype(ec2, CKA_VALUE);
388 if (((attr1 != NULL) || (attr2 != NULL)) &&
389 ((attr1 == NULL) || (attr2 == NULL) ||
390 (attr1->ulValueLen != attr2->ulValueLen) ||
391 !isc_safe_memequal(attr1->pValue, attr2->pValue,
392 attr1->ulValueLen)))
393 {
394 return (false);
395 }
396
397 if (!ec1->ontoken && !ec2->ontoken) {
398 return (true);
399 } else if (ec1->ontoken || ec2->ontoken || (ec1->object != ec2->object))
400 {
401 return (false);
402 }
403
404 return (true);
405 }
406
407 #define SETCURVE() \
408 switch (key->key_alg) { \
409 case DST_ALG_ED25519: \
410 attr->pValue = isc_mem_get(key->mctx, \
411 sizeof(PK11_ECX_ED25519)); \
412 memmove(attr->pValue, PK11_ECX_ED25519, \
413 sizeof(PK11_ECX_ED25519)); \
414 attr->ulValueLen = sizeof(PK11_ECX_ED25519); \
415 break; \
416 case DST_ALG_ED448: \
417 attr->pValue = isc_mem_get(key->mctx, sizeof(PK11_ECX_ED448)); \
418 memmove(attr->pValue, PK11_ECX_ED448, sizeof(PK11_ECX_ED448)); \
419 attr->ulValueLen = sizeof(PK11_ECX_ED448); \
420 break; \
421 default: \
422 INSIST(0); \
423 ISC_UNREACHABLE(); \
424 }
425
426 #define FREECURVE() \
427 if (attr->pValue != NULL) { \
428 memset(attr->pValue, 0, attr->ulValueLen); \
429 isc_mem_put(key->mctx, attr->pValue, attr->ulValueLen); \
430 attr->pValue = NULL; \
431 }
432
433 static isc_result_t
pkcs11eddsa_generate(dst_key_t * key,int unused,void (* callback)(int))434 pkcs11eddsa_generate(dst_key_t *key, int unused, void (*callback)(int)) {
435 CK_RV rv;
436 CK_MECHANISM mech = { CKM_EC_EDWARDS_KEY_PAIR_GEN, NULL, 0 };
437 CK_OBJECT_HANDLE pub = CK_INVALID_HANDLE;
438 CK_OBJECT_CLASS pubClass = CKO_PUBLIC_KEY;
439 CK_KEY_TYPE keyType = CKK_EC_EDWARDS;
440 CK_ATTRIBUTE pubTemplate[] = {
441 { CKA_CLASS, &pubClass, (CK_ULONG)sizeof(pubClass) },
442 { CKA_KEY_TYPE, &keyType, (CK_ULONG)sizeof(keyType) },
443 { CKA_TOKEN, &falsevalue, (CK_ULONG)sizeof(falsevalue) },
444 { CKA_PRIVATE, &falsevalue, (CK_ULONG)sizeof(falsevalue) },
445 { CKA_VERIFY, &truevalue, (CK_ULONG)sizeof(truevalue) },
446 { CKA_EC_PARAMS, NULL, 0 }
447 };
448 CK_OBJECT_HANDLE priv = CK_INVALID_HANDLE;
449 CK_OBJECT_HANDLE privClass = CKO_PRIVATE_KEY;
450 CK_ATTRIBUTE privTemplate[] = {
451 { CKA_CLASS, &privClass, (CK_ULONG)sizeof(privClass) },
452 { CKA_KEY_TYPE, &keyType, (CK_ULONG)sizeof(keyType) },
453 { CKA_TOKEN, &falsevalue, (CK_ULONG)sizeof(falsevalue) },
454 { CKA_PRIVATE, &falsevalue, (CK_ULONG)sizeof(falsevalue) },
455 { CKA_SENSITIVE, &falsevalue, (CK_ULONG)sizeof(falsevalue) },
456 { CKA_EXTRACTABLE, &truevalue, (CK_ULONG)sizeof(truevalue) },
457 { CKA_SIGN, &truevalue, (CK_ULONG)sizeof(truevalue) }
458 };
459 CK_ATTRIBUTE *attr;
460 pk11_object_t *ec;
461 pk11_context_t *pk11_ctx;
462 isc_result_t ret;
463
464 REQUIRE(key->key_alg == DST_ALG_ED25519 ||
465 key->key_alg == DST_ALG_ED448);
466 UNUSED(unused);
467 UNUSED(callback);
468
469 pk11_ctx = isc_mem_get(key->mctx, sizeof(*pk11_ctx));
470 ret = pk11_get_session(pk11_ctx, OP_EDDSA, true, false, false, NULL,
471 pk11_get_best_token(OP_EDDSA));
472 if (ret != ISC_R_SUCCESS) {
473 goto err;
474 }
475
476 ec = isc_mem_get(key->mctx, sizeof(*ec));
477 memset(ec, 0, sizeof(*ec));
478 key->keydata.pkey = ec;
479 ec->repr = isc_mem_get(key->mctx, sizeof(*attr) * 3);
480 memset(ec->repr, 0, sizeof(*attr) * 3);
481 ec->attrcnt = 3;
482
483 attr = ec->repr;
484 attr[0].type = CKA_EC_PARAMS;
485 attr[1].type = CKA_EC_POINT;
486 attr[2].type = CKA_VALUE;
487
488 attr = &pubTemplate[5];
489 SETCURVE();
490
491 PK11_RET(pkcs_C_GenerateKeyPair,
492 (pk11_ctx->session, &mech, pubTemplate, (CK_ULONG)6,
493 privTemplate, (CK_ULONG)7, &pub, &priv),
494 DST_R_CRYPTOFAILURE);
495
496 attr = &pubTemplate[5];
497 FREECURVE();
498
499 attr = ec->repr;
500 SETCURVE();
501
502 attr++;
503 PK11_RET(pkcs_C_GetAttributeValue, (pk11_ctx->session, pub, attr, 1),
504 DST_R_CRYPTOFAILURE);
505 attr->pValue = isc_mem_get(key->mctx, attr->ulValueLen);
506 memset(attr->pValue, 0, attr->ulValueLen);
507 PK11_RET(pkcs_C_GetAttributeValue, (pk11_ctx->session, pub, attr, 1),
508 DST_R_CRYPTOFAILURE);
509
510 attr++;
511 PK11_RET(pkcs_C_GetAttributeValue, (pk11_ctx->session, priv, attr, 1),
512 DST_R_CRYPTOFAILURE);
513 attr->pValue = isc_mem_get(key->mctx, attr->ulValueLen);
514 memset(attr->pValue, 0, attr->ulValueLen);
515 PK11_RET(pkcs_C_GetAttributeValue, (pk11_ctx->session, priv, attr, 1),
516 DST_R_CRYPTOFAILURE);
517
518 (void)pkcs_C_DestroyObject(pk11_ctx->session, priv);
519 (void)pkcs_C_DestroyObject(pk11_ctx->session, pub);
520 pk11_return_session(pk11_ctx);
521 memset(pk11_ctx, 0, sizeof(*pk11_ctx));
522 isc_mem_put(key->mctx, pk11_ctx, sizeof(*pk11_ctx));
523
524 switch (key->key_alg) {
525 case DST_ALG_ED25519:
526 key->key_size = DNS_KEY_ED25519SIZE * 8;
527 break;
528 case DST_ALG_ED448:
529 key->key_size = DNS_KEY_ED448SIZE * 8;
530 break;
531 default:
532 INSIST(0);
533 ISC_UNREACHABLE();
534 }
535
536 return (ISC_R_SUCCESS);
537
538 err:
539 pkcs11eddsa_destroy(key);
540 if (priv != CK_INVALID_HANDLE) {
541 (void)pkcs_C_DestroyObject(pk11_ctx->session, priv);
542 }
543 if (pub != CK_INVALID_HANDLE) {
544 (void)pkcs_C_DestroyObject(pk11_ctx->session, pub);
545 }
546 pk11_return_session(pk11_ctx);
547 memset(pk11_ctx, 0, sizeof(*pk11_ctx));
548 isc_mem_put(key->mctx, pk11_ctx, sizeof(*pk11_ctx));
549
550 return (ret);
551 }
552
553 static bool
pkcs11eddsa_isprivate(const dst_key_t * key)554 pkcs11eddsa_isprivate(const dst_key_t *key) {
555 pk11_object_t *ec = key->keydata.pkey;
556 CK_ATTRIBUTE *attr;
557
558 if (ec == NULL) {
559 return (false);
560 }
561 attr = pk11_attribute_bytype(ec, CKA_VALUE);
562 return (attr != NULL || ec->ontoken);
563 }
564
565 static void
pkcs11eddsa_destroy(dst_key_t * key)566 pkcs11eddsa_destroy(dst_key_t *key) {
567 pk11_object_t *ec = key->keydata.pkey;
568 CK_ATTRIBUTE *attr;
569
570 if (ec == NULL) {
571 return;
572 }
573
574 INSIST((ec->object == CK_INVALID_HANDLE) || ec->ontoken);
575
576 for (attr = pk11_attribute_first(ec); attr != NULL;
577 attr = pk11_attribute_next(ec, attr))
578 switch (attr->type) {
579 case CKA_LABEL:
580 case CKA_ID:
581 case CKA_EC_PARAMS:
582 case CKA_EC_POINT:
583 case CKA_VALUE:
584 FREECURVE();
585 break;
586 }
587 if (ec->repr != NULL) {
588 memset(ec->repr, 0, ec->attrcnt * sizeof(*attr));
589 isc_mem_put(key->mctx, ec->repr, ec->attrcnt * sizeof(*attr));
590 }
591 memset(ec, 0, sizeof(*ec));
592 isc_mem_put(key->mctx, ec, sizeof(*ec));
593 key->keydata.pkey = NULL;
594 }
595
596 static isc_result_t
pkcs11eddsa_todns(const dst_key_t * key,isc_buffer_t * data)597 pkcs11eddsa_todns(const dst_key_t *key, isc_buffer_t *data) {
598 pk11_object_t *ec;
599 isc_region_t r;
600 unsigned int len;
601 CK_ATTRIBUTE *attr;
602
603 REQUIRE(key->keydata.pkey != NULL);
604
605 switch (key->key_alg) {
606 case DST_ALG_ED25519:
607 len = DNS_KEY_ED25519SIZE;
608 break;
609 case DST_ALG_ED448:
610 len = DNS_KEY_ED448SIZE;
611 break;
612 default:
613 INSIST(0);
614 ISC_UNREACHABLE();
615 }
616
617 ec = key->keydata.pkey;
618 attr = pk11_attribute_bytype(ec, CKA_EC_POINT);
619 if ((attr == NULL) || (attr->ulValueLen != len + 2) ||
620 (((CK_BYTE_PTR)attr->pValue)[0] != TAG_OCTECT_STRING) ||
621 (((CK_BYTE_PTR)attr->pValue)[1] != len))
622 {
623 return (ISC_R_FAILURE);
624 }
625
626 isc_buffer_availableregion(data, &r);
627 if (r.length < len) {
628 return (ISC_R_NOSPACE);
629 }
630 memmove(r.base, (CK_BYTE_PTR)attr->pValue + 2, len);
631 isc_buffer_add(data, len);
632
633 return (ISC_R_SUCCESS);
634 }
635
636 static isc_result_t
pkcs11eddsa_fromdns(dst_key_t * key,isc_buffer_t * data)637 pkcs11eddsa_fromdns(dst_key_t *key, isc_buffer_t *data) {
638 pk11_object_t *ec;
639 isc_region_t r;
640 unsigned int len;
641 CK_ATTRIBUTE *attr;
642
643 REQUIRE(key->key_alg == DST_ALG_ED25519 ||
644 key->key_alg == DST_ALG_ED448);
645
646 switch (key->key_alg) {
647 case DST_ALG_ED25519:
648 len = DNS_KEY_ED25519SIZE;
649 break;
650 case DST_ALG_ED448:
651 len = DNS_KEY_ED448SIZE;
652 break;
653 default:
654 INSIST(0);
655 ISC_UNREACHABLE();
656 }
657
658 isc_buffer_remainingregion(data, &r);
659 if (r.length == 0) {
660 return (ISC_R_SUCCESS);
661 }
662 if (r.length != len) {
663 return (DST_R_INVALIDPUBLICKEY);
664 }
665
666 ec = isc_mem_get(key->mctx, sizeof(*ec));
667 memset(ec, 0, sizeof(*ec));
668 ec->repr = isc_mem_get(key->mctx, sizeof(*attr) * 2);
669 ec->attrcnt = 2;
670
671 attr = ec->repr;
672 attr->type = CKA_EC_PARAMS;
673 SETCURVE();
674
675 attr++;
676 attr->type = CKA_EC_POINT;
677 attr->pValue = isc_mem_get(key->mctx, len + 2);
678 ((CK_BYTE_PTR)attr->pValue)[0] = TAG_OCTECT_STRING;
679 ((CK_BYTE_PTR)attr->pValue)[1] = len;
680 memmove((CK_BYTE_PTR)attr->pValue + 2, r.base, len);
681 attr->ulValueLen = len + 2;
682
683 isc_buffer_forward(data, len);
684 key->keydata.pkey = ec;
685 key->key_size = len * 8;
686
687 return (ISC_R_SUCCESS);
688 }
689
690 static isc_result_t
pkcs11eddsa_tofile(const dst_key_t * key,const char * directory)691 pkcs11eddsa_tofile(const dst_key_t *key, const char *directory) {
692 isc_result_t ret;
693 pk11_object_t *ec;
694 dst_private_t priv;
695 unsigned char *buf = NULL;
696 unsigned int i = 0;
697 CK_ATTRIBUTE *attr;
698
699 if (key->keydata.pkey == NULL) {
700 return (DST_R_NULLKEY);
701 }
702
703 if (key->external) {
704 priv.nelements = 0;
705 return (dst__privstruct_writefile(key, &priv, directory));
706 }
707
708 ec = key->keydata.pkey;
709 attr = pk11_attribute_bytype(ec, CKA_VALUE);
710 if (attr != NULL) {
711 buf = isc_mem_get(key->mctx, attr->ulValueLen);
712 priv.elements[i].tag = TAG_EDDSA_PRIVATEKEY;
713 priv.elements[i].length = (unsigned short)attr->ulValueLen;
714 memmove(buf, attr->pValue, attr->ulValueLen);
715 priv.elements[i].data = buf;
716 i++;
717 }
718
719 if (key->engine != NULL) {
720 priv.elements[i].tag = TAG_EDDSA_ENGINE;
721 priv.elements[i].length = strlen(key->engine) + 1;
722 priv.elements[i].data = (unsigned char *)key->engine;
723 i++;
724 }
725
726 if (key->label != NULL) {
727 priv.elements[i].tag = TAG_EDDSA_LABEL;
728 priv.elements[i].length = strlen(key->label) + 1;
729 priv.elements[i].data = (unsigned char *)key->label;
730 i++;
731 }
732
733 priv.nelements = i;
734 ret = dst__privstruct_writefile(key, &priv, directory);
735
736 if (buf != NULL) {
737 memset(buf, 0, attr->ulValueLen);
738 isc_mem_put(key->mctx, buf, attr->ulValueLen);
739 }
740 return (ret);
741 }
742
743 static isc_result_t
pkcs11eddsa_fetch(dst_key_t * key,const char * engine,const char * label,dst_key_t * pub)744 pkcs11eddsa_fetch(dst_key_t *key, const char *engine, const char *label,
745 dst_key_t *pub) {
746 CK_RV rv;
747 CK_OBJECT_CLASS keyClass = CKO_PRIVATE_KEY;
748 CK_KEY_TYPE keyType = CKK_EC_EDWARDS;
749 CK_ATTRIBUTE searchTemplate[] = {
750 { CKA_CLASS, &keyClass, (CK_ULONG)sizeof(keyClass) },
751 { CKA_KEY_TYPE, &keyType, (CK_ULONG)sizeof(keyType) },
752 { CKA_TOKEN, &truevalue, (CK_ULONG)sizeof(truevalue) },
753 { CKA_LABEL, NULL, 0 }
754 };
755 CK_ULONG cnt;
756 CK_ATTRIBUTE *attr;
757 CK_ATTRIBUTE *pubattr;
758 pk11_object_t *ec;
759 pk11_object_t *pubec;
760 pk11_context_t *pk11_ctx = NULL;
761 isc_result_t ret;
762
763 if (label == NULL) {
764 return (DST_R_NOENGINE);
765 }
766
767 ec = key->keydata.pkey;
768 pubec = pub->keydata.pkey;
769
770 ec->object = CK_INVALID_HANDLE;
771 ec->ontoken = true;
772 ec->reqlogon = true;
773 ec->repr = isc_mem_get(key->mctx, sizeof(*attr) * 2);
774 memset(ec->repr, 0, sizeof(*attr) * 2);
775 ec->attrcnt = 2;
776 attr = ec->repr;
777
778 attr->type = CKA_EC_PARAMS;
779 pubattr = pk11_attribute_bytype(pubec, CKA_EC_PARAMS);
780 INSIST(pubattr != NULL);
781 attr->pValue = isc_mem_get(key->mctx, pubattr->ulValueLen);
782 memmove(attr->pValue, pubattr->pValue, pubattr->ulValueLen);
783 attr->ulValueLen = pubattr->ulValueLen;
784 attr++;
785
786 attr->type = CKA_EC_POINT;
787 pubattr = pk11_attribute_bytype(pubec, CKA_EC_POINT);
788 INSIST(pubattr != NULL);
789 attr->pValue = isc_mem_get(key->mctx, pubattr->ulValueLen);
790 memmove(attr->pValue, pubattr->pValue, pubattr->ulValueLen);
791 attr->ulValueLen = pubattr->ulValueLen;
792
793 ret = pk11_parse_uri(ec, label, key->mctx, OP_EDDSA);
794 if (ret != ISC_R_SUCCESS) {
795 goto err;
796 }
797
798 pk11_ctx = isc_mem_get(key->mctx, sizeof(*pk11_ctx));
799 ret = pk11_get_session(pk11_ctx, OP_EDDSA, true, false, ec->reqlogon,
800 NULL, ec->slot);
801 if (ret != ISC_R_SUCCESS) {
802 goto err;
803 }
804
805 attr = pk11_attribute_bytype(ec, CKA_LABEL);
806 if (attr == NULL) {
807 attr = pk11_attribute_bytype(ec, CKA_ID);
808 INSIST(attr != NULL);
809 searchTemplate[3].type = CKA_ID;
810 }
811 searchTemplate[3].pValue = attr->pValue;
812 searchTemplate[3].ulValueLen = attr->ulValueLen;
813
814 PK11_RET(pkcs_C_FindObjectsInit,
815 (pk11_ctx->session, searchTemplate, (CK_ULONG)4),
816 DST_R_CRYPTOFAILURE);
817 PK11_RET(pkcs_C_FindObjects,
818 (pk11_ctx->session, &ec->object, (CK_ULONG)1, &cnt),
819 DST_R_CRYPTOFAILURE);
820 (void)pkcs_C_FindObjectsFinal(pk11_ctx->session);
821 if (cnt == 0) {
822 DST_RET(ISC_R_NOTFOUND);
823 }
824 if (cnt > 1) {
825 DST_RET(ISC_R_EXISTS);
826 }
827
828 if (engine != NULL) {
829 key->engine = isc_mem_strdup(key->mctx, engine);
830 }
831
832 key->label = isc_mem_strdup(key->mctx, label);
833
834 pk11_return_session(pk11_ctx);
835 memset(pk11_ctx, 0, sizeof(*pk11_ctx));
836 isc_mem_put(key->mctx, pk11_ctx, sizeof(*pk11_ctx));
837 return (ISC_R_SUCCESS);
838
839 err:
840 if (pk11_ctx != NULL) {
841 pk11_return_session(pk11_ctx);
842 memset(pk11_ctx, 0, sizeof(*pk11_ctx));
843 isc_mem_put(key->mctx, pk11_ctx, sizeof(*pk11_ctx));
844 }
845 return (ret);
846 }
847
848 static isc_result_t
pkcs11eddsa_parse(dst_key_t * key,isc_lex_t * lexer,dst_key_t * pub)849 pkcs11eddsa_parse(dst_key_t *key, isc_lex_t *lexer, dst_key_t *pub) {
850 dst_private_t priv;
851 isc_result_t ret;
852 pk11_object_t *ec = NULL;
853 CK_ATTRIBUTE *attr, *pattr;
854 isc_mem_t *mctx = key->mctx;
855 unsigned int i;
856 const char *engine = NULL, *label = NULL;
857
858 REQUIRE(key->key_alg == DST_ALG_ED25519 ||
859 key->key_alg == DST_ALG_ED448);
860
861 if ((pub == NULL) || (pub->keydata.pkey == NULL)) {
862 DST_RET(DST_R_INVALIDPRIVATEKEY);
863 }
864
865 /* read private key file */
866 ret = dst__privstruct_parse(key, DST_ALG_ED25519, lexer, mctx, &priv);
867 if (ret != ISC_R_SUCCESS) {
868 return (ret);
869 }
870
871 if (key->external) {
872 if (priv.nelements != 0) {
873 DST_RET(DST_R_INVALIDPRIVATEKEY);
874 }
875
876 key->keydata.pkey = pub->keydata.pkey;
877 pub->keydata.pkey = NULL;
878 key->key_size = pub->key_size;
879
880 dst__privstruct_free(&priv, mctx);
881 memset(&priv, 0, sizeof(priv));
882
883 return (ISC_R_SUCCESS);
884 }
885
886 for (i = 0; i < priv.nelements; i++) {
887 switch (priv.elements[i].tag) {
888 case TAG_EDDSA_ENGINE:
889 engine = (char *)priv.elements[i].data;
890 break;
891 case TAG_EDDSA_LABEL:
892 label = (char *)priv.elements[i].data;
893 break;
894 default:
895 break;
896 }
897 }
898 ec = isc_mem_get(key->mctx, sizeof(*ec));
899 memset(ec, 0, sizeof(*ec));
900 key->keydata.pkey = ec;
901
902 /* Is this key is stored in a HSM? See if we can fetch it. */
903 if ((label != NULL) || (engine != NULL)) {
904 ret = pkcs11eddsa_fetch(key, engine, label, pub);
905 if (ret != ISC_R_SUCCESS) {
906 goto err;
907 }
908 dst__privstruct_free(&priv, mctx);
909 memset(&priv, 0, sizeof(priv));
910 return (ret);
911 }
912
913 ec->repr = isc_mem_get(key->mctx, sizeof(*attr) * 3);
914 memset(ec->repr, 0, sizeof(*attr) * 3);
915 ec->attrcnt = 3;
916
917 attr = ec->repr;
918 attr->type = CKA_EC_PARAMS;
919 pattr = pk11_attribute_bytype(pub->keydata.pkey, CKA_EC_PARAMS);
920 INSIST(pattr != NULL);
921 attr->pValue = isc_mem_get(key->mctx, pattr->ulValueLen);
922 memmove(attr->pValue, pattr->pValue, pattr->ulValueLen);
923 attr->ulValueLen = pattr->ulValueLen;
924
925 attr++;
926 attr->type = CKA_EC_POINT;
927 pattr = pk11_attribute_bytype(pub->keydata.pkey, CKA_EC_POINT);
928 INSIST(pattr != NULL);
929 attr->pValue = isc_mem_get(key->mctx, pattr->ulValueLen);
930 memmove(attr->pValue, pattr->pValue, pattr->ulValueLen);
931 attr->ulValueLen = pattr->ulValueLen;
932
933 attr++;
934 attr->type = CKA_VALUE;
935 attr->pValue = isc_mem_get(key->mctx, priv.elements[0].length);
936 memmove(attr->pValue, priv.elements[0].data, priv.elements[0].length);
937 attr->ulValueLen = priv.elements[0].length;
938
939 dst__privstruct_free(&priv, mctx);
940 memset(&priv, 0, sizeof(priv));
941 switch (key->key_alg) {
942 case DST_ALG_ED25519:
943 key->key_size = DNS_KEY_ED25519SIZE * 8;
944 break;
945 case DST_ALG_ED448:
946 key->key_size = DNS_KEY_ED448SIZE * 8;
947 break;
948 default:
949 INSIST(0);
950 ISC_UNREACHABLE();
951 }
952
953 return (ISC_R_SUCCESS);
954
955 err:
956 pkcs11eddsa_destroy(key);
957 dst__privstruct_free(&priv, mctx);
958 memset(&priv, 0, sizeof(priv));
959 return (ret);
960 }
961
962 static isc_result_t
pkcs11eddsa_fromlabel(dst_key_t * key,const char * engine,const char * label,const char * pin)963 pkcs11eddsa_fromlabel(dst_key_t *key, const char *engine, const char *label,
964 const char *pin) {
965 CK_RV rv;
966 CK_OBJECT_HANDLE hKey = CK_INVALID_HANDLE;
967 CK_OBJECT_CLASS keyClass = CKO_PUBLIC_KEY;
968 CK_KEY_TYPE keyType = CKK_EC_EDWARDS;
969 CK_ATTRIBUTE searchTemplate[] = {
970 { CKA_CLASS, &keyClass, (CK_ULONG)sizeof(keyClass) },
971 { CKA_KEY_TYPE, &keyType, (CK_ULONG)sizeof(keyType) },
972 { CKA_TOKEN, &truevalue, (CK_ULONG)sizeof(truevalue) },
973 { CKA_LABEL, NULL, 0 }
974 };
975 CK_ULONG cnt;
976 CK_ATTRIBUTE *attr;
977 pk11_object_t *ec;
978 pk11_context_t *pk11_ctx = NULL;
979 isc_result_t ret;
980 unsigned int i;
981
982 UNUSED(pin);
983
984 ec = isc_mem_get(key->mctx, sizeof(*ec));
985 memset(ec, 0, sizeof(*ec));
986 ec->object = CK_INVALID_HANDLE;
987 ec->ontoken = true;
988 ec->reqlogon = true;
989 key->keydata.pkey = ec;
990
991 ec->repr = isc_mem_get(key->mctx, sizeof(*attr) * 2);
992 memset(ec->repr, 0, sizeof(*attr) * 2);
993 ec->attrcnt = 2;
994 attr = ec->repr;
995 attr[0].type = CKA_EC_PARAMS;
996 attr[1].type = CKA_EC_POINT;
997
998 ret = pk11_parse_uri(ec, label, key->mctx, OP_EDDSA);
999 if (ret != ISC_R_SUCCESS) {
1000 goto err;
1001 }
1002
1003 pk11_ctx = isc_mem_get(key->mctx, sizeof(*pk11_ctx));
1004 ret = pk11_get_session(pk11_ctx, OP_EDDSA, true, false, ec->reqlogon,
1005 NULL, ec->slot);
1006 if (ret != ISC_R_SUCCESS) {
1007 goto err;
1008 }
1009
1010 attr = pk11_attribute_bytype(ec, CKA_LABEL);
1011 if (attr == NULL) {
1012 attr = pk11_attribute_bytype(ec, CKA_ID);
1013 INSIST(attr != NULL);
1014 searchTemplate[3].type = CKA_ID;
1015 }
1016 searchTemplate[3].pValue = attr->pValue;
1017 searchTemplate[3].ulValueLen = attr->ulValueLen;
1018
1019 PK11_RET(pkcs_C_FindObjectsInit,
1020 (pk11_ctx->session, searchTemplate, (CK_ULONG)4),
1021 DST_R_CRYPTOFAILURE);
1022 PK11_RET(pkcs_C_FindObjects,
1023 (pk11_ctx->session, &hKey, (CK_ULONG)1, &cnt),
1024 DST_R_CRYPTOFAILURE);
1025 (void)pkcs_C_FindObjectsFinal(pk11_ctx->session);
1026 if (cnt == 0) {
1027 DST_RET(ISC_R_NOTFOUND);
1028 }
1029 if (cnt > 1) {
1030 DST_RET(ISC_R_EXISTS);
1031 }
1032
1033 attr = ec->repr;
1034 PK11_RET(pkcs_C_GetAttributeValue, (pk11_ctx->session, hKey, attr, 2),
1035 DST_R_CRYPTOFAILURE);
1036 for (i = 0; i <= 1; i++) {
1037 attr[i].pValue = isc_mem_get(key->mctx, attr[i].ulValueLen);
1038 memset(attr[i].pValue, 0, attr[i].ulValueLen);
1039 }
1040 PK11_RET(pkcs_C_GetAttributeValue, (pk11_ctx->session, hKey, attr, 2),
1041 DST_R_CRYPTOFAILURE);
1042
1043 keyClass = CKO_PRIVATE_KEY;
1044 PK11_RET(pkcs_C_FindObjectsInit,
1045 (pk11_ctx->session, searchTemplate, (CK_ULONG)4),
1046 DST_R_CRYPTOFAILURE);
1047 PK11_RET(pkcs_C_FindObjects,
1048 (pk11_ctx->session, &ec->object, (CK_ULONG)1, &cnt),
1049 DST_R_CRYPTOFAILURE);
1050 (void)pkcs_C_FindObjectsFinal(pk11_ctx->session);
1051 if (cnt == 0) {
1052 DST_RET(ISC_R_NOTFOUND);
1053 }
1054 if (cnt > 1) {
1055 DST_RET(ISC_R_EXISTS);
1056 }
1057
1058 if (engine != NULL) {
1059 key->engine = isc_mem_strdup(key->mctx, engine);
1060 }
1061
1062 key->label = isc_mem_strdup(key->mctx, label);
1063 switch (key->key_alg) {
1064 case DST_ALG_ED25519:
1065 key->key_size = DNS_KEY_ED25519SIZE * 8;
1066 break;
1067 case DST_ALG_ED448:
1068 key->key_size = DNS_KEY_ED448SIZE * 8;
1069 break;
1070 default:
1071 INSIST(0);
1072 ISC_UNREACHABLE();
1073 }
1074
1075 pk11_return_session(pk11_ctx);
1076 memset(pk11_ctx, 0, sizeof(*pk11_ctx));
1077 isc_mem_put(key->mctx, pk11_ctx, sizeof(*pk11_ctx));
1078 return (ISC_R_SUCCESS);
1079
1080 err:
1081 pkcs11eddsa_destroy(key);
1082 if (pk11_ctx != NULL) {
1083 pk11_return_session(pk11_ctx);
1084 memset(pk11_ctx, 0, sizeof(*pk11_ctx));
1085 isc_mem_put(key->mctx, pk11_ctx, sizeof(*pk11_ctx));
1086 }
1087 return (ret);
1088 }
1089
1090 static dst_func_t pkcs11eddsa_functions = {
1091 pkcs11eddsa_createctx,
1092 NULL, /*%< createctx2 */
1093 pkcs11eddsa_destroyctx,
1094 pkcs11eddsa_adddata,
1095 pkcs11eddsa_sign,
1096 pkcs11eddsa_verify,
1097 NULL, /*%< verify2 */
1098 NULL, /*%< computesecret */
1099 pkcs11eddsa_compare,
1100 NULL, /*%< paramcompare */
1101 pkcs11eddsa_generate,
1102 pkcs11eddsa_isprivate,
1103 pkcs11eddsa_destroy,
1104 pkcs11eddsa_todns,
1105 pkcs11eddsa_fromdns,
1106 pkcs11eddsa_tofile,
1107 pkcs11eddsa_parse,
1108 NULL, /*%< cleanup */
1109 pkcs11eddsa_fromlabel,
1110 NULL, /*%< dump */
1111 NULL, /*%< restore */
1112 };
1113
1114 isc_result_t
dst__pkcs11eddsa_init(dst_func_t ** funcp)1115 dst__pkcs11eddsa_init(dst_func_t **funcp) {
1116 REQUIRE(funcp != NULL);
1117 if (*funcp == NULL) {
1118 *funcp = &pkcs11eddsa_functions;
1119 }
1120 return (ISC_R_SUCCESS);
1121 }
1122
1123 #endif /* USE_PKCS11 */
1124