1/*	$NetBSD$	*/
2
3/*
4 * Copyright (c) 2008 Kungliga Tekniska H��gskolan
5 * (Royal Institute of Technology, Stockholm, Sweden).
6 * All rights reserved.
7 *
8 * Portions Copyright (c) 2009 Apple Inc. All rights reserved.
9 *
10 * Redistribution and use in source and binary forms, with or without
11 * modification, are permitted provided that the following conditions
12 * are met:
13 *
14 * 1. Redistributions of source code must retain the above copyright
15 *    notice, this list of conditions and the following disclaimer.
16 *
17 * 2. Redistributions in binary form must reproduce the above copyright
18 *    notice, this list of conditions and the following disclaimer in the
19 *    documentation and/or other materials provided with the distribution.
20 *
21 * 3. Neither the name of the Institute nor the names of its contributors
22 *    may be used to endorse or promote products derived from this software
23 *    without specific prior written permission.
24 *
25 * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND
26 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
27 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
28 * ARE DISCLAIMED.  IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE
29 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
30 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
31 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
32 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
33 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
34 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
35 * SUCH DAMAGE.
36 */
37
38/* CommonCrypto provider */
39
40#ifdef __APPLE__
41
42#include "config.h"
43
44#include <sys/types.h>
45#include <stdio.h>
46#include <stdlib.h>
47#include <string.h>
48#include <assert.h>
49
50#ifdef HAVE_COMMONCRYPTO_COMMONDIGEST_H
51#include <CommonCrypto/CommonDigest.h>
52#endif
53#ifdef HAVE_COMMONCRYPTO_COMMONCRYPTOR_H
54#include <CommonCrypto/CommonCryptor.h>
55#endif
56
57#include <evp.h>
58#include <evp-cc.h>
59
60/*
61 *
62 */
63
64#ifdef HAVE_COMMONCRYPTO_COMMONCRYPTOR_H
65
66struct cc_key {
67    CCCryptorRef href;
68};
69
70static int
71cc_do_cipher(EVP_CIPHER_CTX *ctx,
72	     unsigned char *out,
73	     const unsigned char *in,
74	     unsigned int size)
75{
76    struct cc_key *cc = ctx->cipher_data;
77    CCCryptorStatus ret;
78    size_t moved;
79
80    memcpy(out, in, size);
81
82    ret = CCCryptorUpdate(cc->href, in, size, out, size, &moved);
83    if (ret)
84	return 0;
85
86    if (moved != size)
87	return 0;
88
89    return 1;
90}
91
92static int
93cc_do_cfb8_cipher(EVP_CIPHER_CTX *ctx,
94                  unsigned char *out,
95                  const unsigned char *in,
96                  unsigned int size)
97{
98    struct cc_key *cc = ctx->cipher_data;
99    CCCryptorStatus ret;
100    size_t moved;
101    unsigned int i;
102
103    for (i = 0; i < size; i++) {
104        unsigned char oiv[EVP_MAX_IV_LENGTH + 1];
105
106        assert(ctx->cipher->iv_len + 1 <= sizeof(oiv));
107        memcpy(oiv, ctx->iv, ctx->cipher->iv_len);
108
109        ret = CCCryptorUpdate(cc->href, ctx->iv, ctx->cipher->iv_len,
110                              ctx->iv, ctx->cipher->iv_len, &moved);
111        if (ret)
112            return 0;
113
114        if (moved != ctx->cipher->iv_len)
115            return 0;
116
117        if (!ctx->encrypt)
118            oiv[ctx->cipher->iv_len] = in[i];
119        out[i] = in[i] ^ ctx->iv[0];
120        if (ctx->encrypt)
121            oiv[ctx->cipher->iv_len] = out[i];
122
123        memcpy(ctx->iv, &oiv[1], ctx->cipher->iv_len);
124    }
125
126    return 1;
127}
128
129static int
130cc_cleanup(EVP_CIPHER_CTX *ctx)
131{
132    struct cc_key *cc = ctx->cipher_data;
133    if (cc->href)
134	CCCryptorRelease(cc->href);
135    return 1;
136}
137
138static int
139init_cc_key(int encp, CCAlgorithm alg, CCOptions opts, const void *key,
140	    size_t keylen, const void *iv, CCCryptorRef *ref)
141{
142    CCOperation op = encp ? kCCEncrypt : kCCDecrypt;
143    CCCryptorStatus ret;
144
145    if (*ref) {
146	if (key == NULL && iv) {
147	    CCCryptorReset(*ref, iv);
148	    return 1;
149	}
150	CCCryptorRelease(*ref);
151    }
152
153    ret = CCCryptorCreate(op, alg, opts, key, keylen, iv, ref);
154    if (ret)
155	return 0;
156    return 1;
157}
158
159static int
160cc_des_ede3_cbc_init(EVP_CIPHER_CTX *ctx,
161		     const unsigned char * key,
162		     const unsigned char * iv,
163		     int encp)
164{
165    struct cc_key *cc = ctx->cipher_data;
166    return init_cc_key(encp, kCCAlgorithm3DES, 0, key, kCCKeySize3DES, iv, &cc->href);
167}
168
169#endif /* HAVE_COMMONCRYPTO_COMMONCRYPTOR_H */
170
171/**
172 * The tripple DES cipher type (Apple CommonCrypto provider)
173 *
174 * @return the DES-EDE3-CBC EVP_CIPHER pointer.
175 *
176 * @ingroup hcrypto_evp
177 */
178
179const EVP_CIPHER *
180EVP_cc_des_ede3_cbc(void)
181{
182#ifdef HAVE_COMMONCRYPTO_COMMONCRYPTOR_H
183    static const EVP_CIPHER des_ede3_cbc = {
184	0,
185	8,
186	24,
187	8,
188	EVP_CIPH_CBC_MODE|EVP_CIPH_ALWAYS_CALL_INIT,
189	cc_des_ede3_cbc_init,
190	cc_do_cipher,
191	cc_cleanup,
192	sizeof(struct cc_key),
193	NULL,
194	NULL,
195	NULL,
196	NULL
197    };
198    return &des_ede3_cbc;
199#else
200    return NULL;
201#endif
202}
203
204#ifdef HAVE_COMMONCRYPTO_COMMONCRYPTOR_H
205/*
206 *
207 */
208
209static int
210cc_des_cbc_init(EVP_CIPHER_CTX *ctx,
211		const unsigned char * key,
212		const unsigned char * iv,
213		int encp)
214{
215    struct cc_key *cc = ctx->cipher_data;
216    return init_cc_key(encp, kCCAlgorithmDES, 0, key, kCCBlockSizeDES, iv, &cc->href);
217}
218#endif
219
220/**
221 * The DES cipher type (Apple CommonCrypto provider)
222 *
223 * @return the DES-CBC EVP_CIPHER pointer.
224 *
225 * @ingroup hcrypto_evp
226 */
227
228const EVP_CIPHER *
229EVP_cc_des_cbc(void)
230{
231#ifdef HAVE_COMMONCRYPTO_COMMONCRYPTOR_H
232    static const EVP_CIPHER des_ede3_cbc = {
233	0,
234	kCCBlockSizeDES,
235	kCCBlockSizeDES,
236	kCCBlockSizeDES,
237	EVP_CIPH_CBC_MODE|EVP_CIPH_ALWAYS_CALL_INIT,
238	cc_des_cbc_init,
239	cc_do_cipher,
240	cc_cleanup,
241	sizeof(struct cc_key),
242	NULL,
243	NULL,
244	NULL,
245	NULL
246    };
247    return &des_ede3_cbc;
248#else
249    return NULL;
250#endif
251}
252
253#ifdef HAVE_COMMONCRYPTO_COMMONCRYPTOR_H
254/*
255 *
256 */
257
258static int
259cc_aes_cbc_init(EVP_CIPHER_CTX *ctx,
260		const unsigned char * key,
261		const unsigned char * iv,
262		int encp)
263{
264    struct cc_key *cc = ctx->cipher_data;
265    return init_cc_key(encp, kCCAlgorithmAES128, 0, key, ctx->cipher->key_len, iv, &cc->href);
266}
267#endif
268
269/**
270 * The AES-128 cipher type (Apple CommonCrypto provider)
271 *
272 * @return the AES-128-CBC EVP_CIPHER pointer.
273 *
274 * @ingroup hcrypto_evp
275 */
276
277const EVP_CIPHER *
278EVP_cc_aes_128_cbc(void)
279{
280#ifdef HAVE_COMMONCRYPTO_COMMONCRYPTOR_H
281    static const EVP_CIPHER c = {
282	0,
283	kCCBlockSizeAES128,
284	kCCKeySizeAES128,
285	kCCBlockSizeAES128,
286	EVP_CIPH_CBC_MODE|EVP_CIPH_ALWAYS_CALL_INIT,
287	cc_aes_cbc_init,
288	cc_do_cipher,
289	cc_cleanup,
290	sizeof(struct cc_key),
291	NULL,
292	NULL,
293	NULL,
294	NULL
295    };
296    return &c;
297#else
298    return NULL;
299#endif
300}
301
302/**
303 * The AES-192 cipher type (Apple CommonCrypto provider)
304 *
305 * @return the AES-192-CBC EVP_CIPHER pointer.
306 *
307 * @ingroup hcrypto_evp
308 */
309
310const EVP_CIPHER *
311EVP_cc_aes_192_cbc(void)
312{
313#ifdef HAVE_COMMONCRYPTO_COMMONCRYPTOR_H
314    static const EVP_CIPHER c = {
315	0,
316	kCCBlockSizeAES128,
317	kCCKeySizeAES192,
318	kCCBlockSizeAES128,
319	EVP_CIPH_CBC_MODE|EVP_CIPH_ALWAYS_CALL_INIT,
320	cc_aes_cbc_init,
321	cc_do_cipher,
322	cc_cleanup,
323	sizeof(struct cc_key),
324	NULL,
325	NULL,
326	NULL,
327	NULL
328    };
329    return &c;
330#else
331    return NULL;
332#endif
333}
334
335/**
336 * The AES-256 cipher type (Apple CommonCrypto provider)
337 *
338 * @return the AES-256-CBC EVP_CIPHER pointer.
339 *
340 * @ingroup hcrypto_evp
341 */
342
343const EVP_CIPHER *
344EVP_cc_aes_256_cbc(void)
345{
346#ifdef HAVE_COMMONCRYPTO_COMMONCRYPTOR_H
347    static const EVP_CIPHER c = {
348	0,
349	kCCBlockSizeAES128,
350	kCCKeySizeAES256,
351	kCCBlockSizeAES128,
352	EVP_CIPH_CBC_MODE|EVP_CIPH_ALWAYS_CALL_INIT,
353	cc_aes_cbc_init,
354	cc_do_cipher,
355	cc_cleanup,
356	sizeof(struct cc_key),
357	NULL,
358	NULL,
359	NULL,
360	NULL
361    };
362    return &c;
363#else
364    return NULL;
365#endif
366}
367
368#ifdef HAVE_COMMONCRYPTO_COMMONCRYPTOR_H
369/*
370 *
371 */
372
373static int
374cc_aes_cfb8_init(EVP_CIPHER_CTX *ctx,
375		const unsigned char * key,
376		const unsigned char * iv,
377		int encp)
378{
379    struct cc_key *cc = ctx->cipher_data;
380    memcpy(ctx->iv, iv, ctx->cipher->iv_len);
381    return init_cc_key(1, kCCAlgorithmAES128, kCCOptionECBMode,
382		       key, ctx->cipher->key_len, NULL, &cc->href);
383}
384#endif
385
386/**
387 * The AES-128 CFB8 cipher type (Apple CommonCrypto provider)
388 *
389 * @return the AES-128-CFB8 EVP_CIPHER pointer.
390 *
391 * @ingroup hcrypto_evp
392 */
393
394const EVP_CIPHER *
395EVP_cc_aes_128_cfb8(void)
396{
397#ifdef HAVE_COMMONCRYPTO_COMMONCRYPTOR_H
398    static const EVP_CIPHER c = {
399	0,
400	1,
401	kCCKeySizeAES128,
402	kCCBlockSizeAES128,
403	EVP_CIPH_CFB8_MODE|EVP_CIPH_ALWAYS_CALL_INIT,
404	cc_aes_cfb8_init,
405	cc_do_cfb8_cipher,
406	cc_cleanup,
407	sizeof(struct cc_key),
408	NULL,
409	NULL,
410	NULL,
411	NULL
412    };
413    return &c;
414#else
415    return NULL;
416#endif
417}
418
419/**
420 * The AES-192 CFB8 cipher type (Apple CommonCrypto provider)
421 *
422 * @return the AES-192-CFB8 EVP_CIPHER pointer.
423 *
424 * @ingroup hcrypto_evp
425 */
426
427const EVP_CIPHER *
428EVP_cc_aes_192_cfb8(void)
429{
430#ifdef HAVE_COMMONCRYPTO_COMMONCRYPTOR_H
431    static const EVP_CIPHER c = {
432	0,
433	1,
434	kCCKeySizeAES192,
435	kCCBlockSizeAES128,
436	EVP_CIPH_CFB8_MODE|EVP_CIPH_ALWAYS_CALL_INIT,
437	cc_aes_cfb8_init,
438	cc_do_cfb8_cipher,
439	cc_cleanup,
440	sizeof(struct cc_key),
441	NULL,
442	NULL,
443	NULL,
444	NULL
445    };
446    return &c;
447#else
448    return NULL;
449#endif
450}
451
452/**
453 * The AES-256 CFB8 cipher type (Apple CommonCrypto provider)
454 *
455 * @return the AES-256-CFB8 EVP_CIPHER pointer.
456 *
457 * @ingroup hcrypto_evp
458 */
459
460const EVP_CIPHER *
461EVP_cc_aes_256_cfb8(void)
462{
463#ifdef HAVE_COMMONCRYPTO_COMMONCRYPTOR_H
464    static const EVP_CIPHER c = {
465	0,
466	kCCBlockSizeAES128,
467	kCCKeySizeAES256,
468	kCCBlockSizeAES128,
469	EVP_CIPH_CFB8_MODE|EVP_CIPH_ALWAYS_CALL_INIT,
470	cc_aes_cfb8_init,
471	cc_do_cfb8_cipher,
472	cc_cleanup,
473	sizeof(struct cc_key),
474	NULL,
475	NULL,
476	NULL,
477	NULL
478    };
479    return &c;
480#else
481    return NULL;
482#endif
483}
484
485/*
486 *
487 */
488
489#ifdef COMMONCRYPTO_SUPPORTS_RC2
490static int
491cc_rc2_cbc_init(EVP_CIPHER_CTX *ctx,
492		const unsigned char * key,
493		const unsigned char * iv,
494		int encp)
495{
496    struct cc_key *cc = ctx->cipher_data;
497    return init_cc_key(encp, kCCAlgorithmRC2, 0, key, ctx->cipher->key_len, iv, &cc->href);
498}
499#endif
500
501/**
502 * The RC2 cipher type - common crypto
503 *
504 * @return the RC2 EVP_CIPHER pointer.
505 *
506 * @ingroup hcrypto_evp
507 */
508
509
510const EVP_CIPHER *
511EVP_cc_rc2_cbc(void)
512{
513#ifdef COMMONCRYPTO_SUPPORTS_RC2
514    static const EVP_CIPHER rc2_cbc = {
515	0,
516	kCCBlockSizeRC2,
517	16,
518	kCCBlockSizeRC2,
519	EVP_CIPH_CBC_MODE|EVP_CIPH_ALWAYS_CALL_INIT,
520	cc_rc2_cbc_init,
521	cc_do_cipher,
522	cc_cleanup,
523	sizeof(struct cc_key),
524	NULL,
525	NULL,
526	NULL,
527	NULL
528    };
529    return &rc2_cbc;
530#else
531    return NULL;
532#endif
533}
534
535/**
536 * The RC2-40 cipher type - common crypto
537 *
538 * @return the RC2-40 EVP_CIPHER pointer.
539 *
540 * @ingroup hcrypto_evp
541 */
542
543
544const EVP_CIPHER *
545EVP_cc_rc2_40_cbc(void)
546{
547#ifdef COMMONCRYPTO_SUPPORTS_RC2
548    static const EVP_CIPHER rc2_40_cbc = {
549	0,
550	kCCBlockSizeRC2,
551	5,
552	kCCBlockSizeRC2,
553	EVP_CIPH_CBC_MODE|EVP_CIPH_ALWAYS_CALL_INIT,
554	cc_rc2_cbc_init,
555	cc_do_cipher,
556	cc_cleanup,
557	sizeof(struct cc_key),
558	NULL,
559	NULL,
560	NULL,
561	NULL
562    };
563    return &rc2_40_cbc;
564#else
565    return NULL;
566#endif
567}
568
569
570/**
571 * The RC2-64 cipher type - common crypto
572 *
573 * @return the RC2-64 EVP_CIPHER pointer.
574 *
575 * @ingroup hcrypto_evp
576 */
577
578
579const EVP_CIPHER *
580EVP_cc_rc2_64_cbc(void)
581{
582#ifdef COMMONCRYPTO_SUPPORTS_RC2
583    static const EVP_CIPHER rc2_64_cbc = {
584	0,
585	kCCBlockSizeRC2,
586	8,
587	kCCBlockSizeRC2,
588	EVP_CIPH_CBC_MODE|EVP_CIPH_ALWAYS_CALL_INIT,
589	cc_rc2_cbc_init,
590	cc_do_cipher,
591	cc_cleanup,
592	sizeof(struct cc_key),
593	NULL,
594	NULL,
595	NULL,
596	NULL
597    };
598    return &rc2_64_cbc;
599#else
600    return NULL;
601#endif
602}
603
604/**
605 * The CommonCrypto md2 provider
606 *
607 * @ingroup hcrypto_evp
608 */
609
610const EVP_MD *
611EVP_cc_md2(void)
612{
613#ifdef HAVE_COMMONCRYPTO_COMMONDIGEST_H
614    static const struct hc_evp_md md2 = {
615	CC_MD2_DIGEST_LENGTH,
616	CC_MD2_BLOCK_BYTES,
617	sizeof(CC_MD2_CTX),
618	(hc_evp_md_init)CC_MD2_Init,
619	(hc_evp_md_update)CC_MD2_Update,
620	(hc_evp_md_final)CC_MD2_Final,
621	(hc_evp_md_cleanup)NULL
622    };
623    return &md2;
624#else
625    return NULL;
626#endif
627}
628
629/**
630 * The CommonCrypto md4 provider
631 *
632 * @ingroup hcrypto_evp
633 */
634
635const EVP_MD *
636EVP_cc_md4(void)
637{
638#ifdef HAVE_COMMONCRYPTO_COMMONDIGEST_H
639    static const struct hc_evp_md md4 = {
640	CC_MD4_DIGEST_LENGTH,
641	CC_MD4_BLOCK_BYTES,
642	sizeof(CC_MD4_CTX),
643	(hc_evp_md_init)CC_MD4_Init,
644	(hc_evp_md_update)CC_MD4_Update,
645	(hc_evp_md_final)CC_MD4_Final,
646	(hc_evp_md_cleanup)NULL
647    };
648    return &md4;
649#else
650    return NULL;
651#endif
652}
653
654/**
655 * The CommonCrypto md5 provider
656 *
657 * @ingroup hcrypto_evp
658 */
659
660const EVP_MD *
661EVP_cc_md5(void)
662{
663#ifdef HAVE_COMMONCRYPTO_COMMONDIGEST_H
664    static const struct hc_evp_md md5 = {
665	CC_MD5_DIGEST_LENGTH,
666	CC_MD5_BLOCK_BYTES,
667	sizeof(CC_MD5_CTX),
668	(hc_evp_md_init)CC_MD5_Init,
669	(hc_evp_md_update)CC_MD5_Update,
670	(hc_evp_md_final)CC_MD5_Final,
671	(hc_evp_md_cleanup)NULL
672    };
673    return &md5;
674#else
675    return NULL;
676#endif
677}
678
679/**
680 * The CommonCrypto sha1 provider
681 *
682 * @ingroup hcrypto_evp
683 */
684
685const EVP_MD *
686EVP_cc_sha1(void)
687{
688#ifdef HAVE_COMMONCRYPTO_COMMONDIGEST_H
689    static const struct hc_evp_md sha1 = {
690	CC_SHA1_DIGEST_LENGTH,
691	CC_SHA1_BLOCK_BYTES,
692	sizeof(CC_SHA1_CTX),
693	(hc_evp_md_init)CC_SHA1_Init,
694	(hc_evp_md_update)CC_SHA1_Update,
695	(hc_evp_md_final)CC_SHA1_Final,
696	(hc_evp_md_cleanup)NULL
697    };
698    return &sha1;
699#else
700    return NULL;
701#endif
702}
703
704/**
705 * The CommonCrypto sha256 provider
706 *
707 * @ingroup hcrypto_evp
708 */
709
710const EVP_MD *
711EVP_cc_sha256(void)
712{
713#ifdef HAVE_COMMONCRYPTO_COMMONDIGEST_H
714    static const struct hc_evp_md sha256 = {
715	CC_SHA256_DIGEST_LENGTH,
716	CC_SHA256_BLOCK_BYTES,
717	sizeof(CC_SHA256_CTX),
718	(hc_evp_md_init)CC_SHA256_Init,
719	(hc_evp_md_update)CC_SHA256_Update,
720	(hc_evp_md_final)CC_SHA256_Final,
721	(hc_evp_md_cleanup)NULL
722    };
723    return &sha256;
724#else
725    return NULL;
726#endif
727}
728
729/**
730 * The Camellia-128 cipher type - CommonCrypto
731 *
732 * @return the Camellia-128 EVP_CIPHER pointer.
733 *
734 * @ingroup hcrypto_evp
735 */
736
737const EVP_CIPHER *
738EVP_cc_camellia_128_cbc(void)
739{
740    return NULL;
741}
742
743/**
744 * The Camellia-198 cipher type - CommonCrypto
745 *
746 * @return the Camellia-198 EVP_CIPHER pointer.
747 *
748 * @ingroup hcrypto_evp
749 */
750
751const EVP_CIPHER *
752EVP_cc_camellia_192_cbc(void)
753{
754    return NULL;
755}
756
757/**
758 * The Camellia-256 cipher type - CommonCrypto
759 *
760 * @return the Camellia-256 EVP_CIPHER pointer.
761 *
762 * @ingroup hcrypto_evp
763 */
764
765const EVP_CIPHER *
766EVP_cc_camellia_256_cbc(void)
767{
768    return NULL;
769}
770
771#ifdef HAVE_COMMONCRYPTO_COMMONCRYPTOR_H
772
773/*
774 *
775 */
776
777static int
778cc_rc4_init(EVP_CIPHER_CTX *ctx,
779	    const unsigned char * key,
780	    const unsigned char * iv,
781	    int encp)
782{
783    struct cc_key *cc = ctx->cipher_data;
784    return init_cc_key(encp, kCCAlgorithmRC4, 0, key, ctx->key_len, iv, &cc->href);
785}
786
787#endif
788
789/**
790
791 * The RC4 cipher type (Apple CommonCrypto provider)
792 *
793 * @return the RC4 EVP_CIPHER pointer.
794 *
795 * @ingroup hcrypto_evp
796 */
797
798const EVP_CIPHER *
799EVP_cc_rc4(void)
800{
801#ifdef HAVE_COMMONCRYPTO_COMMONCRYPTOR_H
802    static const EVP_CIPHER rc4 = {
803	0,
804	1,
805	16,
806	0,
807	EVP_CIPH_STREAM_CIPHER|EVP_CIPH_VARIABLE_LENGTH,
808	cc_rc4_init,
809	cc_do_cipher,
810	cc_cleanup,
811	sizeof(struct cc_key),
812	NULL,
813	NULL,
814	NULL,
815	NULL
816    };
817    return &rc4;
818#else
819    return NULL;
820#endif
821}
822
823
824/**
825 * The RC4-40 cipher type (Apple CommonCrypto provider)
826 *
827 * @return the RC4 EVP_CIPHER pointer.
828 *
829 * @ingroup hcrypto_evp
830 */
831
832const EVP_CIPHER *
833EVP_cc_rc4_40(void)
834{
835#ifdef HAVE_COMMONCRYPTO_COMMONCRYPTOR_H
836    static const EVP_CIPHER rc4_40 = {
837	0,
838	1,
839	5,
840	0,
841	EVP_CIPH_STREAM_CIPHER|EVP_CIPH_VARIABLE_LENGTH,
842	cc_rc4_init,
843	cc_do_cipher,
844	cc_cleanup,
845	sizeof(struct cc_key),
846	NULL,
847	NULL,
848	NULL,
849	NULL
850    };
851    return &rc4_40;
852#else
853    return NULL;
854#endif
855}
856
857#endif /* __APPLE__ */
858
859