?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
HEIMDAL: move code from source4/heimdal* to third_party/heimdal*
[Samba.git] / third_party / heimdal / lib / hx509 / crypto.c
blob77e721064ef11e158ae033e93cc43146967222a1
1 /*
2 * Copyright (c) 2004 - 2016 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 /*-
37 * RFC5758 specifies no parameters for ecdsa-with-SHA<N> signatures
38 * RFC5754 specifies NULL parameters for sha<N>WithRSAEncryption signatures
39 *
40 * XXX: Make sure that the parameters are either NULL in both the tbs and the
41 * signature, or absent from both the tbs and the signature.
42 */
43
44 static const heim_octet_string null_entry_oid = { 2, rk_UNCONST("\x05\x00") };
45
46 static const unsigned sha512_oid_tree[] = { 2, 16, 840, 1, 101, 3, 4, 2, 3 };
47 const AlgorithmIdentifier _hx509_signature_sha512_data = {
48 { 9, rk_UNCONST(sha512_oid_tree) }, rk_UNCONST(&null_entry_oid)
49 };
50
51 static const unsigned sha384_oid_tree[] = { 2, 16, 840, 1, 101, 3, 4, 2, 2 };
52 const AlgorithmIdentifier _hx509_signature_sha384_data = {
53 { 9, rk_UNCONST(sha384_oid_tree) }, rk_UNCONST(&null_entry_oid)
54 };
55
56 static const unsigned sha256_oid_tree[] = { 2, 16, 840, 1, 101, 3, 4, 2, 1 };
57 const AlgorithmIdentifier _hx509_signature_sha256_data = {
58 { 9, rk_UNCONST(sha256_oid_tree) }, rk_UNCONST(&null_entry_oid)
59 };
60
61 static const unsigned sha1_oid_tree[] = { 1, 3, 14, 3, 2, 26 };
62 const AlgorithmIdentifier _hx509_signature_sha1_data = {
63 { 6, rk_UNCONST(sha1_oid_tree) }, rk_UNCONST(&null_entry_oid)
64 };
65
66 static const unsigned md5_oid_tree[] = { 1, 2, 840, 113549, 2, 5 };
67 const AlgorithmIdentifier _hx509_signature_md5_data = {
68 { 6, rk_UNCONST(md5_oid_tree) }, rk_UNCONST(&null_entry_oid)
69 };
70
71 static const unsigned rsa_with_sha512_oid[] ={ 1, 2, 840, 113549, 1, 1, 13 };
72 const AlgorithmIdentifier _hx509_signature_rsa_with_sha512_data = {
73 { 7, rk_UNCONST(rsa_with_sha512_oid) }, rk_UNCONST(&null_entry_oid)
74 };
75
76 static const unsigned rsa_with_sha384_oid[] ={ 1, 2, 840, 113549, 1, 1, 12 };
77 const AlgorithmIdentifier _hx509_signature_rsa_with_sha384_data = {
78 { 7, rk_UNCONST(rsa_with_sha384_oid) }, rk_UNCONST(&null_entry_oid)
79 };
80
81 static const unsigned rsa_with_sha256_oid[] ={ 1, 2, 840, 113549, 1, 1, 11 };
82 const AlgorithmIdentifier _hx509_signature_rsa_with_sha256_data = {
83 { 7, rk_UNCONST(rsa_with_sha256_oid) }, rk_UNCONST(&null_entry_oid)
84 };
85
86 static const unsigned rsa_with_sha1_oid[] ={ 1, 2, 840, 113549, 1, 1, 5 };
87 const AlgorithmIdentifier _hx509_signature_rsa_with_sha1_data = {
88 { 7, rk_UNCONST(rsa_with_sha1_oid) }, rk_UNCONST(&null_entry_oid)
89 };
90
91 static const unsigned rsa_with_md5_oid[] ={ 1, 2, 840, 113549, 1, 1, 4 };
92 const AlgorithmIdentifier _hx509_signature_rsa_with_md5_data = {
93 { 7, rk_UNCONST(rsa_with_md5_oid) }, rk_UNCONST(&null_entry_oid)
94 };
95
96 static const unsigned rsa_oid[] ={ 1, 2, 840, 113549, 1, 1, 1 };
97 const AlgorithmIdentifier _hx509_signature_rsa_data = {
98 { 7, rk_UNCONST(rsa_oid) }, NULL
99 };
100
101 static const unsigned rsa_pkcs1_x509_oid[] ={ 1, 2, 752, 43, 16, 1 };
102 const AlgorithmIdentifier _hx509_signature_rsa_pkcs1_x509_data = {
103 { 6, rk_UNCONST(rsa_pkcs1_x509_oid) }, NULL
104 };
105
106 static const unsigned des_rsdi_ede3_cbc_oid[] ={ 1, 2, 840, 113549, 3, 7 };
107 const AlgorithmIdentifier _hx509_des_rsdi_ede3_cbc_oid = {
108 { 6, rk_UNCONST(des_rsdi_ede3_cbc_oid) }, NULL
109 };
110
111 static const unsigned aes128_cbc_oid[] ={ 2, 16, 840, 1, 101, 3, 4, 1, 2 };
112 const AlgorithmIdentifier _hx509_crypto_aes128_cbc_data = {
113 { 9, rk_UNCONST(aes128_cbc_oid) }, NULL
114 };
115
116 static const unsigned aes256_cbc_oid[] ={ 2, 16, 840, 1, 101, 3, 4, 1, 42 };
117 const AlgorithmIdentifier _hx509_crypto_aes256_cbc_data = {
118 { 9, rk_UNCONST(aes256_cbc_oid) }, NULL
119 };
120
121 /*
122 *
123 */
124
125 static BIGNUM *
126 heim_int2BN(const heim_integer *i)
127 {
128 BIGNUM *bn;
129
130 bn = BN_bin2bn(i->data, i->length, NULL);
131 BN_set_negative(bn, i->negative);
132 return bn;
133 }
134
135 /*
136 *
137 */
138
139 HX509_LIB_FUNCTION int HX509_LIB_CALL
140 _hx509_set_digest_alg(DigestAlgorithmIdentifier *id,
141 const heim_oid *oid,
142 const void *param, size_t length)
143 {
144 int ret;
145 if (param) {
146 id->parameters = malloc(sizeof(*id->parameters));
147 if (id->parameters == NULL)
148 return ENOMEM;
149 id->parameters->data = malloc(length);
150 if (id->parameters->data == NULL) {
151 free(id->parameters);
152 id->parameters = NULL;
153 return ENOMEM;
154 }
155 memcpy(id->parameters->data, param, length);
156 id->parameters->length = length;
157 } else
158 id->parameters = NULL;
159 ret = der_copy_oid(oid, &id->algorithm);
160 if (ret) {
161 if (id->parameters) {
162 free(id->parameters->data);
163 free(id->parameters);
164 id->parameters = NULL;
165 }
166 return ret;
167 }
168 return 0;
169 }
170
171 /*
172 *
173 */
174
175 static int
176 rsa_verify_signature(hx509_context context,
177 const struct signature_alg *sig_alg,
178 const Certificate *signer,
179 const AlgorithmIdentifier *alg,
180 const heim_octet_string *data,
181 const heim_octet_string *sig)
182 {
183 const SubjectPublicKeyInfo *spi;
184 DigestInfo di;
185 unsigned char *to;
186 int tosize, retsize;
187 int ret;
188 RSA *rsa;
189 size_t size;
190 const unsigned char *p;
191
192 memset(&di, 0, sizeof(di));
193
194 spi = &signer->tbsCertificate.subjectPublicKeyInfo;
195
196 p = spi->subjectPublicKey.data;
197 size = spi->subjectPublicKey.length / 8;
198
199 rsa = d2i_RSAPublicKey(NULL, &p, size);
200 if (rsa == NULL) {
201 ret = ENOMEM;
202 hx509_set_error_string(context, 0, ret, "out of memory");
203 goto out;
204 }
205
206 tosize = RSA_size(rsa);
207 to = malloc(tosize);
208 if (to == NULL) {
209 ret = ENOMEM;
210 hx509_set_error_string(context, 0, ret, "out of memory");
211 goto out;
212 }
213
214 retsize = RSA_public_decrypt(sig->length, (unsigned char *)sig->data,
215 to, rsa, RSA_PKCS1_PADDING);
216 if (retsize <= 0) {
217 ret = HX509_CRYPTO_SIG_INVALID_FORMAT;
218 hx509_set_error_string(context, 0, ret,
219 "RSA public decrypt failed: %d", retsize);
220 free(to);
221 goto out;
222 }
223 if (retsize > tosize)
224 _hx509_abort("internal rsa decryption failure: ret > tosize");
225
226 if (sig_alg->flags & RA_RSA_USES_DIGEST_INFO) {
227
228 ret = decode_DigestInfo(to, retsize, &di, &size);
229 free(to);
230 if (ret) {
231 goto out;
232 }
233
234 /* Check for extra data inside the sigature */
235 if (size != (size_t)retsize) {
236 ret = HX509_CRYPTO_SIG_INVALID_FORMAT;
237 hx509_set_error_string(context, 0, ret, "size from decryption mismatch");
238 goto out;
239 }
240
241 if (sig_alg->digest_alg &&
242 der_heim_oid_cmp(&di.digestAlgorithm.algorithm,
243 &sig_alg->digest_alg->algorithm) != 0)
244 {
245 ret = HX509_CRYPTO_OID_MISMATCH;
246 hx509_set_error_string(context, 0, ret, "object identifier in RSA sig mismatch");
247 goto out;
248 }
249
250 /* verify that the parameters are NULL or the NULL-type */
251 if (di.digestAlgorithm.parameters != NULL &&
252 (di.digestAlgorithm.parameters->length != 2 ||
253 memcmp(di.digestAlgorithm.parameters->data, "\x05\x00", 2) != 0))
254 {
255 ret = HX509_CRYPTO_SIG_INVALID_FORMAT;
256 hx509_set_error_string(context, 0, ret, "Extra parameters inside RSA signature");
257 goto out;
258 }
259
260 ret = _hx509_verify_signature(context,
261 NULL,
262 &di.digestAlgorithm,
263 data,
264 &di.digest);
265 if (ret)
266 goto out;
267
268 } else {
269 if ((size_t)retsize != data->length ||
270 ct_memcmp(to, data->data, retsize) != 0)
271 {
272 ret = HX509_CRYPTO_SIG_INVALID_FORMAT;
273 hx509_set_error_string(context, 0, ret, "RSA Signature incorrect");
274 goto out;
275 }
276 free(to);
277 ret = 0;
278 }
279
280 out:
281 free_DigestInfo(&di);
282 if (rsa)
283 RSA_free(rsa);
284 return ret;
285 }
286
287 static int
288 rsa_create_signature(hx509_context context,
289 const struct signature_alg *sig_alg,
290 const hx509_private_key signer,
291 const AlgorithmIdentifier *alg,
292 const heim_octet_string *data,
293 AlgorithmIdentifier *signatureAlgorithm,
294 heim_octet_string *sig)
295 {
296 const AlgorithmIdentifier *digest_alg;
297 heim_octet_string indata;
298 const heim_oid *sig_oid;
299 size_t size;
300 int ret;
301
302 if (signer->ops && der_heim_oid_cmp(signer->ops->key_oid, ASN1_OID_ID_PKCS1_RSAENCRYPTION) != 0)
303 return HX509_ALG_NOT_SUPP;
304
305 if (alg)
306 sig_oid = &alg->algorithm;
307 else
308 sig_oid = signer->signature_alg;
309
310 if (der_heim_oid_cmp(sig_oid, ASN1_OID_ID_PKCS1_SHA512WITHRSAENCRYPTION) == 0) {
311 digest_alg = hx509_signature_sha512();
312 } else if (der_heim_oid_cmp(sig_oid, ASN1_OID_ID_PKCS1_SHA384WITHRSAENCRYPTION) == 0) {
313 digest_alg = hx509_signature_sha384();
314 } else if (der_heim_oid_cmp(sig_oid, ASN1_OID_ID_PKCS1_SHA256WITHRSAENCRYPTION) == 0) {
315 digest_alg = hx509_signature_sha256();
316 } else if (der_heim_oid_cmp(sig_oid, ASN1_OID_ID_PKCS1_SHA1WITHRSAENCRYPTION) == 0) {
317 digest_alg = hx509_signature_sha1();
318 } else if (der_heim_oid_cmp(sig_oid, ASN1_OID_ID_PKCS1_MD5WITHRSAENCRYPTION) == 0) {
319 digest_alg = hx509_signature_md5();
320 } else if (der_heim_oid_cmp(sig_oid, ASN1_OID_ID_PKCS1_MD5WITHRSAENCRYPTION) == 0) {
321 digest_alg = hx509_signature_md5();
322 } else if (der_heim_oid_cmp(sig_oid, ASN1_OID_ID_DSA_WITH_SHA1) == 0) {
323 digest_alg = hx509_signature_sha1();
324 } else if (der_heim_oid_cmp(sig_oid, ASN1_OID_ID_PKCS1_RSAENCRYPTION) == 0) {
325 digest_alg = hx509_signature_sha1();
326 } else if (der_heim_oid_cmp(sig_oid, ASN1_OID_ID_HEIM_RSA_PKCS1_X509) == 0) {
327 digest_alg = NULL;
328 } else
329 return HX509_ALG_NOT_SUPP;
330
331 if (signatureAlgorithm) {
332 ret = _hx509_set_digest_alg(signatureAlgorithm, sig_oid,
333 "\x05\x00", 2);
334 if (ret) {
335 hx509_clear_error_string(context);
336 return ret;
337 }
338 }
339
340 if (digest_alg) {
341 DigestInfo di;
342 memset(&di, 0, sizeof(di));
343
344 ret = _hx509_create_signature(context,
345 NULL,
346 digest_alg,
347 data,
348 &di.digestAlgorithm,
349 &di.digest);
350 if (ret)
351 return ret;
352 ASN1_MALLOC_ENCODE(DigestInfo,
353 indata.data,
354 indata.length,
355 &di,
356 &size,
357 ret);
358 free_DigestInfo(&di);
359 if (ret) {
360 hx509_set_error_string(context, 0, ret, "out of memory");
361 return ret;
362 }
363 if (indata.length != size)
364 _hx509_abort("internal ASN.1 encoder error");
365 } else {
366 indata = *data;
367 }
368
369 sig->length = RSA_size(signer->private_key.rsa);
370 sig->data = malloc(sig->length);
371 if (sig->data == NULL) {
372 der_free_octet_string(&indata);
373 hx509_set_error_string(context, 0, ENOMEM, "out of memory");
374 return ENOMEM;
375 }
376
377 ret = RSA_private_encrypt(indata.length, indata.data,
378 sig->data,
379 signer->private_key.rsa,
380 RSA_PKCS1_PADDING);
381 if (indata.data != data->data)
382 der_free_octet_string(&indata);
383 if (ret <= 0) {
384 ret = HX509_CMS_FAILED_CREATE_SIGATURE;
385 hx509_set_error_string(context, 0, ret,
386 "RSA private encrypt failed: %d", ret);
387 return ret;
388 }
389 if (sig->length > (size_t)ret) {
390 size = sig->length - ret;
391 memmove((uint8_t *)sig->data + size, sig->data, ret);
392 memset(sig->data, 0, size);
393 } else if (sig->length < (size_t)ret)
394 _hx509_abort("RSA signature prelen longer the output len");
395
396 return 0;
397 }
398
399 static int
400 rsa_private_key_import(hx509_context context,
401 const AlgorithmIdentifier *keyai,
402 const void *data,
403 size_t len,
404 hx509_key_format_t format,
405 hx509_private_key private_key)
406 {
407 switch (format) {
408 case HX509_KEY_FORMAT_DER: {
409 const unsigned char *p = data;
410
411 private_key->private_key.rsa =
412 d2i_RSAPrivateKey(NULL, &p, len);
413 if (private_key->private_key.rsa == NULL) {
414 hx509_set_error_string(context, 0, HX509_PARSING_KEY_FAILED,
415 "Failed to parse RSA key");
416 return HX509_PARSING_KEY_FAILED;
417 }
418 private_key->signature_alg = ASN1_OID_ID_PKCS1_SHA1WITHRSAENCRYPTION;
419 break;
420
421 }
422 default:
423 return HX509_CRYPTO_KEY_FORMAT_UNSUPPORTED;
424 }
425
426 return 0;
427 }
428
429 static int
430 rsa_private_key2SPKI(hx509_context context,
431 hx509_private_key private_key,
432 SubjectPublicKeyInfo *spki)
433 {
434 int len, ret;
435
436 memset(spki, 0, sizeof(*spki));
437
438 len = i2d_RSAPublicKey(private_key->private_key.rsa, NULL);
439
440 spki->subjectPublicKey.data = malloc(len);
441 if (spki->subjectPublicKey.data == NULL) {
442 hx509_set_error_string(context, 0, ENOMEM, "malloc - out of memory");
443 return ENOMEM;
444 }
445 spki->subjectPublicKey.length = len * 8;
446
447 ret = _hx509_set_digest_alg(&spki->algorithm,
448 ASN1_OID_ID_PKCS1_RSAENCRYPTION,
449 "\x05\x00", 2);
450 if (ret) {
451 hx509_set_error_string(context, 0, ret, "malloc - out of memory");
452 free(spki->subjectPublicKey.data);
453 spki->subjectPublicKey.data = NULL;
454 spki->subjectPublicKey.length = 0;
455 return ret;
456 }
457
458 {
459 unsigned char *pp = spki->subjectPublicKey.data;
460 i2d_RSAPublicKey(private_key->private_key.rsa, &pp);
461 }
462
463 return 0;
464 }
465
466 static int
467 rsa_generate_private_key(hx509_context context,
468 struct hx509_generate_private_context *ctx,
469 hx509_private_key private_key)
470 {
471 BIGNUM *e;
472 int ret;
473 unsigned long bits;
474
475 static const int default_rsa_e = 65537;
476 static const int default_rsa_bits = 2048;
477
478 private_key->private_key.rsa = RSA_new();
479 if (private_key->private_key.rsa == NULL) {
480 hx509_set_error_string(context, 0, HX509_PARSING_KEY_FAILED,
481 "Failed to generate RSA key");
482 return HX509_PARSING_KEY_FAILED;
483 }
484
485 e = BN_new();
486 BN_set_word(e, default_rsa_e);
487
488 bits = default_rsa_bits;
489
490 if (ctx->num_bits)
491 bits = ctx->num_bits;
492
493 ret = RSA_generate_key_ex(private_key->private_key.rsa, bits, e, NULL);
494 BN_free(e);
495 if (ret != 1) {
496 hx509_set_error_string(context, 0, HX509_PARSING_KEY_FAILED,
497 "Failed to generate RSA key");
498 return HX509_PARSING_KEY_FAILED;
499 }
500 private_key->signature_alg = ASN1_OID_ID_PKCS1_SHA1WITHRSAENCRYPTION;
501
502 return 0;
503 }
504
505 static int
506 rsa_private_key_export(hx509_context context,
507 const hx509_private_key key,
508 hx509_key_format_t format,
509 heim_octet_string *data)
510 {
511 int ret;
512
513 data->data = NULL;
514 data->length = 0;
515
516 switch (format) {
517 case HX509_KEY_FORMAT_DER:
518
519 ret = i2d_RSAPrivateKey(key->private_key.rsa, NULL);
520 if (ret <= 0) {
521 ret = EINVAL;
522 hx509_set_error_string(context, 0, ret,
523 "Private key is not exportable");
524 return ret;
525 }
526
527 data->data = malloc(ret);
528 if (data->data == NULL) {
529 ret = ENOMEM;
530 hx509_set_error_string(context, 0, ret, "malloc out of memory");
531 return ret;
532 }
533 data->length = ret;
534
535 {
536 unsigned char *p = data->data;
537 i2d_RSAPrivateKey(key->private_key.rsa, &p);
538 }
539 break;
540 default:
541 return HX509_CRYPTO_KEY_FORMAT_UNSUPPORTED;
542 }
543
544 return 0;
545 }
546
547 static BIGNUM *
548 rsa_get_internal(hx509_context context,
549 hx509_private_key key,
550 const char *type)
551 {
552 if (strcasecmp(type, "rsa-modulus") == 0) {
553 return BN_dup(key->private_key.rsa->n);
554 } else if (strcasecmp(type, "rsa-exponent") == 0) {
555 return BN_dup(key->private_key.rsa->e);
556 } else
557 return NULL;
558 }
559
560
561
562 static hx509_private_key_ops rsa_private_key_ops = {
563 "RSA PRIVATE KEY",
564 ASN1_OID_ID_PKCS1_RSAENCRYPTION,
565 NULL,
566 rsa_private_key2SPKI,
567 rsa_private_key_export,
568 rsa_private_key_import,
569 rsa_generate_private_key,
570 rsa_get_internal
571 };
572
573 /*
574 *
575 */
576
577 static int
578 dsa_verify_signature(hx509_context context,
579 const struct signature_alg *sig_alg,
580 const Certificate *signer,
581 const AlgorithmIdentifier *alg,
582 const heim_octet_string *data,
583 const heim_octet_string *sig)
584 {
585 const SubjectPublicKeyInfo *spi;
586 DSAPublicKey pk;
587 DSAParams param;
588 size_t size;
589 DSA *dsa;
590 int ret;
591
592 spi = &signer->tbsCertificate.subjectPublicKeyInfo;
593
594 dsa = DSA_new();
595 if (dsa == NULL) {
596 hx509_set_error_string(context, 0, ENOMEM, "out of memory");
597 return ENOMEM;
598 }
599
600 ret = decode_DSAPublicKey(spi->subjectPublicKey.data,
601 spi->subjectPublicKey.length / 8,
602 &pk, &size);
603 if (ret)
604 goto out;
605
606 dsa->pub_key = heim_int2BN(&pk);
607
608 free_DSAPublicKey(&pk);
609
610 if (dsa->pub_key == NULL) {
611 ret = ENOMEM;
612 hx509_set_error_string(context, 0, ret, "out of memory");
613 goto out;
614 }
615
616 if (spi->algorithm.parameters == NULL) {
617 ret = HX509_CRYPTO_SIG_INVALID_FORMAT;
618 hx509_set_error_string(context, 0, ret, "DSA parameters missing");
619 goto out;
620 }
621
622 ret = decode_DSAParams(spi->algorithm.parameters->data,
623 spi->algorithm.parameters->length,
624 &param,
625 &size);
626 if (ret) {
627 hx509_set_error_string(context, 0, ret, "DSA parameters failed to decode");
628 goto out;
629 }
630
631 dsa->p = heim_int2BN(&param.p);
632 dsa->q = heim_int2BN(&param.q);
633 dsa->g = heim_int2BN(&param.g);
634
635 free_DSAParams(&param);
636
637 if (dsa->p == NULL || dsa->q == NULL || dsa->g == NULL) {
638 ret = ENOMEM;
639 hx509_set_error_string(context, 0, ret, "out of memory");
640 goto out;
641 }
642
643 ret = DSA_verify(-1, data->data, data->length,
644 (unsigned char*)sig->data, sig->length,
645 dsa);
646 if (ret == 1)
647 ret = 0;
648 else if (ret == 0 || ret == -1) {
649 ret = HX509_CRYPTO_BAD_SIGNATURE;
650 hx509_set_error_string(context, 0, ret, "BAD DSA sigature");
651 } else {
652 ret = HX509_CRYPTO_SIG_INVALID_FORMAT;
653 hx509_set_error_string(context, 0, ret, "Invalid format of DSA sigature");
654 }
655
656 out:
657 DSA_free(dsa);
658
659 return ret;
660 }
661
662 #if 0
663 static int
664 dsa_parse_private_key(hx509_context context,
665 const void *data,
666 size_t len,
667 hx509_private_key private_key)
668 {
669 const unsigned char *p = data;
670
671 private_key->private_key.dsa =
672 d2i_DSAPrivateKey(NULL, &p, len);
673 if (private_key->private_key.dsa == NULL)
674 return EINVAL;
675 private_key->signature_alg = ASN1_OID_ID_DSA_WITH_SHA1;
676
677 return 0;
678 /* else */
679 hx509_set_error_string(context, 0, HX509_PARSING_KEY_FAILED,
680 "No support to parse DSA keys");
681 return HX509_PARSING_KEY_FAILED;
682 }
683 #endif
684
685 static int
686 evp_md_create_signature(hx509_context context,
687 const struct signature_alg *sig_alg,
688 const hx509_private_key signer,
689 const AlgorithmIdentifier *alg,
690 const heim_octet_string *data,
691 AlgorithmIdentifier *signatureAlgorithm,
692 heim_octet_string *sig)
693 {
694 size_t sigsize = EVP_MD_size(sig_alg->evp_md());
695 EVP_MD_CTX *ctx;
696
697 memset(sig, 0, sizeof(*sig));
698
699 if (signatureAlgorithm) {
700 int ret;
701 ret = _hx509_set_digest_alg(signatureAlgorithm,
702 sig_alg->sig_oid, "\x05\x00", 2);
703 if (ret)
704 return ret;
705 }
706
707
708 sig->data = malloc(sigsize);
709 if (sig->data == NULL) {
710 sig->length = 0;
711 return ENOMEM;
712 }
713 sig->length = sigsize;
714
715 ctx = EVP_MD_CTX_create();
716 EVP_DigestInit_ex(ctx, sig_alg->evp_md(), NULL);
717 EVP_DigestUpdate(ctx, data->data, data->length);
718 EVP_DigestFinal_ex(ctx, sig->data, NULL);
719 EVP_MD_CTX_destroy(ctx);
720
721
722 return 0;
723 }
724
725 static int
726 evp_md_verify_signature(hx509_context context,
727 const struct signature_alg *sig_alg,
728 const Certificate *signer,
729 const AlgorithmIdentifier *alg,
730 const heim_octet_string *data,
731 const heim_octet_string *sig)
732 {
733 unsigned char digest[EVP_MAX_MD_SIZE];
734 EVP_MD_CTX *ctx;
735 size_t sigsize = EVP_MD_size(sig_alg->evp_md());
736
737 if (sig->length != sigsize || sigsize > sizeof(digest)) {
738 hx509_set_error_string(context, 0, HX509_CRYPTO_SIG_INVALID_FORMAT,
739 "SHA256 sigature have wrong length");
740 return HX509_CRYPTO_SIG_INVALID_FORMAT;
741 }
742
743 ctx = EVP_MD_CTX_create();
744 EVP_DigestInit_ex(ctx, sig_alg->evp_md(), NULL);
745 EVP_DigestUpdate(ctx, data->data, data->length);
746 EVP_DigestFinal_ex(ctx, digest, NULL);
747 EVP_MD_CTX_destroy(ctx);
748
749 if (ct_memcmp(digest, sig->data, sigsize) != 0) {
750 hx509_set_error_string(context, 0, HX509_CRYPTO_BAD_SIGNATURE,
751 "Bad %s sigature", sig_alg->name);
752 return HX509_CRYPTO_BAD_SIGNATURE;
753 }
754
755 return 0;
756 }
757
758 #ifdef HAVE_HCRYPTO_W_OPENSSL
759 extern const struct signature_alg ecdsa_with_sha512_alg;
760 extern const struct signature_alg ecdsa_with_sha384_alg;
761 extern const struct signature_alg ecdsa_with_sha256_alg;
762 extern const struct signature_alg ecdsa_with_sha1_alg;
763 #endif
764
765 static const struct signature_alg heim_rsa_pkcs1_x509 = {
766 "rsa-pkcs1-x509",
767 ASN1_OID_ID_HEIM_RSA_PKCS1_X509,
768 &_hx509_signature_rsa_pkcs1_x509_data,
769 ASN1_OID_ID_PKCS1_RSAENCRYPTION,
770 NULL,
771 PROVIDE_CONF|REQUIRE_SIGNER|SIG_PUBLIC_SIG,
772 0,
773 NULL,
774 rsa_verify_signature,
775 rsa_create_signature,
776 0
777 };
778
779 static const struct signature_alg pkcs1_rsa_sha1_alg = {
780 "rsa",
781 ASN1_OID_ID_PKCS1_RSAENCRYPTION,
782 &_hx509_signature_rsa_with_sha1_data,
783 ASN1_OID_ID_PKCS1_RSAENCRYPTION,
784 NULL,
785 PROVIDE_CONF|REQUIRE_SIGNER|RA_RSA_USES_DIGEST_INFO|SIG_PUBLIC_SIG|SELF_SIGNED_OK,
786 0,
787 NULL,
788 rsa_verify_signature,
789 rsa_create_signature,
790 0
791 };
792
793 static const struct signature_alg rsa_with_sha512_alg = {
794 "rsa-with-sha512",
795 ASN1_OID_ID_PKCS1_SHA512WITHRSAENCRYPTION,
796 &_hx509_signature_rsa_with_sha512_data,
797 ASN1_OID_ID_PKCS1_RSAENCRYPTION,
798 &_hx509_signature_sha512_data,
799 PROVIDE_CONF|REQUIRE_SIGNER|RA_RSA_USES_DIGEST_INFO|SIG_PUBLIC_SIG|SELF_SIGNED_OK,
800 0,
801 NULL,
802 rsa_verify_signature,
803 rsa_create_signature,
804 0
805 };
806
807 static const struct signature_alg rsa_with_sha384_alg = {
808 "rsa-with-sha384",
809 ASN1_OID_ID_PKCS1_SHA384WITHRSAENCRYPTION,
810 &_hx509_signature_rsa_with_sha384_data,
811 ASN1_OID_ID_PKCS1_RSAENCRYPTION,
812 &_hx509_signature_sha384_data,
813 PROVIDE_CONF|REQUIRE_SIGNER|RA_RSA_USES_DIGEST_INFO|SIG_PUBLIC_SIG|SELF_SIGNED_OK,
814 0,
815 NULL,
816 rsa_verify_signature,
817 rsa_create_signature,
818 0
819 };
820
821 static const struct signature_alg rsa_with_sha256_alg = {
822 "rsa-with-sha256",
823 ASN1_OID_ID_PKCS1_SHA256WITHRSAENCRYPTION,
824 &_hx509_signature_rsa_with_sha256_data,
825 ASN1_OID_ID_PKCS1_RSAENCRYPTION,
826 &_hx509_signature_sha256_data,
827 PROVIDE_CONF|REQUIRE_SIGNER|RA_RSA_USES_DIGEST_INFO|SIG_PUBLIC_SIG|SELF_SIGNED_OK,
828 0,
829 NULL,
830 rsa_verify_signature,
831 rsa_create_signature,
832 0
833 };
834
835 static const struct signature_alg rsa_with_sha1_alg = {
836 "rsa-with-sha1",
837 ASN1_OID_ID_PKCS1_SHA1WITHRSAENCRYPTION,
838 &_hx509_signature_rsa_with_sha1_data,
839 ASN1_OID_ID_PKCS1_RSAENCRYPTION,
840 &_hx509_signature_sha1_data,
841 PROVIDE_CONF|REQUIRE_SIGNER|RA_RSA_USES_DIGEST_INFO|SIG_PUBLIC_SIG|SELF_SIGNED_OK,
842 0,
843 NULL,
844 rsa_verify_signature,
845 rsa_create_signature,
846 0
847 };
848
849 static const struct signature_alg rsa_with_sha1_alg_secsig = {
850 "rsa-with-sha1",
851 ASN1_OID_ID_SECSIG_SHA_1WITHRSAENCRYPTION,
852 &_hx509_signature_rsa_with_sha1_data,
853 ASN1_OID_ID_PKCS1_RSAENCRYPTION,
854 &_hx509_signature_sha1_data,
855 PROVIDE_CONF|REQUIRE_SIGNER|RA_RSA_USES_DIGEST_INFO|SIG_PUBLIC_SIG|SELF_SIGNED_OK,
856 0,
857 NULL,
858 rsa_verify_signature,
859 rsa_create_signature,
860 0
861 };
862
863 static const struct signature_alg rsa_with_md5_alg = {
864 "rsa-with-md5",
865 ASN1_OID_ID_PKCS1_MD5WITHRSAENCRYPTION,
866 &_hx509_signature_rsa_with_md5_data,
867 ASN1_OID_ID_PKCS1_RSAENCRYPTION,
868 &_hx509_signature_md5_data,
869 PROVIDE_CONF|REQUIRE_SIGNER|RA_RSA_USES_DIGEST_INFO|SIG_PUBLIC_SIG|WEAK_SIG_ALG,
870 1230739889,
871 NULL,
872 rsa_verify_signature,
873 rsa_create_signature,
874 0
875 };
876
877 static const struct signature_alg dsa_sha1_alg = {
878 "dsa-with-sha1",
879 ASN1_OID_ID_DSA_WITH_SHA1,
880 NULL,
881 ASN1_OID_ID_DSA,
882 &_hx509_signature_sha1_data,
883 PROVIDE_CONF|REQUIRE_SIGNER|SIG_PUBLIC_SIG,
884 0,
885 NULL,
886 dsa_verify_signature,
887 /* create_signature */ NULL,
888 0
889 };
890
891 static const struct signature_alg sha512_alg = {
892 "sha-512",
893 ASN1_OID_ID_SHA512,
894 &_hx509_signature_sha512_data,
895 NULL,
896 NULL,
897 SIG_DIGEST,
898 0,
899 EVP_sha512,
900 evp_md_verify_signature,
901 evp_md_create_signature,
902 0
903 };
904
905 static const struct signature_alg sha384_alg = {
906 "sha-384",
907 ASN1_OID_ID_SHA384,
908 &_hx509_signature_sha384_data,
909 NULL,
910 NULL,
911 SIG_DIGEST,
912 0,
913 EVP_sha384,
914 evp_md_verify_signature,
915 evp_md_create_signature,
916 0
917 };
918
919 static const struct signature_alg sha256_alg = {
920 "sha-256",
921 ASN1_OID_ID_SHA256,
922 &_hx509_signature_sha256_data,
923 NULL,
924 NULL,
925 SIG_DIGEST,
926 0,
927 EVP_sha256,
928 evp_md_verify_signature,
929 evp_md_create_signature,
930 0
931 };
932
933 static const struct signature_alg sha1_alg = {
934 "sha1",
935 ASN1_OID_ID_SECSIG_SHA_1,
936 &_hx509_signature_sha1_data,
937 NULL,
938 NULL,
939 SIG_DIGEST,
940 0,
941 EVP_sha1,
942 evp_md_verify_signature,
943 evp_md_create_signature,
944 0
945 };
946
947 static const struct signature_alg md5_alg = {
948 "rsa-md5",
949 ASN1_OID_ID_RSA_DIGEST_MD5,
950 &_hx509_signature_md5_data,
951 NULL,
952 NULL,
953 SIG_DIGEST|WEAK_SIG_ALG,
954 0,
955 EVP_md5,
956 evp_md_verify_signature,
957 NULL,
958 0
959 };
960
961 /*
962 * Order matter in this structure, "best" first for each "key
963 * compatible" type (type is ECDSA, RSA, DSA, none, etc)
964 */
965
966 static const struct signature_alg *sig_algs[] = {
967 #ifdef HAVE_HCRYPTO_W_OPENSSL
968 &ecdsa_with_sha512_alg,
969 &ecdsa_with_sha384_alg,
970 &ecdsa_with_sha256_alg,
971 &ecdsa_with_sha1_alg,
972 #endif
973 &rsa_with_sha512_alg,
974 &rsa_with_sha384_alg,
975 &rsa_with_sha256_alg,
976 &rsa_with_sha1_alg,
977 &rsa_with_sha1_alg_secsig,
978 &pkcs1_rsa_sha1_alg,
979 &rsa_with_md5_alg,
980 &heim_rsa_pkcs1_x509,
981 &dsa_sha1_alg,
982 &sha512_alg,
983 &sha384_alg,
984 &sha256_alg,
985 &sha1_alg,
986 &md5_alg,
987 NULL
988 };
989
990 const struct signature_alg *
991 _hx509_find_sig_alg(const heim_oid *oid)
992 {
993 unsigned int i;
994 for (i = 0; sig_algs[i]; i++)
995 if (der_heim_oid_cmp(sig_algs[i]->sig_oid, oid) == 0)
996 return sig_algs[i];
997 return NULL;
998 }
999
1000 static const AlgorithmIdentifier *
1001 alg_for_privatekey(const hx509_private_key pk, int type)
1002 {
1003 const heim_oid *keytype;
1004 unsigned int i;
1005
1006 if (pk->ops == NULL)
1007 return NULL;
1008
1009 keytype = pk->ops->key_oid;
1010
1011 for (i = 0; sig_algs[i]; i++) {
1012 if (sig_algs[i]->key_oid == NULL)
1013 continue;
1014 if (der_heim_oid_cmp(sig_algs[i]->key_oid, keytype) != 0)
1015 continue;
1016 if (pk->ops->available &&
1017 pk->ops->available(pk, sig_algs[i]->sig_alg) == 0)
1018 continue;
1019 if (type == HX509_SELECT_PUBLIC_SIG)
1020 return sig_algs[i]->sig_alg;
1021 if (type == HX509_SELECT_DIGEST)
1022 return sig_algs[i]->digest_alg;
1023
1024 return NULL;
1025 }
1026 return NULL;
1027 }
1028
1029 /*
1030 *
1031 */
1032 #ifdef HAVE_HCRYPTO_W_OPENSSL
1033 extern hx509_private_key_ops ecdsa_private_key_ops;
1034 #endif
1035
1036 static struct hx509_private_key_ops *private_algs[] = {
1037 &rsa_private_key_ops,
1038 #ifdef HAVE_HCRYPTO_W_OPENSSL
1039 &ecdsa_private_key_ops,
1040 #endif
1041 NULL
1042 };
1043
1044 HX509_LIB_FUNCTION hx509_private_key_ops * HX509_LIB_CALL
1045 hx509_find_private_alg(const heim_oid *oid)
1046 {
1047 int i;
1048 for (i = 0; private_algs[i]; i++) {
1049 if (private_algs[i]->key_oid == NULL)
1050 continue;
1051 if (der_heim_oid_cmp(private_algs[i]->key_oid, oid) == 0)
1052 return private_algs[i];
1053 }
1054 return NULL;
1055 }
1056
1057 /*
1058 * Check if the algorithm `alg' have a best before date, and if it
1059 * des, make sure the its before the time `t'.
1060 */
1061
1062 HX509_LIB_FUNCTION int HX509_LIB_CALL
1063 _hx509_signature_is_weak(hx509_context context, const AlgorithmIdentifier *alg)
1064 {
1065 const struct signature_alg *md;
1066
1067 md = _hx509_find_sig_alg(&alg->algorithm);
1068 if (md == NULL) {
1069 hx509_clear_error_string(context);
1070 return HX509_SIG_ALG_NO_SUPPORTED;
1071 }
1072 if (md->flags & WEAK_SIG_ALG) {
1073 hx509_set_error_string(context, 0, HX509_CRYPTO_ALGORITHM_BEST_BEFORE,
1074 "Algorithm %s is weak", md->name);
1075 return HX509_CRYPTO_ALGORITHM_BEST_BEFORE;
1076 }
1077 return 0;
1078 }
1079
1080 HX509_LIB_FUNCTION int HX509_LIB_CALL
1081 _hx509_self_signed_valid(hx509_context context,
1082 const AlgorithmIdentifier *alg)
1083 {
1084 const struct signature_alg *md;
1085
1086 md = _hx509_find_sig_alg(&alg->algorithm);
1087 if (md == NULL) {
1088 hx509_clear_error_string(context);
1089 return HX509_SIG_ALG_NO_SUPPORTED;
1090 }
1091 if ((md->flags & SELF_SIGNED_OK) == 0) {
1092 hx509_set_error_string(context, 0, HX509_CRYPTO_ALGORITHM_BEST_BEFORE,
1093 "Algorithm %s not trusted for self signatures",
1094 md->name);
1095 return HX509_CRYPTO_ALGORITHM_BEST_BEFORE;
1096 }
1097 return 0;
1098 }
1099
1100
1101 HX509_LIB_FUNCTION int HX509_LIB_CALL
1102 _hx509_verify_signature(hx509_context context,
1103 const hx509_cert cert,
1104 const AlgorithmIdentifier *alg,
1105 const heim_octet_string *data,
1106 const heim_octet_string *sig)
1107 {
1108 const struct signature_alg *md;
1109 const Certificate *signer = NULL;
1110
1111 if (cert)
1112 signer = _hx509_get_cert(cert);
1113
1114 md = _hx509_find_sig_alg(&alg->algorithm);
1115 if (md == NULL) {
1116 hx509_clear_error_string(context);
1117 return HX509_SIG_ALG_NO_SUPPORTED;
1118 }
1119 if (signer && (md->flags & PROVIDE_CONF) == 0) {
1120 hx509_clear_error_string(context);
1121 return HX509_CRYPTO_SIG_NO_CONF;
1122 }
1123 if (signer == NULL && (md->flags & REQUIRE_SIGNER)) {
1124 hx509_clear_error_string(context);
1125 return HX509_CRYPTO_SIGNATURE_WITHOUT_SIGNER;
1126 }
1127 if (md->key_oid && signer) {
1128 const SubjectPublicKeyInfo *spi;
1129 spi = &signer->tbsCertificate.subjectPublicKeyInfo;
1130
1131 if (der_heim_oid_cmp(&spi->algorithm.algorithm, md->key_oid) != 0) {
1132 hx509_clear_error_string(context);
1133 return HX509_SIG_ALG_DONT_MATCH_KEY_ALG;
1134 }
1135 }
1136 return (*md->verify_signature)(context, md, signer, alg, data, sig);
1137 }
1138
1139 HX509_LIB_FUNCTION int HX509_LIB_CALL
1140 _hx509_create_signature(hx509_context context,
1141 const hx509_private_key signer,
1142 const AlgorithmIdentifier *alg,
1143 const heim_octet_string *data,
1144 AlgorithmIdentifier *signatureAlgorithm,
1145 heim_octet_string *sig)
1146 {
1147 const struct signature_alg *md;
1148
1149 md = _hx509_find_sig_alg(&alg->algorithm);
1150 if (md == NULL) {
1151 hx509_set_error_string(context, 0, HX509_SIG_ALG_NO_SUPPORTED,
1152 "algorithm no supported");
1153 return HX509_SIG_ALG_NO_SUPPORTED;
1154 }
1155
1156 if (signer && (md->flags & PROVIDE_CONF) == 0) {
1157 hx509_set_error_string(context, 0, HX509_SIG_ALG_NO_SUPPORTED,
1158 "algorithm provides no conf");
1159 return HX509_CRYPTO_SIG_NO_CONF;
1160 }
1161
1162 return (*md->create_signature)(context, md, signer, alg, data,
1163 signatureAlgorithm, sig);
1164 }
1165
1166 HX509_LIB_FUNCTION int HX509_LIB_CALL
1167 _hx509_create_signature_bitstring(hx509_context context,
1168 const hx509_private_key signer,
1169 const AlgorithmIdentifier *alg,
1170 const heim_octet_string *data,
1171 AlgorithmIdentifier *signatureAlgorithm,
1172 heim_bit_string *sig)
1173 {
1174 heim_octet_string os;
1175 int ret;
1176
1177 ret = _hx509_create_signature(context, signer, alg,
1178 data, signatureAlgorithm, &os);
1179 if (ret)
1180 return ret;
1181 sig->data = os.data;
1182 sig->length = os.length * 8;
1183 return 0;
1184 }
1185
1186 HX509_LIB_FUNCTION int HX509_LIB_CALL
1187 _hx509_public_encrypt(hx509_context context,
1188 const heim_octet_string *cleartext,
1189 const Certificate *cert,
1190 heim_oid *encryption_oid,
1191 heim_octet_string *ciphertext)
1192 {
1193 const SubjectPublicKeyInfo *spi;
1194 unsigned char *to;
1195 int tosize;
1196 int ret;
1197 RSA *rsa;
1198 size_t size;
1199 const unsigned char *p;
1200
1201 ciphertext->data = NULL;
1202 ciphertext->length = 0;
1203
1204 spi = &cert->tbsCertificate.subjectPublicKeyInfo;
1205
1206 p = spi->subjectPublicKey.data;
1207 size = spi->subjectPublicKey.length / 8;
1208
1209 rsa = d2i_RSAPublicKey(NULL, &p, size);
1210 if (rsa == NULL) {
1211 hx509_set_error_string(context, 0, ENOMEM, "out of memory");
1212 return ENOMEM;
1213 }
1214
1215 tosize = RSA_size(rsa);
1216 to = malloc(tosize);
1217 if (to == NULL) {
1218 RSA_free(rsa);
1219 hx509_set_error_string(context, 0, ENOMEM, "out of memory");
1220 return ENOMEM;
1221 }
1222
1223 ret = RSA_public_encrypt(cleartext->length,
1224 (unsigned char *)cleartext->data,
1225 to, rsa, RSA_PKCS1_PADDING);
1226 RSA_free(rsa);
1227 if (ret <= 0) {
1228 free(to);
1229 hx509_set_error_string(context, 0, HX509_CRYPTO_RSA_PUBLIC_ENCRYPT,
1230 "RSA public encrypt failed with %d", ret);
1231 return HX509_CRYPTO_RSA_PUBLIC_ENCRYPT;
1232 }
1233 if (ret > tosize)
1234 _hx509_abort("internal rsa decryption failure: ret > tosize");
1235
1236 ciphertext->length = ret;
1237 ciphertext->data = to;
1238
1239 ret = der_copy_oid(ASN1_OID_ID_PKCS1_RSAENCRYPTION, encryption_oid);
1240 if (ret) {
1241 der_free_octet_string(ciphertext);
1242 hx509_set_error_string(context, 0, ENOMEM, "out of memory");
1243 return ENOMEM;
1244 }
1245
1246 return 0;
1247 }
1248
1249 HX509_LIB_FUNCTION int HX509_LIB_CALL
1250 hx509_private_key_private_decrypt(hx509_context context,
1251 const heim_octet_string *ciphertext,
1252 const heim_oid *encryption_oid,
1253 hx509_private_key p,
1254 heim_octet_string *cleartext)
1255 {
1256 int ret;
1257
1258 cleartext->data = NULL;
1259 cleartext->length = 0;
1260
1261 if (p->private_key.rsa == NULL) {
1262 hx509_set_error_string(context, 0, HX509_PRIVATE_KEY_MISSING,
1263 "Private RSA key missing");
1264 return HX509_PRIVATE_KEY_MISSING;
1265 }
1266
1267 cleartext->length = RSA_size(p->private_key.rsa);
1268 cleartext->data = malloc(cleartext->length);
1269 if (cleartext->data == NULL) {
1270 hx509_set_error_string(context, 0, ENOMEM, "out of memory");
1271 return ENOMEM;
1272 }
1273 ret = RSA_private_decrypt(ciphertext->length, ciphertext->data,
1274 cleartext->data,
1275 p->private_key.rsa,
1276 RSA_PKCS1_PADDING);
1277 if (ret <= 0) {
1278 der_free_octet_string(cleartext);
1279 hx509_set_error_string(context, 0, HX509_CRYPTO_RSA_PRIVATE_DECRYPT,
1280 "Failed to decrypt using private key: %d", ret);
1281 return HX509_CRYPTO_RSA_PRIVATE_DECRYPT;
1282 }
1283 if (cleartext->length < (size_t)ret)
1284 _hx509_abort("internal rsa decryption failure: ret > tosize");
1285
1286 cleartext->length = ret;
1287
1288 return 0;
1289 }
1290
1291
1292 HX509_LIB_FUNCTION int HX509_LIB_CALL
1293 hx509_parse_private_key(hx509_context context,
1294 const AlgorithmIdentifier *keyai,
1295 const void *data,
1296 size_t len,
1297 hx509_key_format_t format,
1298 hx509_private_key *private_key)
1299 {
1300 struct hx509_private_key_ops *ops;
1301 int ret;
1302
1303 *private_key = NULL;
1304
1305 if (format == HX509_KEY_FORMAT_PKCS8) {
1306 PKCS8PrivateKeyInfo ki;
1307 hx509_private_key key;
1308
1309 ret = decode_PKCS8PrivateKeyInfo(data, len, &ki, NULL);
1310 if (ret) {
1311 hx509_set_error_string(context, 0, HX509_PARSING_KEY_FAILED,
1312 "Failed to parse PKCS#8-encoded private "
1313 "key");
1314 return HX509_PARSING_KEY_FAILED;
1315 }
1316
1317 /* Re-enter to parse DER-encoded key from PKCS#8 envelope */
1318 ret = hx509_parse_private_key(context, &ki.privateKeyAlgorithm,
1319 ki.privateKey.data, ki.privateKey.length,
1320 HX509_KEY_FORMAT_DER, &key);
1321 free_PKCS8PrivateKeyInfo(&ki);
1322 if (ret) {
1323 hx509_set_error_string(context, 0, HX509_PARSING_KEY_FAILED,
1324 "Failed to parse RSA key from PKCS#8 "
1325 "envelope");
1326 return HX509_PARSING_KEY_FAILED;
1327 }
1328
1329 *private_key = key;
1330 return ret;
1331 }
1332
1333 ops = hx509_find_private_alg(&keyai->algorithm);
1334 if (ops == NULL) {
1335 hx509_clear_error_string(context);
1336 return HX509_SIG_ALG_NO_SUPPORTED;
1337 }
1338
1339 ret = hx509_private_key_init(private_key, ops, NULL);
1340 if (ret) {
1341 hx509_set_error_string(context, 0, ret, "out of memory");
1342 return ret;
1343 }
1344
1345 ret = (*ops->import)(context, keyai, data, len, format, *private_key);
1346 if (ret)
1347 hx509_private_key_free(private_key);
1348
1349 return ret;
1350 }
1351
1352 /*
1353 *
1354 */
1355
1356 HX509_LIB_FUNCTION int HX509_LIB_CALL
1357 hx509_private_key2SPKI(hx509_context context,
1358 hx509_private_key private_key,
1359 SubjectPublicKeyInfo *spki)
1360 {
1361 const struct hx509_private_key_ops *ops = private_key->ops;
1362 if (ops == NULL || ops->get_spki == NULL) {
1363 hx509_set_error_string(context, 0, HX509_UNIMPLEMENTED_OPERATION,
1364 "Private key have no key2SPKI function");
1365 return HX509_UNIMPLEMENTED_OPERATION;
1366 }
1367 return (*ops->get_spki)(context, private_key, spki);
1368 }
1369
1370 HX509_LIB_FUNCTION int HX509_LIB_CALL
1371 _hx509_generate_private_key_init(hx509_context context,
1372 const heim_oid *oid,
1373 struct hx509_generate_private_context **ctx)
1374 {
1375 *ctx = NULL;
1376
1377 if (der_heim_oid_cmp(oid, ASN1_OID_ID_PKCS1_RSAENCRYPTION) != 0) {
1378 hx509_set_error_string(context, 0, EINVAL,
1379 "private key not an RSA key");
1380 return EINVAL;
1381 }
1382
1383 *ctx = calloc(1, sizeof(**ctx));
1384 if (*ctx == NULL) {
1385 hx509_set_error_string(context, 0, ENOMEM, "out of memory");
1386 return ENOMEM;
1387 }
1388 (*ctx)->key_oid = oid;
1389
1390 return 0;
1391 }
1392
1393 HX509_LIB_FUNCTION int HX509_LIB_CALL
1394 _hx509_generate_private_key_is_ca(hx509_context context,
1395 struct hx509_generate_private_context *ctx)
1396 {
1397 ctx->isCA = 1;
1398 return 0;
1399 }
1400
1401 HX509_LIB_FUNCTION int HX509_LIB_CALL
1402 _hx509_generate_private_key_bits(hx509_context context,
1403 struct hx509_generate_private_context *ctx,
1404 unsigned long bits)
1405 {
1406 ctx->num_bits = bits;
1407 return 0;
1408 }
1409
1410
1411 HX509_LIB_FUNCTION void HX509_LIB_CALL
1412 _hx509_generate_private_key_free(struct hx509_generate_private_context **ctx)
1413 {
1414 free(*ctx);
1415 *ctx = NULL;
1416 }
1417
1418 HX509_LIB_FUNCTION int HX509_LIB_CALL
1419 _hx509_generate_private_key(hx509_context context,
1420 struct hx509_generate_private_context *ctx,
1421 hx509_private_key *private_key)
1422 {
1423 struct hx509_private_key_ops *ops;
1424 int ret;
1425
1426 *private_key = NULL;
1427
1428 ops = hx509_find_private_alg(ctx->key_oid);
1429 if (ops == NULL) {
1430 hx509_clear_error_string(context);
1431 return HX509_SIG_ALG_NO_SUPPORTED;
1432 }
1433
1434 ret = hx509_private_key_init(private_key, ops, NULL);
1435 if (ret) {
1436 hx509_set_error_string(context, 0, ret, "out of memory");
1437 return ret;
1438 }
1439
1440 ret = (*ops->generate_private_key)(context, ctx, *private_key);
1441 if (ret)
1442 hx509_private_key_free(private_key);
1443
1444 return ret;
1445 }
1446
1447 /*
1448 *
1449 */
1450
1451 const AlgorithmIdentifier *
1452 hx509_signature_sha512(void)
1453 { return &_hx509_signature_sha512_data; }
1454
1455 const AlgorithmIdentifier *
1456 hx509_signature_sha384(void)
1457 { return &_hx509_signature_sha384_data; }
1458
1459 const AlgorithmIdentifier *
1460 hx509_signature_sha256(void)
1461 { return &_hx509_signature_sha256_data; }
1462
1463 const AlgorithmIdentifier *
1464 hx509_signature_sha1(void)
1465 { return &_hx509_signature_sha1_data; }
1466
1467 const AlgorithmIdentifier *
1468 hx509_signature_md5(void)
1469 { return &_hx509_signature_md5_data; }
1470
1471 const AlgorithmIdentifier *
1472 hx509_signature_rsa_with_sha512(void)
1473 { return &_hx509_signature_rsa_with_sha512_data; }
1474
1475 const AlgorithmIdentifier *
1476 hx509_signature_rsa_with_sha384(void)
1477 { return &_hx509_signature_rsa_with_sha384_data; }
1478
1479 const AlgorithmIdentifier *
1480 hx509_signature_rsa_with_sha256(void)
1481 { return &_hx509_signature_rsa_with_sha256_data; }
1482
1483 const AlgorithmIdentifier *
1484 hx509_signature_rsa_with_sha1(void)
1485 { return &_hx509_signature_rsa_with_sha1_data; }
1486
1487 const AlgorithmIdentifier *
1488 hx509_signature_rsa_with_md5(void)
1489 { return &_hx509_signature_rsa_with_md5_data; }
1490
1491 const AlgorithmIdentifier *
1492 hx509_signature_rsa(void)
1493 { return &_hx509_signature_rsa_data; }
1494
1495 const AlgorithmIdentifier *
1496 hx509_signature_rsa_pkcs1_x509(void)
1497 { return &_hx509_signature_rsa_pkcs1_x509_data; }
1498
1499 const AlgorithmIdentifier *
1500 hx509_crypto_des_rsdi_ede3_cbc(void)
1501 { return &_hx509_des_rsdi_ede3_cbc_oid; }
1502
1503 const AlgorithmIdentifier *
1504 hx509_crypto_aes128_cbc(void)
1505 { return &_hx509_crypto_aes128_cbc_data; }
1506
1507 const AlgorithmIdentifier *
1508 hx509_crypto_aes256_cbc(void)
1509 { return &_hx509_crypto_aes256_cbc_data; }
1510
1511 /*
1512 *
1513 */
1514
1515 const AlgorithmIdentifier * _hx509_crypto_default_sig_alg =
1516 &_hx509_signature_rsa_with_sha256_data;
1517 const AlgorithmIdentifier * _hx509_crypto_default_digest_alg =
1518 &_hx509_signature_sha256_data;
1519 const AlgorithmIdentifier * _hx509_crypto_default_secret_alg =
1520 &_hx509_crypto_aes128_cbc_data;
1521
1522 /*
1523 *
1524 */
1525
1526 HX509_LIB_FUNCTION int HX509_LIB_CALL
1527 hx509_private_key_init(hx509_private_key *key,
1528 hx509_private_key_ops *ops,
1529 void *keydata)
1530 {
1531 *key = calloc(1, sizeof(**key));
1532 if (*key == NULL)
1533 return ENOMEM;
1534 (*key)->ref = 1;
1535 (*key)->ops = ops;
1536 (*key)->private_key.keydata = keydata;
1537 return 0;
1538 }
1539
1540 HX509_LIB_FUNCTION hx509_private_key HX509_LIB_CALL
1541 _hx509_private_key_ref(hx509_private_key key)
1542 {
1543 if (key->ref == 0)
1544 _hx509_abort("key refcount <= 0 on ref");
1545 key->ref++;
1546 if (key->ref == UINT_MAX)
1547 _hx509_abort("key refcount == UINT_MAX on ref");
1548 return key;
1549 }
1550
1551 HX509_LIB_FUNCTION const char * HX509_LIB_CALL
1552 _hx509_private_pem_name(hx509_private_key key)
1553 {
1554 return key->ops->pemtype;
1555 }
1556
1557 HX509_LIB_FUNCTION int HX509_LIB_CALL
1558 hx509_private_key_free(hx509_private_key *key)
1559 {
1560 if (key == NULL || *key == NULL)
1561 return 0;
1562
1563 if ((*key)->ref == 0)
1564 _hx509_abort("key refcount == 0 on free");
1565 if (--(*key)->ref > 0)
1566 return 0;
1567
1568 if ((*key)->ops && der_heim_oid_cmp((*key)->ops->key_oid, ASN1_OID_ID_PKCS1_RSAENCRYPTION) == 0) {
1569 if ((*key)->private_key.rsa)
1570 RSA_free((*key)->private_key.rsa);
1571 } else if ((*key)->ops && der_heim_oid_cmp((*key)->ops->key_oid,
1572 ASN1_OID_ID_ECPUBLICKEY) == 0 &&
1573 (*key)->private_key.ecdsa != NULL) {
1574 _hx509_private_eckey_free((*key)->private_key.ecdsa);
1575 }
1576 (*key)->private_key.rsa = NULL;
1577 free(*key);
1578 *key = NULL;
1579 return 0;
1580 }
1581
1582 HX509_LIB_FUNCTION void HX509_LIB_CALL
1583 hx509_private_key_assign_rsa(hx509_private_key key, void *ptr)
1584 {
1585 if (key->private_key.rsa)
1586 RSA_free(key->private_key.rsa);
1587 key->private_key.rsa = ptr;
1588 key->signature_alg = ASN1_OID_ID_PKCS1_SHA1WITHRSAENCRYPTION;
1589 key->md = &pkcs1_rsa_sha1_alg;
1590 }
1591
1592 HX509_LIB_FUNCTION int HX509_LIB_CALL
1593 _hx509_private_key_oid(hx509_context context,
1594 const hx509_private_key key,
1595 heim_oid *data)
1596 {
1597 int ret;
1598 ret = der_copy_oid(key->ops->key_oid, data);
1599 if (ret)
1600 hx509_set_error_string(context, 0, ret, "malloc out of memory");
1601 return ret;
1602 }
1603
1604 HX509_LIB_FUNCTION int HX509_LIB_CALL
1605 _hx509_private_key_exportable(hx509_private_key key)
1606 {
1607 if (key->ops->export == NULL)
1608 return 0;
1609 return 1;
1610 }
1611
1612 HX509_LIB_FUNCTION BIGNUM * HX509_LIB_CALL
1613 _hx509_private_key_get_internal(hx509_context context,
1614 hx509_private_key key,
1615 const char *type)
1616 {
1617 if (key->ops->get_internal == NULL)
1618 return NULL;
1619 return (*key->ops->get_internal)(context, key, type);
1620 }
1621
1622 HX509_LIB_FUNCTION int HX509_LIB_CALL
1623 _hx509_private_key_export(hx509_context context,
1624 const hx509_private_key key,
1625 hx509_key_format_t format,
1626 heim_octet_string *data)
1627 {
1628 if (key->ops->export == NULL) {
1629 hx509_clear_error_string(context);
1630 return HX509_UNIMPLEMENTED_OPERATION;
1631 }
1632 if (format == HX509_KEY_FORMAT_PKCS8) {
1633 PKCS8PrivateKeyInfo ki;
1634 size_t size;
1635 int ret;
1636
1637 memset(&ki, 0, sizeof(ki));
1638 ki.attributes = NULL; /* No localKeyId needed */
1639 ki.privateKey.data = NULL;
1640 ki.privateKeyAlgorithm.algorithm.components = NULL;
1641 ret = der_parse_hex_heim_integer("00", &ki.version);
1642 if (ret == 0)
1643 ret = _hx509_private_key_oid(context, key,
1644 &ki.privateKeyAlgorithm.algorithm);
1645 if (ret == 0)
1646 /* Re-enter */
1647 ret = _hx509_private_key_export(context, key, HX509_KEY_FORMAT_DER,
1648 &ki.privateKey);
1649
1650 /*
1651 * XXX To set ki.privateKeyAlgorithm.parameters we'll need to either
1652 * move this code into the *key->ops->export() functions, or expand
1653 * their signature to allow them to set it for us, or add a method to
1654 * hx509_private_key_ops that allows us to get the parameters from the
1655 * backend.
1656 */
1657 ki.privateKeyAlgorithm.parameters = NULL;
1658
1659 if (ret == 0)
1660 ASN1_MALLOC_ENCODE(PKCS8PrivateKeyInfo, data->data, data->length,
1661 &ki, &size, ret);
1662 free_PKCS8PrivateKeyInfo(&ki);
1663 if (ret == 0 && size != data->length)
1664 ret = EINVAL;
1665 if (ret)
1666 hx509_set_error_string(context, 0, ret,
1667 "Private key PKCS#8 encoding failed");
1668 return ret;
1669 }
1670 return (*key->ops->export)(context, key, format, data);
1671 }
1672
1673 /*
1674 *
1675 */
1676
1677 struct hx509cipher {
1678 const char *name;
1679 int flags;
1680 #define CIPHER_WEAK 1
1681 const heim_oid *oid;
1682 const AlgorithmIdentifier *(*ai_func)(void);
1683 const EVP_CIPHER *(*evp_func)(void);
1684 int (*get_params)(hx509_context, const hx509_crypto,
1685 const heim_octet_string *, heim_octet_string *);
1686 int (*set_params)(hx509_context, const heim_octet_string *,
1687 hx509_crypto, heim_octet_string *);
1688 };
1689
1690 struct hx509_crypto_data {
1691 char *name;
1692 int flags;
1693 #define ALLOW_WEAK 1
1694
1695 #define PADDING_NONE 2
1696 #define PADDING_PKCS7 4
1697 #define PADDING_FLAGS (2|4)
1698 const struct hx509cipher *cipher;
1699 const EVP_CIPHER *c;
1700 heim_octet_string key;
1701 heim_oid oid;
1702 void *param;
1703 };
1704
1705 /*
1706 *
1707 */
1708
1709 static unsigned private_rc2_40_oid_data[] = { 127, 1 };
1710
1711 static heim_oid asn1_oid_private_rc2_40 =
1712 { 2, private_rc2_40_oid_data };
1713
1714 /*
1715 *
1716 */
1717
1718 static int
1719 CMSCBCParam_get(hx509_context context, const hx509_crypto crypto,
1720 const heim_octet_string *ivec, heim_octet_string *param)
1721 {
1722 size_t size;
1723 int ret;
1724
1725 assert(crypto->param == NULL);
1726 if (ivec == NULL)
1727 return 0;
1728
1729 ASN1_MALLOC_ENCODE(CMSCBCParameter, param->data, param->length,
1730 ivec, &size, ret);
1731 if (ret == 0 && size != param->length)
1732 _hx509_abort("Internal asn1 encoder failure");
1733 if (ret)
1734 hx509_clear_error_string(context);
1735 return ret;
1736 }
1737
1738 static int
1739 CMSCBCParam_set(hx509_context context, const heim_octet_string *param,
1740 hx509_crypto crypto, heim_octet_string *ivec)
1741 {
1742 int ret;
1743 if (ivec == NULL)
1744 return 0;
1745
1746 ret = decode_CMSCBCParameter(param->data, param->length, ivec, NULL);
1747 if (ret)
1748 hx509_clear_error_string(context);
1749
1750 return ret;
1751 }
1752
1753 struct _RC2_params {
1754 int maximum_effective_key;
1755 };
1756
1757 static int
1758 CMSRC2CBCParam_get(hx509_context context, const hx509_crypto crypto,
1759 const heim_octet_string *ivec, heim_octet_string *param)
1760 {
1761 CMSRC2CBCParameter rc2params;
1762 const struct _RC2_params *p = crypto->param;
1763 int maximum_effective_key = 128;
1764 size_t size;
1765 int ret;
1766
1767 memset(&rc2params, 0, sizeof(rc2params));
1768
1769 if (p)
1770 maximum_effective_key = p->maximum_effective_key;
1771
1772 switch(maximum_effective_key) {
1773 case 40:
1774 rc2params.rc2ParameterVersion = 160;
1775 break;
1776 case 64:
1777 rc2params.rc2ParameterVersion = 120;
1778 break;
1779 case 128:
1780 rc2params.rc2ParameterVersion = 58;
1781 break;
1782 }
1783 rc2params.iv = *ivec;
1784
1785 ASN1_MALLOC_ENCODE(CMSRC2CBCParameter, param->data, param->length,
1786 &rc2params, &size, ret);
1787 if (ret == 0 && size != param->length)
1788 _hx509_abort("Internal asn1 encoder failure");
1789
1790 return ret;
1791 }
1792
1793 static int
1794 CMSRC2CBCParam_set(hx509_context context, const heim_octet_string *param,
1795 hx509_crypto crypto, heim_octet_string *ivec)
1796 {
1797 CMSRC2CBCParameter rc2param;
1798 struct _RC2_params *p;
1799 size_t size;
1800 int ret;
1801
1802 ret = decode_CMSRC2CBCParameter(param->data, param->length,
1803 &rc2param, &size);
1804 if (ret) {
1805 hx509_clear_error_string(context);
1806 return ret;
1807 }
1808
1809 p = calloc(1, sizeof(*p));
1810 if (p == NULL) {
1811 free_CMSRC2CBCParameter(&rc2param);
1812 hx509_clear_error_string(context);
1813 return ENOMEM;
1814 }
1815 switch(rc2param.rc2ParameterVersion) {
1816 case 160:
1817 crypto->c = EVP_rc2_40_cbc();
1818 p->maximum_effective_key = 40;
1819 break;
1820 case 120:
1821 crypto->c = EVP_rc2_64_cbc();
1822 p->maximum_effective_key = 64;
1823 break;
1824 case 58:
1825 crypto->c = EVP_rc2_cbc();
1826 p->maximum_effective_key = 128;
1827 break;
1828 default:
1829 free(p);
1830 free_CMSRC2CBCParameter(&rc2param);
1831 return HX509_CRYPTO_SIG_INVALID_FORMAT;
1832 }
1833 if (ivec)
1834 ret = der_copy_octet_string(&rc2param.iv, ivec);
1835 free_CMSRC2CBCParameter(&rc2param);
1836 if (ret) {
1837 free(p);
1838 hx509_clear_error_string(context);
1839 } else
1840 crypto->param = p;
1841
1842 return ret;
1843 }
1844
1845 /*
1846 *
1847 */
1848
1849 static const struct hx509cipher ciphers[] = {
1850 {
1851 "rc2-cbc",
1852 CIPHER_WEAK,
1853 ASN1_OID_ID_PKCS3_RC2_CBC,
1854 NULL,
1855 EVP_rc2_cbc,
1856 CMSRC2CBCParam_get,
1857 CMSRC2CBCParam_set
1858 },
1859 {
1860 "rc2-cbc",
1861 CIPHER_WEAK,
1862 ASN1_OID_ID_RSADSI_RC2_CBC,
1863 NULL,
1864 EVP_rc2_cbc,
1865 CMSRC2CBCParam_get,
1866 CMSRC2CBCParam_set
1867 },
1868 {
1869 "rc2-40-cbc",
1870 CIPHER_WEAK,
1871 &asn1_oid_private_rc2_40,
1872 NULL,
1873 EVP_rc2_40_cbc,
1874 CMSRC2CBCParam_get,
1875 CMSRC2CBCParam_set
1876 },
1877 {
1878 "des-ede3-cbc",
1879 0,
1880 ASN1_OID_ID_PKCS3_DES_EDE3_CBC,
1881 NULL,
1882 EVP_des_ede3_cbc,
1883 CMSCBCParam_get,
1884 CMSCBCParam_set
1885 },
1886 {
1887 "des-ede3-cbc",
1888 0,
1889 ASN1_OID_ID_RSADSI_DES_EDE3_CBC,
1890 hx509_crypto_des_rsdi_ede3_cbc,
1891 EVP_des_ede3_cbc,
1892 CMSCBCParam_get,
1893 CMSCBCParam_set
1894 },
1895 {
1896 "aes-128-cbc",
1897 0,
1898 ASN1_OID_ID_AES_128_CBC,
1899 hx509_crypto_aes128_cbc,
1900 EVP_aes_128_cbc,
1901 CMSCBCParam_get,
1902 CMSCBCParam_set
1903 },
1904 {
1905 "aes-192-cbc",
1906 0,
1907 ASN1_OID_ID_AES_192_CBC,
1908 NULL,
1909 EVP_aes_192_cbc,
1910 CMSCBCParam_get,
1911 CMSCBCParam_set
1912 },
1913 {
1914 "aes-256-cbc",
1915 0,
1916 ASN1_OID_ID_AES_256_CBC,
1917 hx509_crypto_aes256_cbc,
1918 EVP_aes_256_cbc,
1919 CMSCBCParam_get,
1920 CMSCBCParam_set
1921 }
1922 };
1923
1924 static const struct hx509cipher *
1925 find_cipher_by_oid(const heim_oid *oid)
1926 {
1927 size_t i;
1928
1929 for (i = 0; i < sizeof(ciphers)/sizeof(ciphers[0]); i++)
1930 if (der_heim_oid_cmp(oid, ciphers[i].oid) == 0)
1931 return &ciphers[i];
1932
1933 return NULL;
1934 }
1935
1936 static const struct hx509cipher *
1937 find_cipher_by_name(const char *name)
1938 {
1939 size_t i;
1940
1941 for (i = 0; i < sizeof(ciphers)/sizeof(ciphers[0]); i++)
1942 if (strcasecmp(name, ciphers[i].name) == 0)
1943 return &ciphers[i];
1944
1945 return NULL;
1946 }
1947
1948
1949 HX509_LIB_FUNCTION const heim_oid * HX509_LIB_CALL
1950 hx509_crypto_enctype_by_name(const char *name)
1951 {
1952 const struct hx509cipher *cipher;
1953
1954 cipher = find_cipher_by_name(name);
1955 if (cipher == NULL)
1956 return NULL;
1957 return cipher->oid;
1958 }
1959
1960 HX509_LIB_FUNCTION int HX509_LIB_CALL
1961 hx509_crypto_init(hx509_context context,
1962 const char *provider,
1963 const heim_oid *enctype,
1964 hx509_crypto *crypto)
1965 {
1966 const struct hx509cipher *cipher;
1967
1968 *crypto = NULL;
1969
1970 cipher = find_cipher_by_oid(enctype);
1971 if (cipher == NULL) {
1972 hx509_set_error_string(context, 0, HX509_ALG_NOT_SUPP,
1973 "Algorithm not supported");
1974 return HX509_ALG_NOT_SUPP;
1975 }
1976
1977 *crypto = calloc(1, sizeof(**crypto));
1978 if (*crypto == NULL) {
1979 hx509_clear_error_string(context);
1980 return ENOMEM;
1981 }
1982
1983 (*crypto)->flags = PADDING_PKCS7;
1984 (*crypto)->cipher = cipher;
1985 (*crypto)->c = (*cipher->evp_func)();
1986
1987 if (der_copy_oid(enctype, &(*crypto)->oid)) {
1988 hx509_crypto_destroy(*crypto);
1989 *crypto = NULL;
1990 hx509_clear_error_string(context);
1991 return ENOMEM;
1992 }
1993
1994 return 0;
1995 }
1996
1997 HX509_LIB_FUNCTION const char * HX509_LIB_CALL
1998 hx509_crypto_provider(hx509_crypto crypto)
1999 {
2000 return "unknown";
2001 }
2002
2003 HX509_LIB_FUNCTION void HX509_LIB_CALL
2004 hx509_crypto_destroy(hx509_crypto crypto)
2005 {
2006 if (crypto->name)
2007 free(crypto->name);
2008 if (crypto->key.data)
2009 free(crypto->key.data);
2010 if (crypto->param)
2011 free(crypto->param);
2012 der_free_oid(&crypto->oid);
2013 memset(crypto, 0, sizeof(*crypto));
2014 free(crypto);
2015 }
2016
2017 HX509_LIB_FUNCTION int HX509_LIB_CALL
2018 hx509_crypto_set_key_name(hx509_crypto crypto, const char *name)
2019 {
2020 return 0;
2021 }
2022
2023 HX509_LIB_FUNCTION void HX509_LIB_CALL
2024 hx509_crypto_allow_weak(hx509_crypto crypto)
2025 {
2026 crypto->flags |= ALLOW_WEAK;
2027 }
2028
2029 HX509_LIB_FUNCTION void HX509_LIB_CALL
2030 hx509_crypto_set_padding(hx509_crypto crypto, int padding_type)
2031 {
2032 switch (padding_type) {
2033 case HX509_CRYPTO_PADDING_PKCS7:
2034 crypto->flags &= ~PADDING_FLAGS;
2035 crypto->flags |= PADDING_PKCS7;
2036 break;
2037 case HX509_CRYPTO_PADDING_NONE:
2038 crypto->flags &= ~PADDING_FLAGS;
2039 crypto->flags |= PADDING_NONE;
2040 break;
2041 default:
2042 _hx509_abort("Invalid padding");
2043 }
2044 }
2045
2046 HX509_LIB_FUNCTION int HX509_LIB_CALL
2047 hx509_crypto_set_key_data(hx509_crypto crypto, const void *data, size_t length)
2048 {
2049 if (EVP_CIPHER_key_length(crypto->c) > (int)length)
2050 return HX509_CRYPTO_INTERNAL_ERROR;
2051
2052 if (crypto->key.data) {
2053 free(crypto->key.data);
2054 crypto->key.data = NULL;
2055 crypto->key.length = 0;
2056 }
2057 crypto->key.data = malloc(length);
2058 if (crypto->key.data == NULL)
2059 return ENOMEM;
2060 memcpy(crypto->key.data, data, length);
2061 crypto->key.length = length;
2062
2063 return 0;
2064 }
2065
2066 HX509_LIB_FUNCTION int HX509_LIB_CALL
2067 hx509_crypto_set_random_key(hx509_crypto crypto, heim_octet_string *key)
2068 {
2069 if (crypto->key.data) {
2070 free(crypto->key.data);
2071 crypto->key.length = 0;
2072 }
2073
2074 crypto->key.length = EVP_CIPHER_key_length(crypto->c);
2075 crypto->key.data = malloc(crypto->key.length);
2076 if (crypto->key.data == NULL) {
2077 crypto->key.length = 0;
2078 return ENOMEM;
2079 }
2080 if (RAND_bytes(crypto->key.data, crypto->key.length) <= 0) {
2081 free(crypto->key.data);
2082 crypto->key.data = NULL;
2083 crypto->key.length = 0;
2084 return HX509_CRYPTO_INTERNAL_ERROR;
2085 }
2086 if (key)
2087 return der_copy_octet_string(&crypto->key, key);
2088 else
2089 return 0;
2090 }
2091
2092 HX509_LIB_FUNCTION int HX509_LIB_CALL
2093 hx509_crypto_set_params(hx509_context context,
2094 hx509_crypto crypto,
2095 const heim_octet_string *param,
2096 heim_octet_string *ivec)
2097 {
2098 return (*crypto->cipher->set_params)(context, param, crypto, ivec);
2099 }
2100
2101 HX509_LIB_FUNCTION int HX509_LIB_CALL
2102 hx509_crypto_get_params(hx509_context context,
2103 hx509_crypto crypto,
2104 const heim_octet_string *ivec,
2105 heim_octet_string *param)
2106 {
2107 return (*crypto->cipher->get_params)(context, crypto, ivec, param);
2108 }
2109
2110 HX509_LIB_FUNCTION int HX509_LIB_CALL
2111 hx509_crypto_random_iv(hx509_crypto crypto, heim_octet_string *ivec)
2112 {
2113 ivec->length = EVP_CIPHER_iv_length(crypto->c);
2114 ivec->data = malloc(ivec->length);
2115 if (ivec->data == NULL) {
2116 ivec->length = 0;
2117 return ENOMEM;
2118 }
2119
2120 if (RAND_bytes(ivec->data, ivec->length) <= 0) {
2121 free(ivec->data);
2122 ivec->data = NULL;
2123 ivec->length = 0;
2124 return HX509_CRYPTO_INTERNAL_ERROR;
2125 }
2126 return 0;
2127 }
2128
2129 HX509_LIB_FUNCTION int HX509_LIB_CALL
2130 hx509_crypto_encrypt(hx509_crypto crypto,
2131 const void *data,
2132 const size_t length,
2133 const heim_octet_string *ivec,
2134 heim_octet_string **ciphertext)
2135 {
2136 EVP_CIPHER_CTX evp;
2137 size_t padsize, bsize;
2138 int ret;
2139
2140 *ciphertext = NULL;
2141
2142 if ((crypto->cipher->flags & CIPHER_WEAK) &&
2143 (crypto->flags & ALLOW_WEAK) == 0)
2144 return HX509_CRYPTO_ALGORITHM_BEST_BEFORE;
2145
2146 assert(EVP_CIPHER_iv_length(crypto->c) == (int)ivec->length);
2147
2148 EVP_CIPHER_CTX_init(&evp);
2149
2150 ret = EVP_CipherInit_ex(&evp, crypto->c, NULL,
2151 crypto->key.data, ivec->data, 1);
2152 if (ret != 1) {
2153 EVP_CIPHER_CTX_cleanup(&evp);
2154 ret = HX509_CRYPTO_INTERNAL_ERROR;
2155 goto out;
2156 }
2157
2158 *ciphertext = calloc(1, sizeof(**ciphertext));
2159 if (*ciphertext == NULL) {
2160 ret = ENOMEM;
2161 goto out;
2162 }
2163
2164 assert(crypto->flags & PADDING_FLAGS);
2165
2166 bsize = EVP_CIPHER_block_size(crypto->c);
2167 padsize = 0;
2168
2169 if (crypto->flags & PADDING_NONE) {
2170 if (bsize != 1 && (length % bsize) != 0)
2171 return HX509_CMS_PADDING_ERROR;
2172 } else if (crypto->flags & PADDING_PKCS7) {
2173 if (bsize != 1)
2174 padsize = bsize - (length % bsize);
2175 }
2176
2177 (*ciphertext)->length = length + padsize;
2178 (*ciphertext)->data = malloc(length + padsize);
2179 if ((*ciphertext)->data == NULL) {
2180 ret = ENOMEM;
2181 goto out;
2182 }
2183
2184 memcpy((*ciphertext)->data, data, length);
2185 if (padsize) {
2186 size_t i;
2187 unsigned char *p = (*ciphertext)->data;
2188 p += length;
2189 for (i = 0; i < padsize; i++)
2190 *p++ = padsize;
2191 }
2192
2193 ret = EVP_Cipher(&evp, (*ciphertext)->data,
2194 (*ciphertext)->data,
2195 length + padsize);
2196 if (ret != 1) {
2197 ret = HX509_CRYPTO_INTERNAL_ERROR;
2198 goto out;
2199 }
2200 ret = 0;
2201
2202 out:
2203 if (ret) {
2204 if (*ciphertext) {
2205 if ((*ciphertext)->data) {
2206 free((*ciphertext)->data);
2207 }
2208 free(*ciphertext);
2209 *ciphertext = NULL;
2210 }
2211 }
2212 EVP_CIPHER_CTX_cleanup(&evp);
2213
2214 return ret;
2215 }
2216
2217 HX509_LIB_FUNCTION int HX509_LIB_CALL
2218 hx509_crypto_decrypt(hx509_crypto crypto,
2219 const void *data,
2220 const size_t length,
2221 heim_octet_string *ivec,
2222 heim_octet_string *clear)
2223 {
2224 EVP_CIPHER_CTX evp;
2225 void *idata = NULL;
2226 int ret;
2227
2228 clear->data = NULL;
2229 clear->length = 0;
2230
2231 if ((crypto->cipher->flags & CIPHER_WEAK) &&
2232 (crypto->flags & ALLOW_WEAK) == 0)
2233 return HX509_CRYPTO_ALGORITHM_BEST_BEFORE;
2234
2235 if (ivec && EVP_CIPHER_iv_length(crypto->c) < (int)ivec->length)
2236 return HX509_CRYPTO_INTERNAL_ERROR;
2237
2238 if (crypto->key.data == NULL)
2239 return HX509_CRYPTO_INTERNAL_ERROR;
2240
2241 if (ivec)
2242 idata = ivec->data;
2243
2244 EVP_CIPHER_CTX_init(&evp);
2245
2246 ret = EVP_CipherInit_ex(&evp, crypto->c, NULL,
2247 crypto->key.data, idata, 0);
2248 if (ret != 1) {
2249 EVP_CIPHER_CTX_cleanup(&evp);
2250 return HX509_CRYPTO_INTERNAL_ERROR;
2251 }
2252
2253 clear->length = length;
2254 clear->data = malloc(length);
2255 if (clear->data == NULL) {
2256 EVP_CIPHER_CTX_cleanup(&evp);
2257 clear->length = 0;
2258 return ENOMEM;
2259 }
2260
2261 if (EVP_Cipher(&evp, clear->data, data, length) != 1) {
2262 return HX509_CRYPTO_INTERNAL_ERROR;
2263 }
2264 EVP_CIPHER_CTX_cleanup(&evp);
2265
2266 if ((crypto->flags & PADDING_PKCS7) && EVP_CIPHER_block_size(crypto->c) > 1) {
2267 int padsize;
2268 unsigned char *p;
2269 int j, bsize = EVP_CIPHER_block_size(crypto->c);
2270
2271 if ((int)clear->length < bsize) {
2272 ret = HX509_CMS_PADDING_ERROR;
2273 goto out;
2274 }
2275
2276 p = clear->data;
2277 p += clear->length - 1;
2278 padsize = *p;
2279 if (padsize > bsize) {
2280 ret = HX509_CMS_PADDING_ERROR;
2281 goto out;
2282 }
2283 clear->length -= padsize;
2284 for (j = 0; j < padsize; j++) {
2285 if (*p-- != padsize) {
2286 ret = HX509_CMS_PADDING_ERROR;
2287 goto out;
2288 }
2289 }
2290 }
2291
2292 return 0;
2293
2294 out:
2295 if (clear->data)
2296 free(clear->data);
2297 clear->data = NULL;
2298 clear->length = 0;
2299 return ret;
2300 }
2301
2302 typedef int (*PBE_string2key_func)(hx509_context,
2303 const char *,
2304 const heim_octet_string *,
2305 hx509_crypto *, heim_octet_string *,
2306 heim_octet_string *,
2307 const heim_oid *, const EVP_MD *);
2308
2309 static int
2310 PBE_string2key(hx509_context context,
2311 const char *password,
2312 const heim_octet_string *parameters,
2313 hx509_crypto *crypto,
2314 heim_octet_string *key, heim_octet_string *iv,
2315 const heim_oid *enc_oid,
2316 const EVP_MD *md)
2317 {
2318 PKCS12_PBEParams p12params;
2319 int passwordlen;
2320 hx509_crypto c;
2321 int iter, saltlen, ret;
2322 unsigned char *salt;
2323
2324 passwordlen = password ? strlen(password) : 0;
2325
2326 if (parameters == NULL)
2327 return HX509_ALG_NOT_SUPP;
2328
2329 ret = decode_PKCS12_PBEParams(parameters->data,
2330 parameters->length,
2331 &p12params, NULL);
2332 if (ret)
2333 goto out;
2334
2335 if (p12params.iterations)
2336 iter = *p12params.iterations;
2337 else
2338 iter = 1;
2339 salt = p12params.salt.data;
2340 saltlen = p12params.salt.length;
2341
2342 if (!PKCS12_key_gen (password, passwordlen, salt, saltlen,
2343 PKCS12_KEY_ID, iter, key->length, key->data, md)) {
2344 ret = HX509_CRYPTO_INTERNAL_ERROR;
2345 goto out;
2346 }
2347
2348 if (!PKCS12_key_gen (password, passwordlen, salt, saltlen,
2349 PKCS12_IV_ID, iter, iv->length, iv->data, md)) {
2350 ret = HX509_CRYPTO_INTERNAL_ERROR;
2351 goto out;
2352 }
2353
2354 ret = hx509_crypto_init(context, NULL, enc_oid, &c);
2355 if (ret)
2356 goto out;
2357
2358 hx509_crypto_allow_weak(c);
2359
2360 ret = hx509_crypto_set_key_data(c, key->data, key->length);
2361 if (ret) {
2362 hx509_crypto_destroy(c);
2363 goto out;
2364 }
2365
2366 *crypto = c;
2367 out:
2368 free_PKCS12_PBEParams(&p12params);
2369 return ret;
2370 }
2371
2372 static const heim_oid *
2373 find_string2key(const heim_oid *oid,
2374 const EVP_CIPHER **c,
2375 const EVP_MD **md,
2376 PBE_string2key_func *s2k)
2377 {
2378 if (der_heim_oid_cmp(oid, ASN1_OID_ID_PBEWITHSHAAND40BITRC2_CBC) == 0) {
2379 *c = EVP_rc2_40_cbc();
2380 if (*c == NULL)
2381 return NULL;
2382 *md = EVP_sha1();
2383 if (*md == NULL)
2384 return NULL;
2385 *s2k = PBE_string2key;
2386 return &asn1_oid_private_rc2_40;
2387 } else if (der_heim_oid_cmp(oid, ASN1_OID_ID_PBEWITHSHAAND128BITRC2_CBC) == 0) {
2388 *c = EVP_rc2_cbc();
2389 if (*c == NULL)
2390 return NULL;
2391 *md = EVP_sha1();
2392 if (*md == NULL)
2393 return NULL;
2394 *s2k = PBE_string2key;
2395 return ASN1_OID_ID_PKCS3_RC2_CBC;
2396 #if 0
2397 } else if (der_heim_oid_cmp(oid, ASN1_OID_ID_PBEWITHSHAAND40BITRC4) == 0) {
2398 *c = EVP_rc4_40();
2399 if (*c == NULL)
2400 return NULL;
2401 *md = EVP_sha1();
2402 if (*md == NULL)
2403 return NULL;
2404 *s2k = PBE_string2key;
2405 return NULL;
2406 } else if (der_heim_oid_cmp(oid, ASN1_OID_ID_PBEWITHSHAAND128BITRC4) == 0) {
2407 *c = EVP_rc4();
2408 if (*c == NULL)
2409 return NULL;
2410 *md = EVP_sha1();
2411 if (*md == NULL)
2412 return NULL;
2413 *s2k = PBE_string2key;
2414 return ASN1_OID_ID_PKCS3_RC4;
2415 #endif
2416 } else if (der_heim_oid_cmp(oid, ASN1_OID_ID_PBEWITHSHAAND3_KEYTRIPLEDES_CBC) == 0) {
2417 *c = EVP_des_ede3_cbc();
2418 if (*c == NULL)
2419 return NULL;
2420 *md = EVP_sha1();
2421 if (*md == NULL)
2422 return NULL;
2423 *s2k = PBE_string2key;
2424 return ASN1_OID_ID_PKCS3_DES_EDE3_CBC;
2425 }
2426
2427 return NULL;
2428 }
2429
2430 /*
2431 *
2432 */
2433
2434 HX509_LIB_FUNCTION int HX509_LIB_CALL
2435 _hx509_pbe_encrypt(hx509_context context,
2436 hx509_lock lock,
2437 const AlgorithmIdentifier *ai,
2438 const heim_octet_string *content,
2439 heim_octet_string *econtent)
2440 {
2441 hx509_clear_error_string(context);
2442 return EINVAL;
2443 }
2444
2445 /*
2446 *
2447 */
2448
2449 HX509_LIB_FUNCTION int HX509_LIB_CALL
2450 _hx509_pbe_decrypt(hx509_context context,
2451 hx509_lock lock,
2452 const AlgorithmIdentifier *ai,
2453 const heim_octet_string *econtent,
2454 heim_octet_string *content)
2455 {
2456 const struct _hx509_password *pw;
2457 heim_octet_string key, iv;
2458 const heim_oid *enc_oid;
2459 const EVP_CIPHER *c;
2460 const EVP_MD *md;
2461 PBE_string2key_func s2k;
2462 int ret = 0;
2463 size_t i;
2464
2465 memset(&key, 0, sizeof(key));
2466 memset(&iv, 0, sizeof(iv));
2467
2468 memset(content, 0, sizeof(*content));
2469
2470 enc_oid = find_string2key(&ai->algorithm, &c, &md, &s2k);
2471 if (enc_oid == NULL) {
2472 hx509_set_error_string(context, 0, HX509_ALG_NOT_SUPP,
2473 "String to key algorithm not supported");
2474 ret = HX509_ALG_NOT_SUPP;
2475 goto out;
2476 }
2477
2478 key.length = EVP_CIPHER_key_length(c);
2479 key.data = malloc(key.length);
2480 if (key.data == NULL) {
2481 ret = ENOMEM;
2482 hx509_clear_error_string(context);
2483 goto out;
2484 }
2485
2486 iv.length = EVP_CIPHER_iv_length(c);
2487 iv.data = malloc(iv.length);
2488 if (iv.data == NULL) {
2489 ret = ENOMEM;
2490 hx509_clear_error_string(context);
2491 goto out;
2492 }
2493
2494 pw = _hx509_lock_get_passwords(lock);
2495
2496 ret = HX509_CRYPTO_INTERNAL_ERROR;
2497 for (i = 0; i < pw->len + 1; i++) {
2498 hx509_crypto crypto;
2499 const char *password;
2500
2501 if (i < pw->len)
2502 password = pw->val[i];
2503 else if (i < pw->len + 1)
2504 password = "";
2505 else
2506 password = NULL;
2507
2508 ret = (*s2k)(context, password, ai->parameters, &crypto,
2509 &key, &iv, enc_oid, md);
2510 if (ret)
2511 goto out;
2512
2513 ret = hx509_crypto_decrypt(crypto,
2514 econtent->data,
2515 econtent->length,
2516 &iv,
2517 content);
2518 hx509_crypto_destroy(crypto);
2519 if (ret == 0)
2520 goto out;
2521
2522 }
2523 out:
2524 if (key.data)
2525 der_free_octet_string(&key);
2526 if (iv.data)
2527 der_free_octet_string(&iv);
2528 return ret;
2529 }
2530
2531 /*
2532 *
2533 */
2534
2535
2536 static int
2537 match_keys_rsa(hx509_cert c, hx509_private_key private_key)
2538 {
2539 const Certificate *cert;
2540 const SubjectPublicKeyInfo *spi;
2541 RSAPublicKey pk;
2542 RSA *rsa;
2543 size_t size;
2544 int ret;
2545
2546 if (private_key->private_key.rsa == NULL)
2547 return 0;
2548
2549 rsa = private_key->private_key.rsa;
2550 if (rsa->d == NULL || rsa->p == NULL || rsa->q == NULL)
2551 return 0;
2552
2553 cert = _hx509_get_cert(c);
2554 spi = &cert->tbsCertificate.subjectPublicKeyInfo;
2555
2556 rsa = RSA_new();
2557 if (rsa == NULL)
2558 return 0;
2559
2560 ret = decode_RSAPublicKey(spi->subjectPublicKey.data,
2561 spi->subjectPublicKey.length / 8,
2562 &pk, &size);
2563 if (ret) {
2564 RSA_free(rsa);
2565 return 0;
2566 }
2567 rsa->n = heim_int2BN(&pk.modulus);
2568 rsa->e = heim_int2BN(&pk.publicExponent);
2569
2570 free_RSAPublicKey(&pk);
2571
2572 rsa->d = BN_dup(private_key->private_key.rsa->d);
2573 rsa->p = BN_dup(private_key->private_key.rsa->p);
2574 rsa->q = BN_dup(private_key->private_key.rsa->q);
2575 rsa->dmp1 = BN_dup(private_key->private_key.rsa->dmp1);
2576 rsa->dmq1 = BN_dup(private_key->private_key.rsa->dmq1);
2577 rsa->iqmp = BN_dup(private_key->private_key.rsa->iqmp);
2578
2579 if (rsa->n == NULL || rsa->e == NULL ||
2580 rsa->d == NULL || rsa->p == NULL|| rsa->q == NULL ||
2581 rsa->dmp1 == NULL || rsa->dmq1 == NULL) {
2582 RSA_free(rsa);
2583 return 0;
2584 }
2585
2586 ret = RSA_check_key(rsa);
2587 RSA_free(rsa);
2588
2589 return ret == 1;
2590 }
2591
2592 static int
2593 match_keys_ec(hx509_cert c, hx509_private_key private_key)
2594 {
2595 return 1; /* XXX use EC_KEY_check_key */
2596 }
2597
2598
2599 HX509_LIB_FUNCTION int HX509_LIB_CALL
2600 _hx509_match_keys(hx509_cert c, hx509_private_key key)
2601 {
2602 if (!key->ops)
2603 return 0;
2604 if (der_heim_oid_cmp(key->ops->key_oid, ASN1_OID_ID_PKCS1_RSAENCRYPTION) == 0)
2605 return match_keys_rsa(c, key);
2606 if (der_heim_oid_cmp(key->ops->key_oid, ASN1_OID_ID_ECPUBLICKEY) == 0)
2607 return match_keys_ec(c, key);
2608 return 0;
2609
2610 }
2611
2612
2613 static const heim_oid *
2614 find_keytype(const hx509_private_key key)
2615 {
2616 const struct signature_alg *md;
2617
2618 if (key == NULL)
2619 return NULL;
2620
2621 md = _hx509_find_sig_alg(key->signature_alg);
2622 if (md == NULL)
2623 return NULL;
2624 return md->key_oid;
2625 }
2626
2627 HX509_LIB_FUNCTION int HX509_LIB_CALL
2628 hx509_crypto_select(const hx509_context context,
2629 int type,
2630 const hx509_private_key source,
2631 hx509_peer_info peer,
2632 AlgorithmIdentifier *selected)
2633 {
2634 const AlgorithmIdentifier *def = NULL;
2635 size_t i, j;
2636 int ret, bits;
2637
2638 memset(selected, 0, sizeof(*selected));
2639
2640 if (type == HX509_SELECT_DIGEST) {
2641 bits = SIG_DIGEST;
2642 if (source)
2643 def = alg_for_privatekey(source, type);
2644 if (def == NULL)
2645 def = _hx509_crypto_default_digest_alg;
2646 } else if (type == HX509_SELECT_PUBLIC_SIG) {
2647 bits = SIG_PUBLIC_SIG;
2648 /* XXX depend on `source´ and `peer´ */
2649 if (source)
2650 def = alg_for_privatekey(source, type);
2651 if (def == NULL)
2652 def = _hx509_crypto_default_sig_alg;
2653 } else if (type == HX509_SELECT_SECRET_ENC) {
2654 bits = SIG_SECRET;
2655 def = _hx509_crypto_default_secret_alg;
2656 } else {
2657 hx509_set_error_string(context, 0, EINVAL,
2658 "Unknown type %d of selection", type);
2659 return EINVAL;
2660 }
2661
2662 if (peer) {
2663 const heim_oid *keytype = NULL;
2664
2665 keytype = find_keytype(source);
2666
2667 for (i = 0; i < peer->len; i++) {
2668 for (j = 0; sig_algs[j]; j++) {
2669 if ((sig_algs[j]->flags & bits) != bits)
2670 continue;
2671 if (der_heim_oid_cmp(sig_algs[j]->sig_oid,
2672 &peer->val[i].algorithm) != 0)
2673 continue;
2674 if (keytype && sig_algs[j]->key_oid &&
2675 der_heim_oid_cmp(keytype, sig_algs[j]->key_oid))
2676 continue;
2677
2678 /* found one, use that */
2679 ret = copy_AlgorithmIdentifier(&peer->val[i], selected);
2680 if (ret)
2681 hx509_clear_error_string(context);
2682 return ret;
2683 }
2684 if (bits & SIG_SECRET) {
2685 const struct hx509cipher *cipher;
2686
2687 cipher = find_cipher_by_oid(&peer->val[i].algorithm);
2688 if (cipher == NULL)
2689 continue;
2690 if (cipher->ai_func == NULL)
2691 continue;
2692 ret = copy_AlgorithmIdentifier(cipher->ai_func(), selected);
2693 if (ret)
2694 hx509_clear_error_string(context);
2695 return ret;
2696 }
2697 }
2698 }
2699
2700 /* use default */
2701 ret = copy_AlgorithmIdentifier(def, selected);
2702 if (ret)
2703 hx509_clear_error_string(context);
2704 return ret;
2705 }
2706
2707 HX509_LIB_FUNCTION int HX509_LIB_CALL
2708 hx509_crypto_available(hx509_context context,
2709 int type,
2710 hx509_cert source,
2711 AlgorithmIdentifier **val,
2712 unsigned int *plen)
2713 {
2714 const heim_oid *keytype = NULL;
2715 unsigned int len, i;
2716 void *ptr;
2717 int bits, ret;
2718
2719 *val = NULL;
2720
2721 if (type == HX509_SELECT_ALL) {
2722 bits = SIG_DIGEST | SIG_PUBLIC_SIG | SIG_SECRET;
2723 } else if (type == HX509_SELECT_DIGEST) {
2724 bits = SIG_DIGEST;
2725 } else if (type == HX509_SELECT_PUBLIC_SIG) {
2726 bits = SIG_PUBLIC_SIG;
2727 } else {
2728 hx509_set_error_string(context, 0, EINVAL,
2729 "Unknown type %d of available", type);
2730 return EINVAL;
2731 }
2732
2733 if (source)
2734 keytype = find_keytype(_hx509_cert_private_key(source));
2735
2736 len = 0;
2737 for (i = 0; sig_algs[i]; i++) {
2738 if ((sig_algs[i]->flags & bits) == 0)
2739 continue;
2740 if (sig_algs[i]->sig_alg == NULL)
2741 continue;
2742 if (keytype && sig_algs[i]->key_oid &&
2743 der_heim_oid_cmp(sig_algs[i]->key_oid, keytype))
2744 continue;
2745
2746 /* found one, add that to the list */
2747 ptr = realloc(*val, sizeof(**val) * (len + 1));
2748 if (ptr == NULL)
2749 goto out;
2750 *val = ptr;
2751
2752 ret = copy_AlgorithmIdentifier(sig_algs[i]->sig_alg, &(*val)[len]);
2753 if (ret)
2754 goto out;
2755 len++;
2756 }
2757
2758 /* Add AES */
2759 if (bits & SIG_SECRET) {
2760
2761 for (i = 0; i < sizeof(ciphers)/sizeof(ciphers[0]); i++) {
2762
2763 if (ciphers[i].flags & CIPHER_WEAK)
2764 continue;
2765 if (ciphers[i].ai_func == NULL)
2766 continue;
2767
2768 ptr = realloc(*val, sizeof(**val) * (len + 1));
2769 if (ptr == NULL)
2770 goto out;
2771 *val = ptr;
2772
2773 ret = copy_AlgorithmIdentifier((ciphers[i].ai_func)(), &(*val)[len]);
2774 if (ret)
2775 goto out;
2776 len++;
2777 }
2778 }
2779
2780 *plen = len;
2781 return 0;
2782
2783 out:
2784 for (i = 0; i < len; i++)
2785 free_AlgorithmIdentifier(&(*val)[i]);
2786 free(*val);
2787 *val = NULL;
2788 hx509_set_error_string(context, 0, ENOMEM, "out of memory");
2789 return ENOMEM;
2790 }
2791
2792 HX509_LIB_FUNCTION void HX509_LIB_CALL
2793 hx509_crypto_free_algs(AlgorithmIdentifier *val,
2794 unsigned int len)
2795 {
2796 unsigned int i;
2797 for (i = 0; i < len; i++)
2798 free_AlgorithmIdentifier(&val[i]);
2799 free(val);
2800 }
Samba GIT mirror