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