Line data Source code
1 : /*
2 : * Copyright (c) 2006 - 2008 Kungliga Tekniska Högskolan
3 : * (Royal Institute of Technology, Stockholm, Sweden).
4 : * All rights reserved.
5 : *
6 : * Redistribution and use in source and binary forms, with or without
7 : * modification, are permitted provided that the following conditions
8 : * are met:
9 : *
10 : * 1. Redistributions of source code must retain the above copyright
11 : * notice, this list of conditions and the following disclaimer.
12 : *
13 : * 2. Redistributions in binary form must reproduce the above copyright
14 : * notice, this list of conditions and the following disclaimer in the
15 : * documentation and/or other materials provided with the distribution.
16 : *
17 : * 3. Neither the name of the Institute nor the names of its contributors
18 : * may be used to endorse or promote products derived from this software
19 : * without specific prior written permission.
20 : *
21 : * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND
22 : * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
23 : * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
24 : * ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE
25 : * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
26 : * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
27 : * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
28 : * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
29 : * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
30 : * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
31 : * SUCH DAMAGE.
32 : */
33 :
34 : #include <config.h>
35 : #include <roken.h>
36 :
37 : #define HC_DEPRECATED
38 :
39 : #include <assert.h>
40 :
41 : #include <evp.h>
42 : #include <evp-hcrypto.h>
43 :
44 : #include <krb5-types.h>
45 :
46 : #include <des.h>
47 : #include "camellia.h"
48 : #include <aes.h>
49 :
50 : #include <rc2.h>
51 : #include <rc4.h>
52 :
53 : #include <sha.h>
54 : #include <md2.h>
55 : #include <md4.h>
56 : #include <md5.h>
57 :
58 : /*
59 : *
60 : */
61 :
62 : static int
63 8885230 : aes_init(EVP_CIPHER_CTX *ctx,
64 : const unsigned char * key,
65 : const unsigned char * iv,
66 : int encp)
67 : {
68 8885230 : AES_KEY *k = ctx->cipher_data;
69 8885230 : if (ctx->encrypt || EVP_CIPHER_CTX_mode(ctx) == EVP_CIPH_CFB8_MODE)
70 4698204 : AES_set_encrypt_key(key, ctx->cipher->key_len * 8, k);
71 : else
72 4187026 : AES_set_decrypt_key(key, ctx->cipher->key_len * 8, k);
73 8885230 : return 1;
74 : }
75 :
76 : static int
77 15502205 : aes_do_cipher(EVP_CIPHER_CTX *ctx,
78 : unsigned char *out,
79 : const unsigned char *in,
80 : unsigned int size)
81 : {
82 15502205 : AES_KEY *k = ctx->cipher_data;
83 15502205 : if (EVP_CIPHER_CTX_mode(ctx) == EVP_CIPH_CFB8_MODE)
84 0 : AES_cfb8_encrypt(in, out, size, k, ctx->iv, ctx->encrypt);
85 : else
86 15502205 : AES_cbc_encrypt(in, out, size, k, ctx->iv, ctx->encrypt);
87 15502205 : return 1;
88 : }
89 :
90 : /**
91 : * The AES-128 cipher type (hcrypto)
92 : *
93 : * @return the AES-128 EVP_CIPHER pointer.
94 : *
95 : * @ingroup hcrypto_evp
96 : */
97 :
98 : const EVP_CIPHER *
99 23295 : EVP_hcrypto_aes_128_cbc(void)
100 : {
101 : static const EVP_CIPHER aes_128_cbc = {
102 : 0,
103 : 16,
104 : 16,
105 : 16,
106 : EVP_CIPH_CBC_MODE,
107 : aes_init,
108 : aes_do_cipher,
109 : NULL,
110 : sizeof(AES_KEY),
111 : NULL,
112 : NULL,
113 : NULL,
114 : NULL
115 : };
116 :
117 23295 : return &aes_128_cbc;
118 : }
119 :
120 : /**
121 : * The AES-192 cipher type (hcrypto)
122 : *
123 : * @return the AES-192 EVP_CIPHER pointer.
124 : *
125 : * @ingroup hcrypto_evp
126 : */
127 :
128 : const EVP_CIPHER *
129 0 : EVP_hcrypto_aes_192_cbc(void)
130 : {
131 : static const EVP_CIPHER aes_192_cbc = {
132 : 0,
133 : 16,
134 : 24,
135 : 16,
136 : EVP_CIPH_CBC_MODE,
137 : aes_init,
138 : aes_do_cipher,
139 : NULL,
140 : sizeof(AES_KEY),
141 : NULL,
142 : NULL,
143 : NULL,
144 : NULL
145 : };
146 0 : return &aes_192_cbc;
147 : }
148 :
149 : /**
150 : * The AES-256 cipher type (hcrypto)
151 : *
152 : * @return the AES-256 EVP_CIPHER pointer.
153 : *
154 : * @ingroup hcrypto_evp
155 : */
156 :
157 : const EVP_CIPHER *
158 4674909 : EVP_hcrypto_aes_256_cbc(void)
159 : {
160 : static const EVP_CIPHER aes_256_cbc = {
161 : 0,
162 : 16,
163 : 32,
164 : 16,
165 : EVP_CIPH_CBC_MODE,
166 : aes_init,
167 : aes_do_cipher,
168 : NULL,
169 : sizeof(AES_KEY),
170 : NULL,
171 : NULL,
172 : NULL,
173 : NULL
174 : };
175 4674909 : return &aes_256_cbc;
176 : }
177 :
178 : /**
179 : * The AES-128 CFB8 cipher type (hcrypto)
180 : *
181 : * @return the AES-128 EVP_CIPHER pointer.
182 : *
183 : * @ingroup hcrypto_evp
184 : */
185 :
186 : const EVP_CIPHER *
187 0 : EVP_hcrypto_aes_128_cfb8(void)
188 : {
189 : static const EVP_CIPHER aes_128_cfb8 = {
190 : 0,
191 : 1,
192 : 16,
193 : 16,
194 : EVP_CIPH_CFB8_MODE,
195 : aes_init,
196 : aes_do_cipher,
197 : NULL,
198 : sizeof(AES_KEY),
199 : NULL,
200 : NULL,
201 : NULL,
202 : NULL
203 : };
204 :
205 0 : return &aes_128_cfb8;
206 : }
207 :
208 : /**
209 : * The AES-192 CFB8 cipher type (hcrypto)
210 : *
211 : * @return the AES-192 EVP_CIPHER pointer.
212 : *
213 : * @ingroup hcrypto_evp
214 : */
215 :
216 : const EVP_CIPHER *
217 0 : EVP_hcrypto_aes_192_cfb8(void)
218 : {
219 : static const EVP_CIPHER aes_192_cfb8 = {
220 : 0,
221 : 1,
222 : 24,
223 : 16,
224 : EVP_CIPH_CFB8_MODE,
225 : aes_init,
226 : aes_do_cipher,
227 : NULL,
228 : sizeof(AES_KEY),
229 : NULL,
230 : NULL,
231 : NULL,
232 : NULL
233 : };
234 0 : return &aes_192_cfb8;
235 : }
236 :
237 : /**
238 : * The AES-256 CFB8 cipher type (hcrypto)
239 : *
240 : * @return the AES-256 EVP_CIPHER pointer.
241 : *
242 : * @ingroup hcrypto_evp
243 : */
244 :
245 : const EVP_CIPHER *
246 0 : EVP_hcrypto_aes_256_cfb8(void)
247 : {
248 : static const EVP_CIPHER aes_256_cfb8 = {
249 : 0,
250 : 1,
251 : 32,
252 : 16,
253 : EVP_CIPH_CFB8_MODE,
254 : aes_init,
255 : aes_do_cipher,
256 : NULL,
257 : sizeof(AES_KEY),
258 : NULL,
259 : NULL,
260 : NULL,
261 : NULL
262 : };
263 0 : return &aes_256_cfb8;
264 : }
265 :
266 : /**
267 : * The message digest SHA256 - hcrypto
268 : *
269 : * @return the message digest type.
270 : *
271 : * @ingroup hcrypto_evp
272 : */
273 :
274 : const EVP_MD *
275 0 : EVP_hcrypto_sha256(void)
276 : {
277 : static const struct hc_evp_md sha256 = {
278 : 32,
279 : 64,
280 : sizeof(SHA256_CTX),
281 : (hc_evp_md_init)SHA256_Init,
282 : (hc_evp_md_update)SHA256_Update,
283 : (hc_evp_md_final)SHA256_Final,
284 : NULL
285 : };
286 0 : return &sha256;
287 : }
288 :
289 : /**
290 : * The message digest SHA384 - hcrypto
291 : *
292 : * @return the message digest type.
293 : *
294 : * @ingroup hcrypto_evp
295 : */
296 :
297 : const EVP_MD *
298 0 : EVP_hcrypto_sha384(void)
299 : {
300 : static const struct hc_evp_md sha384 = {
301 : 48,
302 : 128,
303 : sizeof(SHA384_CTX),
304 : (hc_evp_md_init)SHA384_Init,
305 : (hc_evp_md_update)SHA384_Update,
306 : (hc_evp_md_final)SHA384_Final,
307 : NULL
308 : };
309 0 : return &sha384;
310 : }
311 :
312 : /**
313 : * The message digest SHA512 - hcrypto
314 : *
315 : * @return the message digest type.
316 : *
317 : * @ingroup hcrypto_evp
318 : */
319 :
320 : const EVP_MD *
321 0 : EVP_hcrypto_sha512(void)
322 : {
323 : static const struct hc_evp_md sha512 = {
324 : 64,
325 : 128,
326 : sizeof(SHA512_CTX),
327 : (hc_evp_md_init)SHA512_Init,
328 : (hc_evp_md_update)SHA512_Update,
329 : (hc_evp_md_final)SHA512_Final,
330 : NULL
331 : };
332 0 : return &sha512;
333 : }
334 :
335 : /**
336 : * The message digest SHA1 - hcrypto
337 : *
338 : * @return the message digest type.
339 : *
340 : * @ingroup hcrypto_evp
341 : */
342 :
343 : const EVP_MD *
344 4480053 : EVP_hcrypto_sha1(void)
345 : {
346 : static const struct hc_evp_md sha1 = {
347 : 20,
348 : 64,
349 : sizeof(SHA_CTX),
350 : (hc_evp_md_init)SHA1_Init,
351 : (hc_evp_md_update)SHA1_Update,
352 : (hc_evp_md_final)SHA1_Final,
353 : NULL
354 : };
355 4480053 : return &sha1;
356 : }
357 :
358 : /**
359 : * The message digest MD5 - hcrypto
360 : *
361 : * @return the message digest type.
362 : *
363 : * @ingroup hcrypto_evp
364 : */
365 :
366 : const EVP_MD *
367 2075355 : EVP_hcrypto_md5(void)
368 : {
369 : static const struct hc_evp_md md5 = {
370 : 16,
371 : 64,
372 : sizeof(MD5_CTX),
373 : (hc_evp_md_init)MD5_Init,
374 : (hc_evp_md_update)MD5_Update,
375 : (hc_evp_md_final)MD5_Final,
376 : NULL
377 : };
378 2075355 : return &md5;
379 : }
380 :
381 : /**
382 : * The message digest MD4 - hcrypto
383 : *
384 : * @return the message digest type.
385 : *
386 : * @ingroup hcrypto_evp
387 : */
388 :
389 : const EVP_MD *
390 1181 : EVP_hcrypto_md4(void)
391 : {
392 : static const struct hc_evp_md md4 = {
393 : 16,
394 : 64,
395 : sizeof(MD4_CTX),
396 : (hc_evp_md_init)MD4_Init,
397 : (hc_evp_md_update)MD4_Update,
398 : (hc_evp_md_final)MD4_Final,
399 : NULL
400 : };
401 1181 : return &md4;
402 : }
403 :
404 : /**
405 : * The message digest MD2 - hcrypto
406 : *
407 : * @return the message digest type.
408 : *
409 : * @ingroup hcrypto_evp
410 : */
411 :
412 : const EVP_MD *
413 0 : EVP_hcrypto_md2(void)
414 : {
415 : static const struct hc_evp_md md2 = {
416 : 16,
417 : 16,
418 : sizeof(MD2_CTX),
419 : (hc_evp_md_init)MD2_Init,
420 : (hc_evp_md_update)MD2_Update,
421 : (hc_evp_md_final)MD2_Final,
422 : NULL
423 : };
424 0 : return &md2;
425 : }
426 :
427 : /*
428 : *
429 : */
430 :
431 : static int
432 0 : des_cbc_init(EVP_CIPHER_CTX *ctx,
433 : const unsigned char * key,
434 : const unsigned char * iv,
435 : int encp)
436 : {
437 0 : DES_key_schedule *k = ctx->cipher_data;
438 : DES_cblock deskey;
439 0 : memcpy(&deskey, key, sizeof(deskey));
440 0 : DES_set_key_unchecked(&deskey, k);
441 0 : return 1;
442 : }
443 :
444 : static int
445 0 : des_cbc_do_cipher(EVP_CIPHER_CTX *ctx,
446 : unsigned char *out,
447 : const unsigned char *in,
448 : unsigned int size)
449 : {
450 0 : DES_key_schedule *k = ctx->cipher_data;
451 0 : DES_cbc_encrypt(in, out, size,
452 0 : k, (DES_cblock *)ctx->iv, ctx->encrypt);
453 0 : return 1;
454 : }
455 :
456 : /**
457 : * The DES cipher type
458 : *
459 : * @return the DES-CBC EVP_CIPHER pointer.
460 : *
461 : * @ingroup hcrypto_evp
462 : */
463 :
464 : const EVP_CIPHER *
465 0 : EVP_hcrypto_des_cbc(void)
466 : {
467 : static const EVP_CIPHER des_cbc = {
468 : 0,
469 : 8,
470 : 8,
471 : 8,
472 : EVP_CIPH_CBC_MODE,
473 : des_cbc_init,
474 : des_cbc_do_cipher,
475 : NULL,
476 : sizeof(DES_key_schedule),
477 : NULL,
478 : NULL,
479 : NULL,
480 : NULL
481 : };
482 0 : return &des_cbc;
483 : }
484 :
485 : /*
486 : *
487 : */
488 :
489 : struct des_ede3_cbc {
490 : DES_key_schedule ks[3];
491 : };
492 :
493 : static int
494 21874 : des_ede3_cbc_init(EVP_CIPHER_CTX *ctx,
495 : const unsigned char * key,
496 : const unsigned char * iv,
497 : int encp)
498 : {
499 21874 : struct des_ede3_cbc *k = ctx->cipher_data;
500 : DES_cblock deskey;
501 :
502 21874 : memcpy(&deskey, key, sizeof(deskey));
503 21874 : DES_set_odd_parity(&deskey);
504 21874 : DES_set_key_unchecked(&deskey, &k->ks[0]);
505 :
506 21874 : memcpy(&deskey, key + 8, sizeof(deskey));
507 21874 : DES_set_odd_parity(&deskey);
508 21874 : DES_set_key_unchecked(&deskey, &k->ks[1]);
509 :
510 21874 : memcpy(&deskey, key + 16, sizeof(deskey));
511 21874 : DES_set_odd_parity(&deskey);
512 21874 : DES_set_key_unchecked(&deskey, &k->ks[2]);
513 :
514 21874 : return 1;
515 : }
516 :
517 : static int
518 21874 : des_ede3_cbc_do_cipher(EVP_CIPHER_CTX *ctx,
519 : unsigned char *out,
520 : const unsigned char *in,
521 : unsigned int size)
522 : {
523 21874 : struct des_ede3_cbc *k = ctx->cipher_data;
524 43748 : DES_ede3_cbc_encrypt(in, out, size,
525 : &k->ks[0], &k->ks[1], &k->ks[2],
526 21874 : (DES_cblock *)ctx->iv, ctx->encrypt);
527 21874 : return 1;
528 : }
529 :
530 : /**
531 : * The triple DES cipher type - hcrypto
532 : *
533 : * @return the DES-EDE3-CBC EVP_CIPHER pointer.
534 : *
535 : * @ingroup hcrypto_evp
536 : */
537 :
538 : const EVP_CIPHER *
539 10937 : EVP_hcrypto_des_ede3_cbc(void)
540 : {
541 : static const EVP_CIPHER des_ede3_cbc = {
542 : 0,
543 : 8,
544 : 24,
545 : 8,
546 : EVP_CIPH_CBC_MODE,
547 : des_ede3_cbc_init,
548 : des_ede3_cbc_do_cipher,
549 : NULL,
550 : sizeof(struct des_ede3_cbc),
551 : NULL,
552 : NULL,
553 : NULL,
554 : NULL
555 : };
556 10937 : return &des_ede3_cbc;
557 : }
558 :
559 : /*
560 : *
561 : */
562 :
563 : struct rc2_cbc {
564 : unsigned int maximum_effective_key;
565 : RC2_KEY key;
566 : };
567 :
568 : static int
569 0 : rc2_init(EVP_CIPHER_CTX *ctx,
570 : const unsigned char * key,
571 : const unsigned char * iv,
572 : int encp)
573 : {
574 0 : struct rc2_cbc *k = ctx->cipher_data;
575 0 : k->maximum_effective_key = EVP_CIPHER_CTX_key_length(ctx) * 8;
576 0 : RC2_set_key(&k->key,
577 0 : EVP_CIPHER_CTX_key_length(ctx),
578 : key,
579 0 : k->maximum_effective_key);
580 0 : return 1;
581 : }
582 :
583 : static int
584 0 : rc2_do_cipher(EVP_CIPHER_CTX *ctx,
585 : unsigned char *out,
586 : const unsigned char *in,
587 : unsigned int size)
588 : {
589 0 : struct rc2_cbc *k = ctx->cipher_data;
590 0 : RC2_cbc_encrypt(in, out, size, &k->key, ctx->iv, ctx->encrypt);
591 0 : return 1;
592 : }
593 :
594 : /**
595 : * The RC2 cipher type - hcrypto
596 : *
597 : * @return the RC2 EVP_CIPHER pointer.
598 : *
599 : * @ingroup hcrypto_evp
600 : */
601 :
602 : const EVP_CIPHER *
603 0 : EVP_hcrypto_rc2_cbc(void)
604 : {
605 : static const EVP_CIPHER rc2_cbc = {
606 : 0,
607 : RC2_BLOCK_SIZE,
608 : RC2_KEY_LENGTH,
609 : RC2_BLOCK_SIZE,
610 : EVP_CIPH_CBC_MODE|EVP_CIPH_VARIABLE_LENGTH,
611 : rc2_init,
612 : rc2_do_cipher,
613 : NULL,
614 : sizeof(struct rc2_cbc),
615 : NULL,
616 : NULL,
617 : NULL,
618 : NULL
619 : };
620 0 : return &rc2_cbc;
621 : }
622 :
623 : /**
624 : * The RC2-40 cipher type
625 : *
626 : * @return the RC2-40 EVP_CIPHER pointer.
627 : *
628 : * @ingroup hcrypto_evp
629 : */
630 :
631 : const EVP_CIPHER *
632 0 : EVP_hcrypto_rc2_40_cbc(void)
633 : {
634 : static const EVP_CIPHER rc2_40_cbc = {
635 : 0,
636 : RC2_BLOCK_SIZE,
637 : 5,
638 : RC2_BLOCK_SIZE,
639 : EVP_CIPH_CBC_MODE,
640 : rc2_init,
641 : rc2_do_cipher,
642 : NULL,
643 : sizeof(struct rc2_cbc),
644 : NULL,
645 : NULL,
646 : NULL,
647 : NULL
648 : };
649 0 : return &rc2_40_cbc;
650 : }
651 :
652 : /**
653 : * The RC2-64 cipher type
654 : *
655 : * @return the RC2-64 EVP_CIPHER pointer.
656 : *
657 : * @ingroup hcrypto_evp
658 : */
659 :
660 : const EVP_CIPHER *
661 0 : EVP_hcrypto_rc2_64_cbc(void)
662 : {
663 : static const EVP_CIPHER rc2_64_cbc = {
664 : 0,
665 : RC2_BLOCK_SIZE,
666 : 8,
667 : RC2_BLOCK_SIZE,
668 : EVP_CIPH_CBC_MODE,
669 : rc2_init,
670 : rc2_do_cipher,
671 : NULL,
672 : sizeof(struct rc2_cbc),
673 : NULL,
674 : NULL,
675 : NULL,
676 : NULL
677 : };
678 0 : return &rc2_64_cbc;
679 : }
680 :
681 : static int
682 0 : camellia_init(EVP_CIPHER_CTX *ctx,
683 : const unsigned char * key,
684 : const unsigned char * iv,
685 : int encp)
686 : {
687 0 : CAMELLIA_KEY *k = ctx->cipher_data;
688 0 : k->bits = ctx->cipher->key_len * 8;
689 0 : CAMELLIA_set_key(key, ctx->cipher->key_len * 8, k);
690 0 : return 1;
691 : }
692 :
693 : static int
694 0 : camellia_do_cipher(EVP_CIPHER_CTX *ctx,
695 : unsigned char *out,
696 : const unsigned char *in,
697 : unsigned int size)
698 : {
699 0 : CAMELLIA_KEY *k = ctx->cipher_data;
700 0 : CAMELLIA_cbc_encrypt(in, out, size, k, ctx->iv, ctx->encrypt);
701 0 : return 1;
702 : }
703 :
704 : /**
705 : * The Camellia-128 cipher type - hcrypto
706 : *
707 : * @return the Camellia-128 EVP_CIPHER pointer.
708 : *
709 : * @ingroup hcrypto_evp
710 : */
711 :
712 : const EVP_CIPHER *
713 0 : EVP_hcrypto_camellia_128_cbc(void)
714 : {
715 : static const EVP_CIPHER cipher = {
716 : 0,
717 : 16,
718 : 16,
719 : 16,
720 : EVP_CIPH_CBC_MODE,
721 : camellia_init,
722 : camellia_do_cipher,
723 : NULL,
724 : sizeof(CAMELLIA_KEY),
725 : NULL,
726 : NULL,
727 : NULL,
728 : NULL
729 : };
730 0 : return &cipher;
731 : }
732 :
733 : /**
734 : * The Camellia-198 cipher type - hcrypto
735 : *
736 : * @return the Camellia-198 EVP_CIPHER pointer.
737 : *
738 : * @ingroup hcrypto_evp
739 : */
740 :
741 : const EVP_CIPHER *
742 0 : EVP_hcrypto_camellia_192_cbc(void)
743 : {
744 : static const EVP_CIPHER cipher = {
745 : 0,
746 : 16,
747 : 24,
748 : 16,
749 : EVP_CIPH_CBC_MODE,
750 : camellia_init,
751 : camellia_do_cipher,
752 : NULL,
753 : sizeof(CAMELLIA_KEY),
754 : NULL,
755 : NULL,
756 : NULL,
757 : NULL
758 : };
759 0 : return &cipher;
760 : }
761 :
762 : /**
763 : * The Camellia-256 cipher type - hcrypto
764 : *
765 : * @return the Camellia-256 EVP_CIPHER pointer.
766 : *
767 : * @ingroup hcrypto_evp
768 : */
769 :
770 : const EVP_CIPHER *
771 0 : EVP_hcrypto_camellia_256_cbc(void)
772 : {
773 : static const EVP_CIPHER cipher = {
774 : 0,
775 : 16,
776 : 32,
777 : 16,
778 : EVP_CIPH_CBC_MODE,
779 : camellia_init,
780 : camellia_do_cipher,
781 : NULL,
782 : sizeof(CAMELLIA_KEY),
783 : NULL,
784 : NULL,
785 : NULL,
786 : NULL
787 : };
788 0 : return &cipher;
789 : }
790 :
791 : static int
792 637721 : rc4_init(EVP_CIPHER_CTX *ctx,
793 : const unsigned char *key,
794 : const unsigned char *iv,
795 : int enc)
796 : {
797 637721 : RC4_KEY *k = ctx->cipher_data;
798 637721 : RC4_set_key(k, ctx->key_len, key);
799 637721 : return 1;
800 : }
801 :
802 : static int
803 422562 : rc4_do_cipher(EVP_CIPHER_CTX *ctx,
804 : unsigned char *out,
805 : const unsigned char *in,
806 : unsigned int size)
807 : {
808 422562 : RC4_KEY *k = ctx->cipher_data;
809 422562 : RC4(k, size, in, out);
810 422562 : return 1;
811 : }
812 :
813 : const EVP_CIPHER *
814 463208 : EVP_hcrypto_rc4(void)
815 : {
816 : static const EVP_CIPHER rc4 = {
817 : 0,
818 : 1,
819 : 16,
820 : 0,
821 : EVP_CIPH_STREAM_CIPHER|EVP_CIPH_VARIABLE_LENGTH,
822 : rc4_init,
823 : rc4_do_cipher,
824 : NULL,
825 : sizeof(RC4_KEY),
826 : NULL,
827 : NULL,
828 : NULL,
829 : NULL
830 : };
831 463208 : return &rc4;
832 : }
833 :
834 :
835 : const EVP_CIPHER *
836 0 : EVP_hcrypto_rc4_40(void)
837 : {
838 : static const EVP_CIPHER rc4_40 = {
839 : 0,
840 : 1,
841 : 5,
842 : 0,
843 : EVP_CIPH_STREAM_CIPHER|EVP_CIPH_VARIABLE_LENGTH,
844 : rc4_init,
845 : rc4_do_cipher,
846 : NULL,
847 : sizeof(RC4_KEY),
848 : NULL,
849 : NULL,
850 : NULL,
851 : NULL
852 : };
853 0 : return &rc4_40;
854 : }
|
