]> git.saurik.com Git - apple/network_cmds.git/blob - racoon.tproj/crypto_openssl.c
projects / apple / network_cmds.git / blob
? search:


37bd1834fbae03d278356796faa503796a14f07c
[apple/network_cmds.git] / racoon.tproj / crypto_openssl.c
1 /* $KAME: crypto_openssl.c,v 1.73 2003/04/24 02:21:22 itojun Exp $ */
2
3 /*
4 * Copyright (C) 1995, 1996, 1997, and 1998 WIDE Project.
5 * All rights reserved.
6 *
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
9 * are met:
10 * 1. Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 * 2. Redistributions in binary form must reproduce the above copyright
13 * notice, this list of conditions and the following disclaimer in the
14 * documentation and/or other materials provided with the distribution.
15 * 3. Neither the name of the project nor the names of its contributors
16 * may be used to endorse or promote products derived from this software
17 * without specific prior written permission.
18 *
19 * THIS SOFTWARE IS PROVIDED BY THE PROJECT AND CONTRIBUTORS ``AS IS'' AND
20 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
21 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
22 * ARE DISCLAIMED. IN NO EVENT SHALL THE PROJECT OR CONTRIBUTORS BE LIABLE
23 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
24 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
25 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
26 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
27 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
28 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
29 * SUCH DAMAGE.
30 */
31
32 #include <sys/types.h>
33 #include <sys/param.h>
34
35 #include <stdlib.h>
36 #include <stdio.h>
37 #include <limits.h>
38 #include <string.h>
39
40 /* get openssl/ssleay version number */
41 #ifdef HAVE_OPENSSL_OPENSSLV_H
42 # include <openssl/opensslv.h>
43 #else
44 # error no opensslv.h found.
45 #endif
46
47 #ifndef OPENSSL_VERSION_NUMBER
48 #error OPENSSL_VERSION_NUMBER is not defined. OpenSSL0.9.4 or later required.
49 #endif
50
51 #ifdef HAVE_OPENSSL_PEM_H
52 #include <openssl/pem.h>
53 #endif
54 #ifdef HAVE_OPENSSL_EVP_H
55 #include <openssl/evp.h>
56 #endif
57 #ifdef HAVE_OPENSSL_X509_H
58 #include <openssl/x509.h>
59 #include <openssl/x509v3.h>
60 #include <openssl/x509_vfy.h>
61 #endif
62 #include <openssl/bn.h>
63 #include <openssl/dh.h>
64 #include <openssl/md5.h>
65 #include <openssl/sha.h>
66 #include <openssl/hmac.h>
67 #include <openssl/des.h>
68 #include <openssl/crypto.h>
69 #ifdef HAVE_OPENSSL_IDEA_H
70 #include <openssl/idea.h>
71 #endif
72 #include <openssl/blowfish.h>
73 #ifdef HAVE_OPENSSL_RC5_H
74 #include <openssl/rc5.h>
75 #endif
76 #include <openssl/cast.h>
77 #include <openssl/err.h>
78 #ifdef HAVE_OPENSSL_RIJNDAEL_H
79 #include <openssl/rijndael.h>
80 #else
81 #include "rijndael-api-fst.h"
82 #endif
83 #ifdef HAVE_OPENSSL_SHA2_H
84 #include <openssl/sha2.h>
85 #else
86 #include "sha2.h"
87 #endif
88
89 #include "var.h"
90 #include "misc.h"
91 #include "vmbuf.h"
92 #include "plog.h"
93 #include "crypto_openssl.h"
94 #include "debug.h"
95 #include "gcmalloc.h"
96
97 /*
98 * I hate to cast every parameter to des_xx into void *, but it is
99 * necessary for SSLeay/OpenSSL portability. It sucks.
100 */
101
102 #ifdef HAVE_SIGNING_C
103 static int cb_check_cert_local __P((int, X509_STORE_CTX *));
104 static int cb_check_cert_remote __P((int, X509_STORE_CTX *));
105 static X509 *mem2x509 __P((vchar_t *));
106 #endif
107
108 static caddr_t eay_hmac_init __P((vchar_t *, const EVP_MD *));
109
110 #ifdef HAVE_SIGNING_C
111 /* X509 Certificate */
112 /*
113 * convert the string of the subject name into DER
114 * e.g. str = "C=JP, ST=Kanagawa";
115 */
116 vchar_t *
117 eay_str2asn1dn(str, len)
118 char *str;
119 int len;
120 {
121 X509_NAME *name;
122 char *buf;
123 char *field, *value;
124 int i, j;
125 vchar_t *ret;
126 caddr_t p;
127
128 buf = racoon_malloc(len + 1);
129 if (!buf) {
130 printf("failed to allocate buffer\n");
131 return NULL;
132 }
133 memcpy(buf, str, len);
134
135 name = X509_NAME_new();
136
137 field = &buf[0];
138 value = NULL;
139 for (i = 0; i < len; i++) {
140 if (!value && buf[i] == '=') {
141 buf[i] = '\0';
142 value = &buf[i + 1];
143 continue;
144 } else if (buf[i] == ',' || buf[i] == '/') {
145 buf[i] = '\0';
146 #if 0
147 printf("[%s][%s]\n", field, value);
148 #endif
149 if (!X509_NAME_add_entry_by_txt(name, field,
150 MBSTRING_ASC, value, -1, -1, 0))
151 goto err;
152 for (j = i + 1; j < len; j++) {
153 if (buf[j] != ' ')
154 break;
155 }
156 field = &buf[j];
157 value = NULL;
158 continue;
159 }
160 }
161 buf[len] = '\0';
162 #if 0
163 printf("[%s][%s]\n", field, value);
164 #endif
165 if (!X509_NAME_add_entry_by_txt(name, field,
166 MBSTRING_ASC, value, -1, -1, 0))
167 goto err;
168
169 i = i2d_X509_NAME(name, NULL);
170 if (!i)
171 goto err;
172 ret = vmalloc(i);
173 if (!ret)
174 goto err;
175 p = ret->v;
176 i = i2d_X509_NAME(name, (unsigned char **)&p);
177 if (!i)
178 goto err;
179
180 return ret;
181
182 err:
183 if (buf)
184 racoon_free(buf);
185 if (name)
186 X509_NAME_free(name);
187 return NULL;
188 }
189
190 /*
191 * compare two subjectNames.
192 * OUT: 0: equal
193 * positive:
194 * -1: other error.
195 */
196 int
197 eay_cmp_asn1dn(n1, n2)
198 vchar_t *n1, *n2;
199 {
200 X509_NAME *a = NULL, *b = NULL;
201 caddr_t p;
202 int i = -1;
203
204 p = n1->v;
205 if (!d2i_X509_NAME(&a, (unsigned char **)&p, n1->l))
206 goto end;
207 p = n2->v;
208 if (!d2i_X509_NAME(&b, (unsigned char **)&p, n2->l))
209 goto end;
210
211 i = X509_NAME_cmp(a, b);
212
213 end:
214 if (a)
215 X509_NAME_free(a);
216 if (b)
217 X509_NAME_free(b);
218 return i;
219 }
220
221 /*
222 * this functions is derived from apps/verify.c in OpenSSL0.9.5
223 */
224 int
225 eay_check_x509cert(cert, CApath, local)
226 vchar_t *cert;
227 char *CApath;
228 int local;
229 {
230 X509_STORE *cert_ctx = NULL;
231 X509_LOOKUP *lookup = NULL;
232 X509 *x509 = NULL;
233 #if OPENSSL_VERSION_NUMBER >= 0x00905100L
234 X509_STORE_CTX *csc;
235 #else
236 X509_STORE_CTX csc;
237 #endif
238 int error = -1;
239
240 /* XXX define only functions required. */
241 #if OPENSSL_VERSION_NUMBER >= 0x00905100L
242 OpenSSL_add_all_algorithms();
243 #else
244 SSLeay_add_all_algorithms();
245 #endif
246
247 cert_ctx = X509_STORE_new();
248 if (cert_ctx == NULL)
249 goto end;
250
251 if (local)
252 X509_STORE_set_verify_cb_func(cert_ctx, cb_check_cert_local);
253 else
254 X509_STORE_set_verify_cb_func(cert_ctx, cb_check_cert_remote);
255
256 lookup = X509_STORE_add_lookup(cert_ctx, X509_LOOKUP_file());
257 if (lookup == NULL)
258 goto end;
259 X509_LOOKUP_load_file(lookup, NULL, X509_FILETYPE_DEFAULT); /* XXX */
260
261 lookup = X509_STORE_add_lookup(cert_ctx, X509_LOOKUP_hash_dir());
262 if (lookup == NULL)
263 goto end;
264 error = X509_LOOKUP_add_dir(lookup, CApath, X509_FILETYPE_PEM);
265 if(!error) {
266 error = -1;
267 goto end;
268 }
269 error = -1; /* initialized */
270
271 /* read the certificate to be verified */
272 x509 = mem2x509(cert);
273 if (x509 == NULL)
274 goto end;
275
276 #if OPENSSL_VERSION_NUMBER >= 0x00905100L
277 csc = X509_STORE_CTX_new();
278 if (csc == NULL)
279 goto end;
280 X509_STORE_CTX_init(csc, cert_ctx, x509, NULL);
281
282 #if OPENSSL_VERSION_NUMBER >= 0x00907000L
283 X509_STORE_CTX_set_flags(csc, X509_V_FLAG_CRL_CHECK);
284 X509_STORE_CTX_set_flags(csc, X509_V_FLAG_CRL_CHECK_ALL);
285 #endif
286
287 error = X509_verify_cert(csc);
288 X509_STORE_CTX_cleanup(csc);
289 #else
290 X509_STORE_CTX_init(&csc, cert_ctx, x509, NULL);
291 error = X509_verify_cert(&csc);
292 X509_STORE_CTX_cleanup(&csc);
293 #endif
294
295 /*
296 * if x509_verify_cert() is successful then the value of error is
297 * set non-zero.
298 */
299 error = error ? 0 : -1;
300
301 end:
302 if (error)
303 printf("%s\n", eay_strerror());
304 if (cert_ctx != NULL)
305 X509_STORE_free(cert_ctx);
306 if (x509 != NULL)
307 X509_free(x509);
308
309 return(error);
310 }
311
312 /*
313 * callback function for verifing certificate.
314 * Derived from cb() in openssl/apps/s_server.c
315 *
316 * This one is called for certificates obtained from
317 * 'peers_certfile' directive.
318 */
319 static int
320 cb_check_cert_local(ok, ctx)
321 int ok;
322 X509_STORE_CTX *ctx;
323 {
324 char buf[256];
325 int log_tag;
326
327 if (!ok) {
328 X509_NAME_oneline(
329 X509_get_subject_name(ctx->current_cert),
330 buf,
331 256);
332 /*
333 * since we are just checking the certificates, it is
334 * ok if they are self signed. But we should still warn
335 * the user.
336 */
337 switch (ctx->error) {
338 case X509_V_ERR_CERT_HAS_EXPIRED:
339 case X509_V_ERR_DEPTH_ZERO_SELF_SIGNED_CERT:
340 #if OPENSSL_VERSION_NUMBER >= 0x00905100L
341 case X509_V_ERR_INVALID_PURPOSE:
342 case X509_V_ERR_UNABLE_TO_GET_CRL:
343 #endif
344 ok = 1;
345 log_tag = LLV_WARNING;
346 break;
347
348 default:
349 log_tag = LLV_ERROR;
350 }
351
352
353 #ifndef EAYDEBUG
354 plog(log_tag, LOCATION, NULL,
355 "%s(%d) at depth:%d SubjectName:%s\n",
356 X509_verify_cert_error_string(ctx->error),
357 ctx->error,
358 ctx->error_depth,
359 buf);
360 #else
361 printf("%d: %s(%d) at depth:%d SubjectName:%s\n",
362 log_tag,
363 X509_verify_cert_error_string(ctx->error),
364 ctx->error,
365 ctx->error_depth,
366 buf);
367 #endif
368 }
369 ERR_clear_error();
370
371 return ok;
372 }
373
374 /*
375 * Similar to cb_check_cert_local() but this one is called
376 * for certificates obtained from the IKE payload.
377 */
378 static int
379 cb_check_cert_remote(ok, ctx)
380 int ok;
381 X509_STORE_CTX *ctx;
382 {
383 char buf[256];
384 int log_tag;
385
386 if (!ok) {
387 X509_NAME_oneline(
388 X509_get_subject_name(ctx->current_cert),
389 buf,
390 256);
391 switch (ctx->error) {
392 case X509_V_ERR_UNABLE_TO_GET_CRL:
393 ok = 1;
394 log_tag = LLV_WARNING;
395 break;
396 default:
397 log_tag = LLV_ERROR;
398 }
399 #ifndef EAYDEBUG
400 plog(log_tag, LOCATION, NULL,
401 "%s(%d) at depth:%d SubjectName:%s\n",
402 X509_verify_cert_error_string(ctx->error),
403 ctx->error,
404 ctx->error_depth,
405 buf);
406 #else
407 printf("%d: %s(%d) at depth:%d SubjectName:%s\n",
408 log_tag,
409 X509_verify_cert_error_string(ctx->error),
410 ctx->error,
411 ctx->error_depth,
412 buf);
413 #endif
414 }
415 ERR_clear_error();
416
417 return ok;
418 }
419
420 /*
421 * get a subjectAltName from X509 certificate.
422 */
423 vchar_t *
424 eay_get_x509asn1subjectname(cert)
425 vchar_t *cert;
426 {
427 X509 *x509 = NULL;
428 u_char *bp;
429 vchar_t *name = NULL;
430 int len;
431 int error = -1;
432
433 bp = cert->v;
434
435 x509 = mem2x509(cert);
436 if (x509 == NULL)
437 goto end;
438
439 /* get the length of the name */
440 len = i2d_X509_NAME(x509->cert_info->subject, NULL);
441 name = vmalloc(len);
442 if (!name)
443 goto end;
444 /* get the name */
445 bp = name->v;
446 len = i2d_X509_NAME(x509->cert_info->subject, &bp);
447
448 error = 0;
449
450 end:
451 if (error) {
452 #ifndef EAYDEBUG
453 plog(LLV_ERROR, LOCATION, NULL, "%s\n", eay_strerror());
454 #else
455 printf("%s\n", eay_strerror());
456 #endif
457 if (name) {
458 vfree(name);
459 name = NULL;
460 }
461 }
462 if (x509)
463 X509_free(x509);
464
465 return name;
466 }
467
468 /*
469 * Get the common name from a cert
470 */
471 #define EAY_MAX_CN_LEN 256
472 vchar_t *
473 eay_get_x509_common_name(cert)
474 vchar_t *cert;
475 {
476 X509 *x509 = NULL;
477 X509_NAME *name;
478 vchar_t *commonName = NULL;
479
480 commonName = vmalloc(EAY_MAX_CN_LEN);
481 if (commonName == NULL) {
482 plog(LLV_ERROR, LOCATION, NULL, "no memory\n");
483 return NULL;
484 }
485
486 x509 = mem2x509(cert);
487 if (x509 == NULL) {
488 vfree(commonName);
489 return NULL;
490 }
491
492 name = X509_get_subject_name(x509);
493 X509_NAME_get_text_by_NID(name, NID_commonName, commonName->v, EAY_MAX_CN_LEN);
494
495 commonName->l = strlen(commonName->v);
496
497 if (x509)
498 X509_free(x509);
499 return commonName;
500 }
501
502 /*
503 * get the subjectAltName from X509 certificate.
504 * the name must be terminated by '\0'.
505 */
506 int
507 eay_get_x509subjectaltname(cert, altname, type, pos, len)
508 vchar_t *cert;
509 char **altname;
510 int *type;
511 int pos;
512 int *len;
513 {
514 X509 *x509 = NULL;
515 int i;
516 GENERAL_NAMES *gens;
517 GENERAL_NAME *gen;
518 int error = -1;
519
520 *altname = NULL;
521 *type = GENT_OTHERNAME;
522
523 x509 = mem2x509(cert);
524 if (x509 == NULL)
525 goto end;
526
527 gens = X509_get_ext_d2i(x509, NID_subject_alt_name, NULL, NULL);
528 if (gens == NULL)
529 goto end;
530
531 for (i = 0; i < sk_GENERAL_NAME_num(gens); i++) {
532 if (i + 1 != pos)
533 continue;
534 break;
535 }
536
537 /* there is no data at "pos" */
538 if (i == sk_GENERAL_NAME_num(gens))
539 goto end;
540
541 gen = sk_GENERAL_NAME_value(gens, i);
542
543 /* make sure the data is terminated by '\0'. */
544 if (gen->d.ia5->data[gen->d.ia5->length] != '\0') {
545 #ifndef EAYDEBUG
546 plog(LLV_ERROR, LOCATION, NULL,
547 "data is not terminated by '\0'.");
548 #endif
549 hexdump(gen->d.ia5->data, gen->d.ia5->length + 1);
550 goto end;
551 }
552
553 *len = gen->d.ia5->length + 1;
554 *altname = racoon_malloc(*len);
555 if (!*altname)
556 goto end;
557
558 strlcpy(*altname, gen->d.ia5->data, *len);
559 *type = gen->type;
560
561 error = 0;
562
563 end:
564 if (error) {
565 if (*altname) {
566 racoon_free(*altname);
567 *altname = NULL;
568 }
569 #ifndef EAYDEBUG
570 plog(LLV_ERROR, LOCATION, NULL, "%s\n", eay_strerror());
571 #else
572 printf("%s\n", eay_strerror());
573 #endif
574 }
575 if (x509)
576 X509_free(x509);
577
578 return error;
579 }
580
581
582 /*
583 * decode a X509 certificate and make a readable text terminated '\n'.
584 * return the buffer allocated, so must free it later.
585 */
586 char *
587 eay_get_x509text(cert)
588 vchar_t *cert;
589 {
590 X509 *x509 = NULL;
591 BIO *bio = NULL;
592 char *text = NULL;
593 u_char *bp = NULL;
594 int len = 0;
595 int error = -1;
596
597 x509 = mem2x509(cert);
598 if (x509 == NULL)
599 goto end;
600
601 bio = BIO_new(BIO_s_mem());
602 if (bio == NULL)
603 goto end;
604
605 error = X509_print(bio, x509);
606 if (error != 1) {
607 error = -1;
608 goto end;
609 }
610
611 len = BIO_get_mem_data(bio, &bp);
612 text = racoon_malloc(len + 1);
613 if (text == NULL)
614 goto end;
615 memcpy(text, bp, len);
616 text[len] = '\0';
617
618 error = 0;
619
620 end:
621 if (error) {
622 if (text) {
623 racoon_free(text);
624 text = NULL;
625 }
626 #ifndef EAYDEBUG
627 plog(LLV_ERROR, LOCATION, NULL, "%s\n", eay_strerror());
628 #else
629 printf("%s\n", eay_strerror());
630 #endif
631 }
632 if (bio)
633 BIO_free(bio);
634 if (x509)
635 X509_free(x509);
636
637 return text;
638 }
639
640 /* get X509 structure from buffer. */
641 static X509 *
642 mem2x509(cert)
643 vchar_t *cert;
644 {
645 X509 *x509;
646
647 #ifndef EAYDEBUG
648 {
649 u_char *bp;
650
651 bp = cert->v;
652
653 x509 = d2i_X509(NULL, &bp, cert->l);
654 }
655 #else
656 {
657 BIO *bio;
658 int len;
659
660 bio = BIO_new(BIO_s_mem());
661 if (bio == NULL)
662 return NULL;
663 len = BIO_write(bio, cert->v, cert->l);
664 if (len == -1)
665 return NULL;
666 x509 = PEM_read_bio_X509(bio, NULL, NULL, NULL);
667 BIO_free(bio);
668 }
669 #endif
670 return x509;
671 }
672
673 /*
674 * get a X509 certificate from local file.
675 * a certificate must be PEM format.
676 * Input:
677 * path to a certificate.
678 * Output:
679 * NULL if error occured
680 * other is the cert.
681 */
682 vchar_t *
683 eay_get_x509cert(path)
684 char *path;
685 {
686 FILE *fp;
687 X509 *x509;
688 vchar_t *cert;
689 u_char *bp;
690 int len;
691 int error;
692
693 /* Read private key */
694 fp = fopen(path, "r");
695 if (fp == NULL)
696 return NULL;
697 #if OPENSSL_VERSION_NUMBER >= 0x00904100L
698 x509 = PEM_read_X509(fp, NULL, NULL, NULL);
699 #else
700 x509 = PEM_read_X509(fp, NULL, NULL);
701 #endif
702 fclose (fp);
703
704 if (x509 == NULL)
705 return NULL;
706
707 len = i2d_X509(x509, NULL);
708 cert = vmalloc(len);
709 if (cert == NULL) {
710 X509_free(x509);
711 return NULL;
712 }
713 bp = cert->v;
714 error = i2d_X509(x509, &bp);
715 X509_free(x509);
716
717 if (error == 0)
718 return NULL;
719
720 return cert;
721 }
722
723 /*
724 * sign a souce by X509 signature.
725 * XXX: to be get hash type from my cert ?
726 * to be handled EVP_dss().
727 */
728 vchar_t *
729 eay_get_x509sign(source, privkey, cert)
730 vchar_t *source;
731 vchar_t *privkey;
732 vchar_t *cert;
733 {
734 vchar_t *sig = NULL;
735
736 sig = eay_rsa_sign(source, privkey);
737
738 return sig;
739 }
740
741 /*
742 * check a X509 signature
743 * XXX: to be get hash type from my cert ?
744 * to be handled EVP_dss().
745 * OUT: return -1 when error.
746 * 0
747 */
748 int
749 eay_check_x509sign(source, sig, cert)
750 vchar_t *source;
751 vchar_t *sig;
752 vchar_t *cert;
753 {
754 X509 *x509;
755 u_char *bp;
756 EVP_PKEY *evp;
757
758 bp = cert->v;
759
760 x509 = d2i_X509(NULL, &bp, cert->l);
761 if (x509 == NULL) {
762 #ifndef EAYDEBUG
763 plog(LLV_ERROR, LOCATION, NULL, "%s\n", eay_strerror());
764 #endif
765 return -1;
766 }
767
768 evp = X509_get_pubkey(x509);
769 if (!evp) {
770 #ifndef EAYDEBUG
771 plog(LLV_ERROR, LOCATION, NULL, "X509_get_pubkey: %s\n", eay_strerror());
772 #endif
773 return -1;
774 }
775
776 return eay_rsa_verify(source, sig, evp);
777 }
778
779 /*
780 * check a signature by signed with PKCS7 certificate.
781 * XXX: to be get hash type from my cert ?
782 * to be handled EVP_dss().
783 * OUT: return -1 when error.
784 * 0
785 */
786 int
787 eay_check_pkcs7sign(source, sig, cert)
788 vchar_t *source;
789 vchar_t *sig;
790 vchar_t *cert;
791 {
792 X509 *x509;
793 EVP_MD_CTX md_ctx;
794 EVP_PKEY *evp;
795 int error;
796 BIO *bio = BIO_new(BIO_s_mem());
797 char *bp;
798
799 if (bio == NULL)
800 return -1;
801 error = BIO_write(bio, cert->v, cert->l);
802 if (error != cert->l)
803 return -1;
804
805 bp = cert->v;
806 x509 = PEM_read_bio_X509(bio, NULL, NULL, NULL);
807 BIO_free(bio);
808 if (x509 == NULL)
809 return -1;
810
811 evp = X509_get_pubkey(x509);
812 X509_free(x509);
813 if (evp == NULL)
814 return -1;
815
816 /* Verify the signature */
817 /* XXX: to be handled EVP_dss() */
818 EVP_VerifyInit(&md_ctx, EVP_sha1());
819 EVP_VerifyUpdate(&md_ctx, source->v, source->l);
820 error = EVP_VerifyFinal(&md_ctx, sig->v, sig->l, evp);
821
822 EVP_PKEY_free(evp);
823
824 if (error != 1)
825 return -1;
826
827 return 0;
828 }
829
830 /*
831 * get PKCS#1 Private Key of PEM format from local file.
832 */
833 vchar_t *
834 eay_get_pkcs1privkey(path)
835 char *path;
836 {
837 FILE *fp;
838 EVP_PKEY *evp = NULL;
839 vchar_t *pkey = NULL;
840 u_char *bp;
841 int pkeylen;
842 int error = -1;
843
844 /* Read private key */
845 fp = fopen(path, "r");
846 if (fp == NULL)
847 return NULL;
848
849 #if OPENSSL_VERSION_NUMBER >= 0x00904100L
850 evp = PEM_read_PrivateKey(fp, NULL, NULL, NULL);
851 #else
852 evp = PEM_read_PrivateKey(fp, NULL, NULL);
853 #endif
854 fclose (fp);
855
856 if (evp == NULL)
857 return NULL;
858
859 pkeylen = i2d_PrivateKey(evp, NULL);
860 if (pkeylen == 0)
861 goto end;
862 pkey = vmalloc(pkeylen);
863 if (pkey == NULL)
864 goto end;
865 bp = pkey->v;
866 pkeylen = i2d_PrivateKey(evp, &bp);
867 if (pkeylen == 0)
868 goto end;
869
870 error = 0;
871
872 end:
873 if (evp != NULL)
874 EVP_PKEY_free(evp);
875 if (error != 0 && pkey != NULL) {
876 vfree(pkey);
877 pkey = NULL;
878 }
879
880 return pkey;
881 }
882
883 /*
884 * get PKCS#1 Public Key of PEM format from local file.
885 */
886 vchar_t *
887 eay_get_pkcs1pubkey(path)
888 char *path;
889 {
890 FILE *fp;
891 EVP_PKEY *evp = NULL;
892 vchar_t *pkey = NULL;
893 X509 *x509 = NULL;
894 u_char *bp;
895 int pkeylen;
896 int error = -1;
897
898 /* Read private key */
899 fp = fopen(path, "r");
900 if (fp == NULL)
901 return NULL;
902
903 #if OPENSSL_VERSION_NUMBER >= 0x00904100L
904 x509 = PEM_read_X509(fp, NULL, NULL, NULL);
905 #else
906 x509 = PEM_read_X509(fp, NULL, NULL);
907 #endif
908 fclose (fp);
909
910 if (x509 == NULL)
911 return NULL;
912
913 /* Get public key - eay */
914 evp = X509_get_pubkey(x509);
915 if (evp == NULL)
916 return NULL;
917
918 pkeylen = i2d_PublicKey(evp, NULL);
919 if (pkeylen == 0)
920 goto end;
921 pkey = vmalloc(pkeylen);
922 if (pkey == NULL)
923 goto end;
924 bp = pkey->v;
925 pkeylen = i2d_PublicKey(evp, &bp);
926 if (pkeylen == 0)
927 goto end;
928
929 error = 0;
930 end:
931 if (evp != NULL)
932 EVP_PKEY_free(evp);
933 if (error != 0 && pkey != NULL) {
934 vfree(pkey);
935 pkey = NULL;
936 }
937
938 return pkey;
939 }
940 #endif
941
942 vchar_t *
943 eay_rsa_sign(src, privkey)
944 vchar_t *src, *privkey;
945 {
946 EVP_PKEY *evp;
947 u_char *bp = privkey->v;
948 vchar_t *sig = NULL;
949 int len;
950 int pad = RSA_PKCS1_PADDING;
951
952 /* XXX to be handled EVP_PKEY_DSA */
953 evp = d2i_PrivateKey(EVP_PKEY_RSA, NULL, &bp, privkey->l);
954 if (evp == NULL)
955 return NULL;
956
957 /* XXX: to be handled EVP_dss() */
958 /* XXX: Where can I get such parameters ? From my cert ? */
959
960 len = RSA_size(evp->pkey.rsa);
961
962 sig = vmalloc(len);
963 if (sig == NULL)
964 return NULL;
965
966 len = RSA_private_encrypt(src->l, src->v, sig->v, evp->pkey.rsa, pad);
967 EVP_PKEY_free(evp);
968 if (len == 0 || len != sig->l) {
969 vfree(sig);
970 sig = NULL;
971 }
972
973 return sig;
974 }
975
976 int
977 eay_rsa_verify(src, sig, evp)
978 vchar_t *src, *sig;
979 EVP_PKEY *evp;
980 {
981 vchar_t *xbuf = NULL;
982 int pad = RSA_PKCS1_PADDING;
983 int len = 0;
984 int error;
985
986 len = RSA_size(evp->pkey.rsa);
987
988 xbuf = vmalloc(len);
989 if (xbuf == NULL) {
990 #ifndef EAYDEBUG
991 plog(LLV_ERROR, LOCATION, NULL, "%s\n", eay_strerror());
992 #endif
993 EVP_PKEY_free(evp);
994 return -1;
995 }
996
997 len = RSA_public_decrypt(sig->l, sig->v, xbuf->v, evp->pkey.rsa, pad);
998 #ifndef EAYDEBUG
999 if (len == 0 || len != src->l)
1000 plog(LLV_ERROR, LOCATION, NULL, "%s\n", eay_strerror());
1001 #endif
1002 EVP_PKEY_free(evp);
1003 if (len == 0 || len != src->l) {
1004 vfree(xbuf);
1005 return -1;
1006 }
1007
1008 error = memcmp(src->v, xbuf->v, src->l);
1009 vfree(xbuf);
1010 if (error != 0)
1011 return -1;
1012
1013 return 0;
1014 }
1015
1016 /*
1017 * get error string
1018 * MUST load ERR_load_crypto_strings() first.
1019 */
1020 char *
1021 eay_strerror()
1022 {
1023 static char ebuf[512];
1024 int len = 0, n;
1025 unsigned long l;
1026 char buf[200];
1027 #if OPENSSL_VERSION_NUMBER >= 0x00904100L
1028 const char *file, *data;
1029 #else
1030 char *file, *data;
1031 #endif
1032 int line, flags;
1033 unsigned long es;
1034
1035 es = CRYPTO_thread_id();
1036
1037 while ((l = ERR_get_error_line_data(&file, &line, &data, &flags)) != 0){
1038 n = snprintf(ebuf + len, sizeof(ebuf) - len,
1039 "%lu:%s:%s:%d:%s ",
1040 es, ERR_error_string(l, buf), file, line,
1041 (flags & ERR_TXT_STRING) ? data : "");
1042 if (n < 0 || n >= sizeof(ebuf) - len)
1043 break;
1044 len += n;
1045 if (sizeof(ebuf) < len)
1046 break;
1047 }
1048
1049 return ebuf;
1050 }
1051
1052 void
1053 eay_init_error()
1054 {
1055 ERR_load_crypto_strings();
1056 }
1057
1058 /*
1059 * DES-CBC
1060 */
1061 vchar_t *
1062 eay_des_encrypt(data, key, iv)
1063 vchar_t *data, *key, *iv;
1064 {
1065 vchar_t *res;
1066 des_key_schedule ks;
1067
1068 if (des_key_sched((void *)key->v, ks) != 0)
1069 return NULL;
1070
1071 /* allocate buffer for result */
1072 if ((res = vmalloc(data->l)) == NULL)
1073 return NULL;
1074
1075 /* decryption data */
1076 des_cbc_encrypt((void *)data->v, (void *)res->v, data->l,
1077 ks, (void *)iv->v, DES_ENCRYPT);
1078
1079 return res;
1080 }
1081
1082 vchar_t *
1083 eay_des_decrypt(data, key, iv)
1084 vchar_t *data, *key, *iv;
1085 {
1086 vchar_t *res;
1087 des_key_schedule ks;
1088
1089 if (des_key_sched((void *)key->v, ks) != 0)
1090 return NULL;
1091
1092 /* allocate buffer for result */
1093 if ((res = vmalloc(data->l)) == NULL)
1094 return NULL;
1095
1096 /* decryption data */
1097 des_cbc_encrypt((void *)data->v, (void *)res->v, data->l,
1098 ks, (void *)iv->v, DES_DECRYPT);
1099
1100 return res;
1101 }
1102
1103 int
1104 eay_des_weakkey(key)
1105 vchar_t *key;
1106 {
1107 return des_is_weak_key((void *)key->v);
1108 }
1109
1110 int
1111 eay_des_keylen(len)
1112 int len;
1113 {
1114 if (len != 0 && len != 64)
1115 return -1;
1116 return 64;
1117 }
1118
1119 #ifdef HAVE_OPENSSL_IDEA_H
1120 /*
1121 * IDEA-CBC
1122 */
1123 vchar_t *
1124 eay_idea_encrypt(data, key, iv)
1125 vchar_t *data, *key, *iv;
1126 {
1127 vchar_t *res;
1128 IDEA_KEY_SCHEDULE ks;
1129
1130 idea_set_encrypt_key(key->v, &ks);
1131
1132 /* allocate buffer for result */
1133 if ((res = vmalloc(data->l)) == NULL)
1134 return NULL;
1135
1136 /* decryption data */
1137 idea_cbc_encrypt(data->v, res->v, data->l,
1138 &ks, iv->v, IDEA_ENCRYPT);
1139
1140 return res;
1141 }
1142
1143 vchar_t *
1144 eay_idea_decrypt(data, key, iv)
1145 vchar_t *data, *key, *iv;
1146 {
1147 vchar_t *res;
1148 IDEA_KEY_SCHEDULE ks, dks;
1149
1150 idea_set_encrypt_key(key->v, &ks);
1151 idea_set_decrypt_key(&ks, &dks);
1152
1153 /* allocate buffer for result */
1154 if ((res = vmalloc(data->l)) == NULL)
1155 return NULL;
1156
1157 /* decryption data */
1158 idea_cbc_encrypt(data->v, res->v, data->l,
1159 &dks, iv->v, IDEA_DECRYPT);
1160
1161 return res;
1162 }
1163
1164 int
1165 eay_idea_weakkey(key)
1166 vchar_t *key;
1167 {
1168 return 0; /* XXX */
1169 }
1170
1171 int
1172 eay_idea_keylen(len)
1173 int len;
1174 {
1175 if (len != 0 && len != 128)
1176 return -1;
1177 return 128;
1178 }
1179 #endif
1180
1181 /*
1182 * BLOWFISH-CBC
1183 */
1184 vchar_t *
1185 eay_bf_encrypt(data, key, iv)
1186 vchar_t *data, *key, *iv;
1187 {
1188 vchar_t *res;
1189 BF_KEY ks;
1190
1191 BF_set_key(&ks, key->l, key->v);
1192
1193 /* allocate buffer for result */
1194 if ((res = vmalloc(data->l)) == NULL)
1195 return NULL;
1196
1197 /* decryption data */
1198 BF_cbc_encrypt(data->v, res->v, data->l,
1199 &ks, iv->v, BF_ENCRYPT);
1200
1201 return res;
1202 }
1203
1204 vchar_t *
1205 eay_bf_decrypt(data, key, iv)
1206 vchar_t *data, *key, *iv;
1207 {
1208 vchar_t *res;
1209 BF_KEY ks;
1210
1211 BF_set_key(&ks, key->l, key->v);
1212
1213 /* allocate buffer for result */
1214 if ((res = vmalloc(data->l)) == NULL)
1215 return NULL;
1216
1217 /* decryption data */
1218 BF_cbc_encrypt(data->v, res->v, data->l,
1219 &ks, iv->v, BF_DECRYPT);
1220
1221 return res;
1222 }
1223
1224 int
1225 eay_bf_weakkey(key)
1226 vchar_t *key;
1227 {
1228 return 0; /* XXX to be done. refer to RFC 2451 */
1229 }
1230
1231 int
1232 eay_bf_keylen(len)
1233 int len;
1234 {
1235 if (len == 0)
1236 return 448;
1237 if (len < 40 || len > 448)
1238 return -1;
1239 return (len + 7) / 8;
1240 }
1241
1242 #ifdef HAVE_OPENSSL_RC5_H
1243 /*
1244 * RC5-CBC
1245 */
1246 vchar_t *
1247 eay_rc5_encrypt(data, key, iv)
1248 vchar_t *data, *key, *iv;
1249 {
1250 vchar_t *res;
1251 RC5_32_KEY ks;
1252
1253 /* in RFC 2451, there is information about the number of round. */
1254 RC5_32_set_key(&ks, key->l, key->v, 16);
1255
1256 /* allocate buffer for result */
1257 if ((res = vmalloc(data->l)) == NULL)
1258 return NULL;
1259
1260 /* decryption data */
1261 RC5_32_cbc_encrypt(data->v, res->v, data->l,
1262 &ks, iv->v, RC5_ENCRYPT);
1263
1264 return res;
1265 }
1266
1267 vchar_t *
1268 eay_rc5_decrypt(data, key, iv)
1269 vchar_t *data, *key, *iv;
1270 {
1271 vchar_t *res;
1272 RC5_32_KEY ks;
1273
1274 /* in RFC 2451, there is information about the number of round. */
1275 RC5_32_set_key(&ks, key->l, key->v, 16);
1276
1277 /* allocate buffer for result */
1278 if ((res = vmalloc(data->l)) == NULL)
1279 return NULL;
1280
1281 /* decryption data */
1282 RC5_32_cbc_encrypt(data->v, res->v, data->l,
1283 &ks, iv->v, RC5_DECRYPT);
1284
1285 return res;
1286 }
1287
1288 int
1289 eay_rc5_weakkey(key)
1290 vchar_t *key;
1291 {
1292 return 0; /* No known weak keys when used with 16 rounds. */
1293
1294 }
1295
1296 int
1297 eay_rc5_keylen(len)
1298 int len;
1299 {
1300 if (len == 0)
1301 return 128;
1302 if (len < 40 || len > 2040)
1303 return -1;
1304 return (len + 7) / 8;
1305 }
1306 #endif
1307
1308 /*
1309 * 3DES-CBC
1310 */
1311 vchar_t *
1312 eay_3des_encrypt(data, key, iv)
1313 vchar_t *data, *key, *iv;
1314 {
1315 vchar_t *res;
1316 des_key_schedule ks1, ks2, ks3;
1317
1318 if (key->l < 24)
1319 return NULL;
1320
1321 if (des_key_sched((void *)key->v, ks1) != 0)
1322 return NULL;
1323 if (des_key_sched((void *)(key->v + 8), ks2) != 0)
1324 return NULL;
1325 if (des_key_sched((void *)(key->v + 16), ks3) != 0)
1326 return NULL;
1327
1328 /* allocate buffer for result */
1329 if ((res = vmalloc(data->l)) == NULL)
1330 return NULL;
1331
1332 /* decryption data */
1333 des_ede3_cbc_encrypt((void *)data->v, (void *)res->v, data->l,
1334 ks1, ks2, ks3, (void *)iv->v, DES_ENCRYPT);
1335
1336 return res;
1337 }
1338
1339 vchar_t *
1340 eay_3des_decrypt(data, key, iv)
1341 vchar_t *data, *key, *iv;
1342 {
1343 vchar_t *res;
1344 des_key_schedule ks1, ks2, ks3;
1345
1346 if (key->l < 24)
1347 return NULL;
1348
1349 if (des_key_sched((void *)key->v, ks1) != 0)
1350 return NULL;
1351 if (des_key_sched((void *)(key->v + 8), ks2) != 0)
1352 return NULL;
1353 if (des_key_sched((void *)(key->v + 16), ks3) != 0)
1354 return NULL;
1355
1356 /* allocate buffer for result */
1357 if ((res = vmalloc(data->l)) == NULL)
1358 return NULL;
1359
1360 /* decryption data */
1361 des_ede3_cbc_encrypt((void *)data->v, (void *)res->v, data->l,
1362 ks1, ks2, ks3, (void *)iv->v, DES_DECRYPT);
1363
1364 return res;
1365 }
1366
1367 int
1368 eay_3des_weakkey(key)
1369 vchar_t *key;
1370 {
1371 if (key->l < 24)
1372 return NULL;
1373
1374 return (des_is_weak_key((void *)key->v)
1375 || des_is_weak_key((void *)(key->v + 8))
1376 || des_is_weak_key((void *)(key->v + 16)));
1377 }
1378
1379 int
1380 eay_3des_keylen(len)
1381 int len;
1382 {
1383 if (len != 0 && len != 192)
1384 return -1;
1385 return 192;
1386 }
1387
1388 /*
1389 * CAST-CBC
1390 */
1391 vchar_t *
1392 eay_cast_encrypt(data, key, iv)
1393 vchar_t *data, *key, *iv;
1394 {
1395 vchar_t *res;
1396 CAST_KEY ks;
1397
1398 CAST_set_key(&ks, key->l, key->v);
1399
1400 /* allocate buffer for result */
1401 if ((res = vmalloc(data->l)) == NULL)
1402 return NULL;
1403
1404 /* decryption data */
1405 CAST_cbc_encrypt(data->v, res->v, data->l,
1406 &ks, iv->v, DES_ENCRYPT);
1407
1408 return res;
1409 }
1410
1411 vchar_t *
1412 eay_cast_decrypt(data, key, iv)
1413 vchar_t *data, *key, *iv;
1414 {
1415 vchar_t *res;
1416 CAST_KEY ks;
1417
1418 CAST_set_key(&ks, key->l, key->v);
1419
1420 /* allocate buffer for result */
1421 if ((res = vmalloc(data->l)) == NULL)
1422 return NULL;
1423
1424 /* decryption data */
1425 CAST_cbc_encrypt(data->v, res->v, data->l,
1426 &ks, iv->v, DES_DECRYPT);
1427
1428 return res;
1429 }
1430
1431 int
1432 eay_cast_weakkey(key)
1433 vchar_t *key;
1434 {
1435 return 0; /* No known weak keys. */
1436 }
1437
1438 int
1439 eay_cast_keylen(len)
1440 int len;
1441 {
1442 if (len == 0)
1443 return 128;
1444 if (len < 40 || len > 128)
1445 return -1;
1446 return (len + 7) / 8;
1447 }
1448
1449 /*
1450 * AES(RIJNDAEL)-CBC
1451 */
1452 vchar_t *
1453 eay_aes_encrypt(data, key, iv)
1454 vchar_t *data, *key, *iv;
1455 {
1456 vchar_t *res;
1457 keyInstance k;
1458 cipherInstance c;
1459
1460 memset(&k, 0, sizeof(k));
1461 if (rijndael_makeKey(&k, DIR_ENCRYPT, key->l << 3, key->v) < 0)
1462 return NULL;
1463
1464 /* allocate buffer for result */
1465 if ((res = vmalloc(data->l)) == NULL)
1466 return NULL;
1467
1468 /* encryption data */
1469 memset(&c, 0, sizeof(c));
1470 if (rijndael_cipherInit(&c, MODE_CBC, iv->v) < 0)
1471 return NULL;
1472 if (rijndael_blockEncrypt(&c, &k, data->v, data->l << 3, res->v) < 0)
1473 return NULL;
1474
1475 return res;
1476 }
1477
1478 vchar_t *
1479 eay_aes_decrypt(data, key, iv)
1480 vchar_t *data, *key, *iv;
1481 {
1482 vchar_t *res;
1483 keyInstance k;
1484 cipherInstance c;
1485
1486 memset(&k, 0, sizeof(k));
1487 if (rijndael_makeKey(&k, DIR_DECRYPT, key->l << 3, key->v) < 0)
1488 return NULL;
1489
1490 /* allocate buffer for result */
1491 if ((res = vmalloc(data->l)) == NULL)
1492 return NULL;
1493
1494 /* decryption data */
1495 memset(&c, 0, sizeof(c));
1496 if (rijndael_cipherInit(&c, MODE_CBC, iv->v) < 0)
1497 return NULL;
1498 if (rijndael_blockDecrypt(&c, &k, data->v, data->l << 3, res->v) < 0)
1499 return NULL;
1500
1501 return res;
1502 }
1503
1504 int
1505 eay_aes_weakkey(key)
1506 vchar_t *key;
1507 {
1508 return 0;
1509 }
1510
1511 int
1512 eay_aes_keylen(len)
1513 int len;
1514 {
1515 if (len == 0)
1516 return 128;
1517 if (len != 128 && len != 192 && len != 256)
1518 return -1;
1519 return len;
1520 }
1521
1522 /* for ipsec part */
1523 int
1524 eay_null_hashlen()
1525 {
1526 return 0;
1527 }
1528
1529 int
1530 eay_kpdk_hashlen()
1531 {
1532 return 0;
1533 }
1534
1535 int
1536 eay_twofish_keylen(len)
1537 int len;
1538 {
1539 if (len < 0 || len > 256)
1540 return -1;
1541 return len;
1542 }
1543
1544 int
1545 eay_null_keylen(len)
1546 int len;
1547 {
1548 return 0;
1549 }
1550
1551 /*
1552 * HMAC functions
1553 */
1554 static caddr_t
1555 eay_hmac_init(key, md)
1556 vchar_t *key;
1557 const EVP_MD *md;
1558 {
1559 HMAC_CTX *c = racoon_malloc(sizeof(*c));
1560
1561 HMAC_CTX_init(c);
1562 HMAC_Init(c, key->v, key->l, md);
1563
1564 return (caddr_t)c;
1565 }
1566
1567 /*
1568 * HMAC SHA2-512
1569 */
1570 vchar_t *
1571 eay_hmacsha2_512_one(key, data)
1572 vchar_t *key, *data;
1573 {
1574 vchar_t *res;
1575 caddr_t ctx;
1576
1577 ctx = eay_hmacsha2_512_init(key);
1578 eay_hmacsha2_512_update(ctx, data);
1579 res = eay_hmacsha2_512_final(ctx);
1580
1581 return(res);
1582 }
1583
1584 caddr_t
1585 eay_hmacsha2_512_init(key)
1586 vchar_t *key;
1587 {
1588 return eay_hmac_init(key, EVP_sha2_512());
1589 }
1590
1591 void
1592 eay_hmacsha2_512_update(c, data)
1593 caddr_t c;
1594 vchar_t *data;
1595 {
1596 HMAC_Update((HMAC_CTX *)c, data->v, data->l);
1597 }
1598
1599 vchar_t *
1600 eay_hmacsha2_512_final(c)
1601 caddr_t c;
1602 {
1603 vchar_t *res;
1604 unsigned int l;
1605
1606 if ((res = vmalloc(SHA512_DIGEST_LENGTH)) == 0)
1607 return NULL;
1608
1609 HMAC_Final((HMAC_CTX *)c, res->v, &l);
1610 res->l = l;
1611 HMAC_CTX_cleanup(c);
1612 (void)racoon_free(c);
1613
1614 if (SHA512_DIGEST_LENGTH != res->l) {
1615 #ifndef EAYDEBUG
1616 plog(LLV_ERROR, LOCATION, NULL,
1617 "hmac sha2_512 length mismatch %d.\n", res->l);
1618 #else
1619 printf("hmac sha2_512 length mismatch %d.\n", res->l);
1620 #endif
1621 vfree(res);
1622 return NULL;
1623 }
1624
1625 return(res);
1626 }
1627
1628 /*
1629 * HMAC SHA2-384
1630 */
1631 vchar_t *
1632 eay_hmacsha2_384_one(key, data)
1633 vchar_t *key, *data;
1634 {
1635 vchar_t *res;
1636 caddr_t ctx;
1637
1638 ctx = eay_hmacsha2_384_init(key);
1639 eay_hmacsha2_384_update(ctx, data);
1640 res = eay_hmacsha2_384_final(ctx);
1641
1642 return(res);
1643 }
1644
1645 caddr_t
1646 eay_hmacsha2_384_init(key)
1647 vchar_t *key;
1648 {
1649 return eay_hmac_init(key, EVP_sha2_384());
1650 }
1651
1652 void
1653 eay_hmacsha2_384_update(c, data)
1654 caddr_t c;
1655 vchar_t *data;
1656 {
1657 HMAC_Update((HMAC_CTX *)c, data->v, data->l);
1658 }
1659
1660 vchar_t *
1661 eay_hmacsha2_384_final(c)
1662 caddr_t c;
1663 {
1664 vchar_t *res;
1665 unsigned int l;
1666
1667 if ((res = vmalloc(SHA384_DIGEST_LENGTH)) == 0)
1668 return NULL;
1669
1670 HMAC_Final((HMAC_CTX *)c, res->v, &l);
1671 res->l = l;
1672 HMAC_CTX_cleanup(c);
1673 (void)racoon_free(c);
1674
1675 if (SHA384_DIGEST_LENGTH != res->l) {
1676 #ifndef EAYDEBUG
1677 plog(LLV_ERROR, LOCATION, NULL,
1678 "hmac sha2_384 length mismatch %d.\n", res->l);
1679 #else
1680 printf("hmac sha2_384 length mismatch %d.\n", res->l);
1681 #endif
1682 vfree(res);
1683 return NULL;
1684 }
1685
1686 return(res);
1687 }
1688
1689 /*
1690 * HMAC SHA2-256
1691 */
1692 vchar_t *
1693 eay_hmacsha2_256_one(key, data)
1694 vchar_t *key, *data;
1695 {
1696 vchar_t *res;
1697 caddr_t ctx;
1698
1699 ctx = eay_hmacsha2_256_init(key);
1700 eay_hmacsha2_256_update(ctx, data);
1701 res = eay_hmacsha2_256_final(ctx);
1702
1703 return(res);
1704 }
1705
1706 caddr_t
1707 eay_hmacsha2_256_init(key)
1708 vchar_t *key;
1709 {
1710 return eay_hmac_init(key, EVP_sha2_256());
1711 }
1712
1713 void
1714 eay_hmacsha2_256_update(c, data)
1715 caddr_t c;
1716 vchar_t *data;
1717 {
1718 HMAC_Update((HMAC_CTX *)c, data->v, data->l);
1719 }
1720
1721 vchar_t *
1722 eay_hmacsha2_256_final(c)
1723 caddr_t c;
1724 {
1725 vchar_t *res;
1726 unsigned int l;
1727
1728 if ((res = vmalloc(SHA256_DIGEST_LENGTH)) == 0)
1729 return NULL;
1730
1731 HMAC_Final((HMAC_CTX *)c, res->v, &l);
1732 res->l = l;
1733 HMAC_CTX_cleanup(c);
1734 (void)racoon_free(c);
1735
1736 if (SHA256_DIGEST_LENGTH != res->l) {
1737 #ifndef EAYDEBUG
1738 plog(LLV_ERROR, LOCATION, NULL,
1739 "hmac sha2_256 length mismatch %d.\n", res->l);
1740 #else
1741 printf("hmac sha2_256 length mismatch %d.\n", res->l);
1742 #endif
1743 vfree(res);
1744 return NULL;
1745 }
1746
1747 return(res);
1748 }
1749
1750 /*
1751 * HMAC SHA1
1752 */
1753 vchar_t *
1754 eay_hmacsha1_one(key, data)
1755 vchar_t *key, *data;
1756 {
1757 vchar_t *res;
1758 caddr_t ctx;
1759
1760 ctx = eay_hmacsha1_init(key);
1761 eay_hmacsha1_update(ctx, data);
1762 res = eay_hmacsha1_final(ctx);
1763
1764 return(res);
1765 }
1766
1767 caddr_t
1768 eay_hmacsha1_init(key)
1769 vchar_t *key;
1770 {
1771 return eay_hmac_init(key, EVP_sha1());
1772 }
1773
1774 void
1775 eay_hmacsha1_update(c, data)
1776 caddr_t c;
1777 vchar_t *data;
1778 {
1779 HMAC_Update((HMAC_CTX *)c, data->v, data->l);
1780 }
1781
1782 vchar_t *
1783 eay_hmacsha1_final(c)
1784 caddr_t c;
1785 {
1786 vchar_t *res;
1787 unsigned int l;
1788
1789 if ((res = vmalloc(SHA_DIGEST_LENGTH)) == 0)
1790 return NULL;
1791
1792 HMAC_Final((HMAC_CTX *)c, res->v, &l);
1793 res->l = l;
1794 HMAC_CTX_cleanup(c);
1795 (void)racoon_free(c);
1796
1797 if (SHA_DIGEST_LENGTH != res->l) {
1798 #ifndef EAYDEBUG
1799 plog(LLV_ERROR, LOCATION, NULL,
1800 "hmac sha1 length mismatch %d.\n", res->l);
1801 #else
1802 printf("hmac sha1 length mismatch %d.\n", res->l);
1803 #endif
1804 vfree(res);
1805 return NULL;
1806 }
1807
1808 return(res);
1809 }
1810
1811 /*
1812 * HMAC MD5
1813 */
1814 vchar_t *
1815 eay_hmacmd5_one(key, data)
1816 vchar_t *key, *data;
1817 {
1818 vchar_t *res;
1819 caddr_t ctx;
1820
1821 ctx = eay_hmacmd5_init(key);
1822 eay_hmacmd5_update(ctx, data);
1823 res = eay_hmacmd5_final(ctx);
1824
1825 return(res);
1826 }
1827
1828 caddr_t
1829 eay_hmacmd5_init(key)
1830 vchar_t *key;
1831 {
1832 return eay_hmac_init(key, EVP_md5());
1833 }
1834
1835 void
1836 eay_hmacmd5_update(c, data)
1837 caddr_t c;
1838 vchar_t *data;
1839 {
1840 HMAC_Update((HMAC_CTX *)c, data->v, data->l);
1841 }
1842
1843 vchar_t *
1844 eay_hmacmd5_final(c)
1845 caddr_t c;
1846 {
1847 vchar_t *res;
1848 unsigned int l;
1849
1850 if ((res = vmalloc(MD5_DIGEST_LENGTH)) == 0)
1851 return NULL;
1852
1853 HMAC_Final((HMAC_CTX *)c, res->v, &l);
1854 res->l = l;
1855 HMAC_CTX_cleanup(c);
1856 (void)racoon_free(c);
1857
1858 if (MD5_DIGEST_LENGTH != res->l) {
1859 #ifndef EAYDEBUG
1860 plog(LLV_ERROR, LOCATION, NULL,
1861 "hmac md5 length mismatch %d.\n", res->l);
1862 #else
1863 printf("hmac md5 length mismatch %d.\n", res->l);
1864 #endif
1865 vfree(res);
1866 return NULL;
1867 }
1868
1869 return(res);
1870 }
1871
1872 /*
1873 * SHA2-512 functions
1874 */
1875 caddr_t
1876 eay_sha2_512_init()
1877 {
1878 SHA512_CTX *c = racoon_malloc(sizeof(*c));
1879
1880 SHA512_Init(c);
1881
1882 return((caddr_t)c);
1883 }
1884
1885 void
1886 eay_sha2_512_update(c, data)
1887 caddr_t c;
1888 vchar_t *data;
1889 {
1890 SHA512_Update((SHA512_CTX *)c, data->v, data->l);
1891
1892 return;
1893 }
1894
1895 vchar_t *
1896 eay_sha2_512_final(c)
1897 caddr_t c;
1898 {
1899 vchar_t *res;
1900
1901 if ((res = vmalloc(SHA512_DIGEST_LENGTH)) == 0)
1902 return(0);
1903
1904 SHA512_Final(res->v, (SHA512_CTX *)c);
1905 (void)racoon_free(c);
1906
1907 return(res);
1908 }
1909
1910 vchar_t *
1911 eay_sha2_512_one(data)
1912 vchar_t *data;
1913 {
1914 caddr_t ctx;
1915 vchar_t *res;
1916
1917 ctx = eay_sha2_512_init();
1918 eay_sha2_512_update(ctx, data);
1919 res = eay_sha2_512_final(ctx);
1920
1921 return(res);
1922 }
1923
1924 int
1925 eay_sha2_512_hashlen()
1926 {
1927 return SHA512_DIGEST_LENGTH << 3;
1928 }
1929
1930 /*
1931 * SHA2-384 functions
1932 */
1933 caddr_t
1934 eay_sha2_384_init()
1935 {
1936 SHA384_CTX *c = racoon_malloc(sizeof(*c));
1937
1938 SHA384_Init(c);
1939
1940 return((caddr_t)c);
1941 }
1942
1943 void
1944 eay_sha2_384_update(c, data)
1945 caddr_t c;
1946 vchar_t *data;
1947 {
1948 SHA384_Update((SHA384_CTX *)c, data->v, data->l);
1949
1950 return;
1951 }
1952
1953 vchar_t *
1954 eay_sha2_384_final(c)
1955 caddr_t c;
1956 {
1957 vchar_t *res;
1958
1959 if ((res = vmalloc(SHA384_DIGEST_LENGTH)) == 0)
1960 return(0);
1961
1962 SHA384_Final(res->v, (SHA384_CTX *)c);
1963 (void)racoon_free(c);
1964
1965 return(res);
1966 }
1967
1968 vchar_t *
1969 eay_sha2_384_one(data)
1970 vchar_t *data;
1971 {
1972 caddr_t ctx;
1973 vchar_t *res;
1974
1975 ctx = eay_sha2_384_init();
1976 eay_sha2_384_update(ctx, data);
1977 res = eay_sha2_384_final(ctx);
1978
1979 return(res);
1980 }
1981
1982 int
1983 eay_sha2_384_hashlen()
1984 {
1985 return SHA384_DIGEST_LENGTH << 3;
1986 }
1987
1988 /*
1989 * SHA2-256 functions
1990 */
1991 caddr_t
1992 eay_sha2_256_init()
1993 {
1994 SHA256_CTX *c = racoon_malloc(sizeof(*c));
1995
1996 SHA256_Init(c);
1997
1998 return((caddr_t)c);
1999 }
2000
2001 void
2002 eay_sha2_256_update(c, data)
2003 caddr_t c;
2004 vchar_t *data;
2005 {
2006 SHA256_Update((SHA256_CTX *)c, data->v, data->l);
2007
2008 return;
2009 }
2010
2011 vchar_t *
2012 eay_sha2_256_final(c)
2013 caddr_t c;
2014 {
2015 vchar_t *res;
2016
2017 if ((res = vmalloc(SHA256_DIGEST_LENGTH)) == 0)
2018 return(0);
2019
2020 SHA256_Final(res->v, (SHA256_CTX *)c);
2021 (void)racoon_free(c);
2022
2023 return(res);
2024 }
2025
2026 vchar_t *
2027 eay_sha2_256_one(data)
2028 vchar_t *data;
2029 {
2030 caddr_t ctx;
2031 vchar_t *res;
2032
2033 ctx = eay_sha2_256_init();
2034 eay_sha2_256_update(ctx, data);
2035 res = eay_sha2_256_final(ctx);
2036
2037 return(res);
2038 }
2039
2040 int
2041 eay_sha2_256_hashlen()
2042 {
2043 return SHA256_DIGEST_LENGTH << 3;
2044 }
2045
2046 /*
2047 * SHA functions
2048 */
2049 caddr_t
2050 eay_sha1_init()
2051 {
2052 SHA_CTX *c = racoon_malloc(sizeof(*c));
2053
2054 SHA1_Init(c);
2055
2056 return((caddr_t)c);
2057 }
2058
2059 void
2060 eay_sha1_update(c, data)
2061 caddr_t c;
2062 vchar_t *data;
2063 {
2064 SHA1_Update((SHA_CTX *)c, data->v, data->l);
2065
2066 return;
2067 }
2068
2069 vchar_t *
2070 eay_sha1_final(c)
2071 caddr_t c;
2072 {
2073 vchar_t *res;
2074
2075 if ((res = vmalloc(SHA_DIGEST_LENGTH)) == 0)
2076 return(0);
2077
2078 SHA1_Final(res->v, (SHA_CTX *)c);
2079 (void)racoon_free(c);
2080
2081 return(res);
2082 }
2083
2084 vchar_t *
2085 eay_sha1_one(data)
2086 vchar_t *data;
2087 {
2088 caddr_t ctx;
2089 vchar_t *res;
2090
2091 ctx = eay_sha1_init();
2092 eay_sha1_update(ctx, data);
2093 res = eay_sha1_final(ctx);
2094
2095 return(res);
2096 }
2097
2098 int
2099 eay_sha1_hashlen()
2100 {
2101 return SHA_DIGEST_LENGTH << 3;
2102 }
2103
2104 /*
2105 * MD5 functions
2106 */
2107 caddr_t
2108 eay_md5_init()
2109 {
2110 MD5_CTX *c = racoon_malloc(sizeof(*c));
2111
2112 MD5_Init(c);
2113
2114 return((caddr_t)c);
2115 }
2116
2117 void
2118 eay_md5_update(c, data)
2119 caddr_t c;
2120 vchar_t *data;
2121 {
2122 MD5_Update((MD5_CTX *)c, data->v, data->l);
2123
2124 return;
2125 }
2126
2127 vchar_t *
2128 eay_md5_final(c)
2129 caddr_t c;
2130 {
2131 vchar_t *res;
2132
2133 if ((res = vmalloc(MD5_DIGEST_LENGTH)) == 0)
2134 return(0);
2135
2136 MD5_Final(res->v, (MD5_CTX *)c);
2137 (void)racoon_free(c);
2138
2139 return(res);
2140 }
2141
2142 vchar_t *
2143 eay_md5_one(data)
2144 vchar_t *data;
2145 {
2146 caddr_t ctx;
2147 vchar_t *res;
2148
2149 ctx = eay_md5_init();
2150 eay_md5_update(ctx, data);
2151 res = eay_md5_final(ctx);
2152
2153 return(res);
2154 }
2155
2156 int
2157 eay_md5_hashlen()
2158 {
2159 return MD5_DIGEST_LENGTH << 3;
2160 }
2161
2162 /*
2163 * eay_set_random
2164 * size: number of bytes.
2165 */
2166 vchar_t *
2167 eay_set_random(size)
2168 u_int32_t size;
2169 {
2170 BIGNUM *r = NULL;
2171 vchar_t *res = 0;
2172
2173 if ((r = BN_new()) == NULL)
2174 goto end;
2175 BN_rand(r, size * 8, 0, 0);
2176 eay_bn2v(&res, r);
2177
2178 end:
2179 if (r)
2180 BN_free(r);
2181 return(res);
2182 }
2183
2184 /* DH */
2185 int
2186 eay_dh_generate(prime, g, publen, pub, priv)
2187 vchar_t *prime, **pub, **priv;
2188 u_int publen;
2189 u_int32_t g;
2190 {
2191 BIGNUM *p = NULL;
2192 DH *dh = NULL;
2193 int error = -1;
2194
2195 /* initialize */
2196 /* pre-process to generate number */
2197 if (eay_v2bn(&p, prime) < 0)
2198 goto end;
2199
2200 if ((dh = DH_new()) == NULL)
2201 goto end;
2202 dh->p = p;
2203 p = NULL; /* p is now part of dh structure */
2204 dh->g = NULL;
2205 if ((dh->g = BN_new()) == NULL)
2206 goto end;
2207 if (!BN_set_word(dh->g, g))
2208 goto end;
2209
2210 if (publen != 0)
2211 dh->length = publen;
2212
2213 /* generate public and private number */
2214 if (!DH_generate_key(dh))
2215 goto end;
2216
2217 /* copy results to buffers */
2218 if (eay_bn2v(pub, dh->pub_key) < 0)
2219 goto end;
2220 if (eay_bn2v(priv, dh->priv_key) < 0) {
2221 vfree(*pub);
2222 goto end;
2223 }
2224
2225 error = 0;
2226
2227 end:
2228 if (dh != NULL)
2229 DH_free(dh);
2230 if (p != 0)
2231 BN_free(p);
2232 return(error);
2233 }
2234
2235 int
2236 eay_dh_compute(prime, g, pub, priv, pub2, key)
2237 vchar_t *prime, *pub, *priv, *pub2, **key;
2238 u_int32_t g;
2239 {
2240 BIGNUM *dh_pub = NULL;
2241 DH *dh = NULL;
2242 int l;
2243 caddr_t v = NULL;
2244 int error = -1;
2245
2246 /* make public number to compute */
2247 if (eay_v2bn(&dh_pub, pub2) < 0)
2248 goto end;
2249
2250 /* make DH structure */
2251 if ((dh = DH_new()) == NULL)
2252 goto end;
2253 if (eay_v2bn(&dh->p, prime) < 0)
2254 goto end;
2255 if (eay_v2bn(&dh->pub_key, pub) < 0)
2256 goto end;
2257 if (eay_v2bn(&dh->priv_key, priv) < 0)
2258 goto end;
2259 dh->length = pub2->l * 8;
2260
2261 dh->g = NULL;
2262 if ((dh->g = BN_new()) == NULL)
2263 goto end;
2264 if (!BN_set_word(dh->g, g))
2265 goto end;
2266
2267 if ((v = (caddr_t)racoon_calloc(prime->l, sizeof(u_char))) == NULL)
2268 goto end;
2269 if ((l = DH_compute_key(v, dh_pub, dh)) == -1)
2270 goto end;
2271 memcpy((*key)->v + (prime->l - l), v, l);
2272
2273 error = 0;
2274
2275 end:
2276 if (dh_pub != NULL)
2277 BN_free(dh_pub);
2278 if (dh != NULL)
2279 DH_free(dh);
2280 if (v != NULL)
2281 racoon_free(v);
2282 return(error);
2283 }
2284
2285 #if 1
2286 int
2287 eay_v2bn(bn, var)
2288 BIGNUM **bn;
2289 vchar_t *var;
2290 {
2291 if ((*bn = BN_bin2bn(var->v, var->l, NULL)) == NULL)
2292 return -1;
2293
2294 return 0;
2295 }
2296 #else
2297 /*
2298 * convert vchar_t <-> BIGNUM.
2299 *
2300 * vchar_t: unit is u_char, network endian, most significant byte first.
2301 * BIGNUM: unit is BN_ULONG, each of BN_ULONG is in host endian,
2302 * least significant BN_ULONG must come first.
2303 *
2304 * hex value of "0x3ffe050104" is represented as follows:
2305 * vchar_t: 3f fe 05 01 04
2306 * BIGNUM (BN_ULONG = u_int8_t): 04 01 05 fe 3f
2307 * BIGNUM (BN_ULONG = u_int16_t): 0x0104 0xfe05 0x003f
2308 * BIGNUM (BN_ULONG = u_int32_t_t): 0xfe050104 0x0000003f
2309 */
2310 int
2311 eay_v2bn(bn, var)
2312 BIGNUM **bn;
2313 vchar_t *var;
2314 {
2315 u_char *p;
2316 u_char *q;
2317 BN_ULONG *r;
2318 int l;
2319 BN_ULONG num;
2320
2321 *bn = BN_new();
2322 if (*bn == NULL)
2323 goto err;
2324 l = (var->l * 8 + BN_BITS2 - 1) / BN_BITS2;
2325 if (bn_expand(*bn, l * BN_BITS2) == NULL)
2326 goto err;
2327 (*bn)->top = l;
2328
2329 /* scan from least significant byte */
2330 p = (u_char *)var->v;
2331 q = (u_char *)(var->v + var->l);
2332 r = (*bn)->d;
2333 num = 0;
2334 l = 0;
2335 do {
2336 q--;
2337 num = num | ((BN_ULONG)*q << (l++ * 8));
2338 if (l == BN_BYTES) {
2339 *r++ = num;
2340 num = 0;
2341 l = 0;
2342 }
2343 } while (p < q);
2344 if (l)
2345 *r = num;
2346 return 0;
2347
2348 err:
2349 if (*bn)
2350 BN_free(*bn);
2351 return -1;
2352 }
2353 #endif
2354
2355 int
2356 eay_bn2v(var, bn)
2357 vchar_t **var;
2358 BIGNUM *bn;
2359 {
2360 *var = vmalloc(bn->top * BN_BYTES);
2361 if (*var == NULL)
2362 return(-1);
2363
2364 (*var)->l = BN_bn2bin(bn, (*var)->v);
2365
2366 return 0;
2367 }
2368
2369 const char *
2370 eay_version()
2371 {
2372 return SSLeay_version(SSLEAY_VERSION);
2373 }
mirror of network_cmds