/* [<][>][^][v][top][bottom][index][help] */
DEFINITIONS
This source file includes following definitions.
- EVP_MD_size
- EVP_MD_block_size
- EVP_MD_CTX_create
- EVP_MD_CTX_init
- EVP_MD_CTX_destroy
- EVP_MD_CTX_cleanup
- EVP_MD_CTX_md
- EVP_MD_CTX_size
- EVP_MD_CTX_block_size
- EVP_DigestInit_ex
- EVP_DigestUpdate
- EVP_DigestFinal_ex
- EVP_Digest
- EVP_sha256
- EVP_sha1
- EVP_sha
- EVP_md5
- EVP_md4
- EVP_md2
- null_Init
- null_Update
- null_Final
- EVP_md_null
- EVP_CIPHER_block_size
- EVP_CIPHER_key_length
- EVP_CIPHER_iv_length
- EVP_CIPHER_CTX_init
- EVP_CIPHER_CTX_cleanup
- EVP_CIPHER_CTX_set_key_length
- EVP_CIPHER_CTX_set_padding
- EVP_CIPHER_CTX_cipher
- EVP_CIPHER_CTX_block_size
- EVP_CIPHER_CTX_key_length
- EVP_CIPHER_CTX_iv_length
- EVP_CIPHER_CTX_flags
- EVP_CIPHER_CTX_mode
- EVP_CIPHER_CTX_get_app_data
- EVP_CIPHER_CTX_set_app_data
- EVP_CipherInit_ex
- EVP_CipherUpdate
- EVP_CipherFinal_ex
- EVP_Cipher
- enc_null_init
- enc_null_do_cipher
- enc_null_cleanup
- EVP_enc_null
- rc2_init
- rc2_do_cipher
- rc2_cleanup
- EVP_rc2_cbc
- EVP_rc2_40_cbc
- EVP_rc2_64_cbc
- EVP_rc4
- EVP_rc4_40
- des_cbc_init
- des_cbc_do_cipher
- des_cbc_cleanup
- EVP_des_cbc
- des_ede3_cbc_init
- des_ede3_cbc_do_cipher
- des_ede3_cbc_cleanup
- EVP_des_ede3_cbc
- EVP_aes_128_cbc
- EVP_aes_192_cbc
- EVP_aes_256_cbc
- camellia_init
- camellia_do_cipher
- camellia_cleanup
- EVP_camellia_128_cbc
- EVP_camellia_192_cbc
- EVP_camellia_256_cbc
- EVP_get_cipherbyname
- EVP_BytesToKey
- EVP_CIPHER_CTX_rand_key
- EVP_CIPHER_CTX_ctrl
- OpenSSL_add_all_algorithms
- OpenSSL_add_all_algorithms_conf
- OpenSSL_add_all_algorithms_noconf
1 /*
2 * Copyright (c) 2006 - 2007 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 #ifdef HAVE_CONFIG_H
35 #include <config.h>
36 #endif
37
38 RCSID("$Id$");
39
40 #define HC_DEPRECATED
41 #define HC_DEPRECATED_CRYPTO
42
43 #include <sys/types.h>
44 #include <stdio.h>
45 #include <stdlib.h>
46 #include <string.h>
47 #include <assert.h>
48
49 #include <evp.h>
50
51 #include <krb5-types.h>
52
53 #include "camellia.h"
54 #include <des.h>
55 #include <sha.h>
56 #include <rc2.h>
57 #include <rc4.h>
58 #include <md2.h>
59 #include <md4.h>
60 #include <md5.h>
61
62 /**
63 * @page page_evp EVP - generic crypto interface
64 *
65 * See the library functions here: @ref hcrypto_evp
66 *
67 * @section evp_cipher EVP Cipher
68 *
69 * The use of EVP_CipherInit_ex() and EVP_Cipher() is pretty easy to
70 * understand forward, then EVP_CipherUpdate() and
71 * EVP_CipherFinal_ex() really needs an example to explain @ref
72 * example_evp_cipher.c .
73 *
74 * @example example_evp_cipher.c
75 *
76 * This is an example how to use EVP_CipherInit_ex(),
77 * EVP_CipherUpdate() and EVP_CipherFinal_ex().
78 */
79
80 struct hc_EVP_MD_CTX {
81 const EVP_MD *md;
82 ENGINE *engine;
83 void *ptr;
84 };
85
86
87 /**
88 * Return the output size of the message digest function.
89 *
90 * @param md the evp message
91 *
92 * @return size output size of the message digest function.
93 *
94 * @ingroup hcrypto_evp
95 */
96
97 size_t
98 EVP_MD_size(const EVP_MD *md)
/* [<][>][^][v][top][bottom][index][help] */
99 {
100 return md->hash_size;
101 }
102
103 /**
104 * Return the blocksize of the message digest function.
105 *
106 * @param md the evp message
107 *
108 * @return size size of the message digest block size
109 *
110 * @ingroup hcrypto_evp
111 */
112
113 size_t
114 EVP_MD_block_size(const EVP_MD *md)
/* [<][>][^][v][top][bottom][index][help] */
115 {
116 return md->block_size;
117 }
118
119 /**
120 * Allocate a messsage digest context object. Free with
121 * EVP_MD_CTX_destroy().
122 *
123 * @return a newly allocated message digest context object.
124 *
125 * @ingroup hcrypto_evp
126 */
127
128 EVP_MD_CTX *
129 EVP_MD_CTX_create(void)
/* [<][>][^][v][top][bottom][index][help] */
130 {
131 return calloc(1, sizeof(EVP_MD_CTX));
132 }
133
134 /**
135 * Initiate a messsage digest context object. Deallocate with
136 * EVP_MD_CTX_cleanup(). Please use EVP_MD_CTX_create() instead.
137 *
138 * @param ctx variable to initiate.
139 *
140 * @ingroup hcrypto_evp
141 */
142
143 void HC_DEPRECATED
144 EVP_MD_CTX_init(EVP_MD_CTX *ctx)
/* [<][>][^][v][top][bottom][index][help] */
145 {
146 memset(ctx, 0, sizeof(*ctx));
147 }
148
149 /**
150 * Free a messsage digest context object.
151 *
152 * @param ctx context to free.
153 *
154 * @ingroup hcrypto_evp
155 */
156
157 void
158 EVP_MD_CTX_destroy(EVP_MD_CTX *ctx)
/* [<][>][^][v][top][bottom][index][help] */
159 {
160 EVP_MD_CTX_cleanup(ctx);
161 free(ctx);
162 }
163
164 /**
165 * Free the resources used by the EVP_MD context.
166 *
167 * @param ctx the context to free the resources from.
168 *
169 * @return 1 on success.
170 *
171 * @ingroup hcrypto_evp
172 */
173
174 int HC_DEPRECATED
175 EVP_MD_CTX_cleanup(EVP_MD_CTX *ctx)
/* [<][>][^][v][top][bottom][index][help] */
176 {
177 if (ctx->md && ctx->md->cleanup)
178 (ctx->md->cleanup)(ctx);
179 ctx->md = NULL;
180 ctx->engine = NULL;
181 free(ctx->ptr);
182 memset(ctx, 0, sizeof(*ctx));
183 return 1;
184 }
185
186 /**
187 * Get the EVP_MD use for a specified context.
188 *
189 * @param ctx the EVP_MD context to get the EVP_MD for.
190 *
191 * @return the EVP_MD used for the context.
192 *
193 * @ingroup hcrypto_evp
194 */
195
196 const EVP_MD *
197 EVP_MD_CTX_md(EVP_MD_CTX *ctx)
/* [<][>][^][v][top][bottom][index][help] */
198 {
199 return ctx->md;
200 }
201
202 /**
203 * Return the output size of the message digest function.
204 *
205 * @param ctx the evp message digest context
206 *
207 * @return size output size of the message digest function.
208 *
209 * @ingroup hcrypto_evp
210 */
211
212 size_t
213 EVP_MD_CTX_size(EVP_MD_CTX *ctx)
/* [<][>][^][v][top][bottom][index][help] */
214 {
215 return EVP_MD_size(ctx->md);
216 }
217
218 /**
219 * Return the blocksize of the message digest function.
220 *
221 * @param ctx the evp message digest context
222 *
223 * @return size size of the message digest block size
224 *
225 * @ingroup hcrypto_evp
226 */
227
228 size_t
229 EVP_MD_CTX_block_size(EVP_MD_CTX *ctx)
/* [<][>][^][v][top][bottom][index][help] */
230 {
231 return EVP_MD_block_size(ctx->md);
232 }
233
234 /**
235 * Init a EVP_MD_CTX for use a specific message digest and engine.
236 *
237 * @param ctx the message digest context to init.
238 * @param md the message digest to use.
239 * @param engine the engine to use, NULL to use the default engine.
240 *
241 * @return 1 on success.
242 *
243 * @ingroup hcrypto_evp
244 */
245
246 int
247 EVP_DigestInit_ex(EVP_MD_CTX *ctx, const EVP_MD *md, ENGINE *engine)
/* [<][>][^][v][top][bottom][index][help] */
248 {
249 if (ctx->md != md || ctx->engine != engine) {
250 EVP_MD_CTX_cleanup(ctx);
251 ctx->md = md;
252 ctx->engine = engine;
253
254 ctx->ptr = calloc(1, md->ctx_size);
255 if (ctx->ptr == NULL)
256 return 0;
257 }
258 (ctx->md->init)(ctx->ptr);
259 return 1;
260 }
261
262 /**
263 * Update the digest with some data.
264 *
265 * @param ctx the context to update
266 * @param data the data to update the context with
267 * @param size length of data
268 *
269 * @return 1 on success.
270 *
271 * @ingroup hcrypto_evp
272 */
273
274 int
275 EVP_DigestUpdate(EVP_MD_CTX *ctx, const void *data, size_t size)
/* [<][>][^][v][top][bottom][index][help] */
276 {
277 (ctx->md->update)(ctx->ptr, data, size);
278 return 1;
279 }
280
281 /**
282 * Complete the message digest.
283 *
284 * @param ctx the context to complete.
285 * @param hash the output of the message digest function. At least
286 * EVP_MD_size().
287 * @param size the output size of hash.
288 *
289 * @return 1 on success.
290 *
291 * @ingroup hcrypto_evp
292 */
293
294 int
295 EVP_DigestFinal_ex(EVP_MD_CTX *ctx, void *hash, unsigned int *size)
/* [<][>][^][v][top][bottom][index][help] */
296 {
297 (ctx->md->final)(hash, ctx->ptr);
298 if (size)
299 *size = ctx->md->hash_size;
300 return 1;
301 }
302
303 /**
304 * Do the whole EVP_MD_CTX_create(), EVP_DigestInit_ex(),
305 * EVP_DigestUpdate(), EVP_DigestFinal_ex(), EVP_MD_CTX_destroy()
306 * dance in one call.
307 *
308 * @param data the data to update the context with
309 * @param dsize length of data
310 * @param hash output data of at least EVP_MD_size() length.
311 * @param hsize output length of hash.
312 * @param md message digest to use
313 * @param engine engine to use, NULL for default engine.
314 *
315 * @return 1 on success.
316 *
317 * @ingroup hcrypto_evp
318 */
319
320 int
321 EVP_Digest(const void *data, size_t dsize, void *hash, unsigned int *hsize,
/* [<][>][^][v][top][bottom][index][help] */
322 const EVP_MD *md, ENGINE *engine)
323 {
324 EVP_MD_CTX *ctx;
325 int ret;
326
327 ctx = EVP_MD_CTX_create();
328 if (ctx == NULL)
329 return 0;
330 ret = EVP_DigestInit_ex(ctx, md, engine);
331 if (ret != 1) {
332 EVP_MD_CTX_destroy(ctx);
333 return ret;
334 }
335 ret = EVP_DigestUpdate(ctx, data, dsize);
336 if (ret != 1) {
337 EVP_MD_CTX_destroy(ctx);
338 return ret;
339 }
340 ret = EVP_DigestFinal_ex(ctx, hash, hsize);
341 EVP_MD_CTX_destroy(ctx);
342 return ret;
343 }
344
345 /**
346 * The message digest SHA256
347 *
348 * @return the message digest type.
349 *
350 * @ingroup hcrypto_evp
351 */
352
353 const EVP_MD *
354 EVP_sha256(void)
/* [<][>][^][v][top][bottom][index][help] */
355 {
356 static const struct hc_evp_md sha256 = {
357 32,
358 64,
359 sizeof(SHA256_CTX),
360 (hc_evp_md_init)SHA256_Init,
361 (hc_evp_md_update)SHA256_Update,
362 (hc_evp_md_final)SHA256_Final,
363 NULL
364 };
365 return &sha256;
366 }
367
368 static const struct hc_evp_md sha1 = {
369 20,
370 64,
371 sizeof(SHA_CTX),
372 (hc_evp_md_init)SHA1_Init,
373 (hc_evp_md_update)SHA1_Update,
374 (hc_evp_md_final)SHA1_Final,
375 NULL
376 };
377
378 /**
379 * The message digest SHA1
380 *
381 * @return the message digest type.
382 *
383 * @ingroup hcrypto_evp
384 */
385
386 const EVP_MD *
387 EVP_sha1(void)
/* [<][>][^][v][top][bottom][index][help] */
388 {
389 return &sha1;
390 }
391
392 /**
393 * The message digest SHA1
394 *
395 * @return the message digest type.
396 *
397 * @ingroup hcrypto_evp
398 */
399
400 const EVP_MD *
401 EVP_sha(void)
/* [<][>][^][v][top][bottom][index][help] */
402 {
403 return &sha1;
404 }
405
406 /**
407 * The message digest MD5
408 *
409 * @return the message digest type.
410 *
411 * @ingroup hcrypto_evp
412 */
413
414 const EVP_MD *
415 EVP_md5(void)
/* [<][>][^][v][top][bottom][index][help] */
416 {
417 static const struct hc_evp_md md5 = {
418 16,
419 64,
420 sizeof(MD5_CTX),
421 (hc_evp_md_init)MD5_Init,
422 (hc_evp_md_update)MD5_Update,
423 (hc_evp_md_final)MD5_Final,
424 NULL
425 };
426 return &md5;
427 }
428
429 /**
430 * The message digest MD4
431 *
432 * @return the message digest type.
433 *
434 * @ingroup hcrypto_evp
435 */
436
437 const EVP_MD *
438 EVP_md4(void)
/* [<][>][^][v][top][bottom][index][help] */
439 {
440 static const struct hc_evp_md md4 = {
441 16,
442 64,
443 sizeof(MD4_CTX),
444 (hc_evp_md_init)MD4_Init,
445 (hc_evp_md_update)MD4_Update,
446 (hc_evp_md_final)MD4_Final,
447 NULL
448 };
449 return &md4;
450 }
451
452 /**
453 * The message digest MD2
454 *
455 * @return the message digest type.
456 *
457 * @ingroup hcrypto_evp
458 */
459
460 const EVP_MD *
461 EVP_md2(void)
/* [<][>][^][v][top][bottom][index][help] */
462 {
463 static const struct hc_evp_md md2 = {
464 16,
465 16,
466 sizeof(MD2_CTX),
467 (hc_evp_md_init)MD2_Init,
468 (hc_evp_md_update)MD2_Update,
469 (hc_evp_md_final)MD2_Final,
470 NULL
471 };
472 return &md2;
473 }
474
475 /*
476 *
477 */
478
479 static void
480 null_Init (void *m)
/* [<][>][^][v][top][bottom][index][help] */
481 {
482 }
483 static void
484 null_Update (void *m, const void * data, size_t size)
/* [<][>][^][v][top][bottom][index][help] */
485 {
486 }
487 static void
488 null_Final(void *res, void *m)
/* [<][>][^][v][top][bottom][index][help] */
489 {
490 }
491
492 /**
493 * The null message digest
494 *
495 * @return the message digest type.
496 *
497 * @ingroup hcrypto_evp
498 */
499
500 const EVP_MD *
501 EVP_md_null(void)
/* [<][>][^][v][top][bottom][index][help] */
502 {
503 static const struct hc_evp_md null = {
504 0,
505 0,
506 0,
507 (hc_evp_md_init)null_Init,
508 (hc_evp_md_update)null_Update,
509 (hc_evp_md_final)null_Final,
510 NULL
511 };
512 return &null;
513 }
514
515 #if 0
516 int EVP_DigestInit(EVP_MD_CTX *ctx, const EVP_MD *type);
517 int EVP_DigestFinal(EVP_MD_CTX *ctx,unsigned char *md,unsigned int *s);
518 int EVP_SignFinal(EVP_MD_CTX *, void *, size_t *, EVP_PKEY *);
519 int EVP_VerifyFinal(EVP_MD_CTX *, const void *, size_t, EVP_PKEY *);
520 #endif
521
522 /**
523 * Return the block size of the cipher.
524 *
525 * @param c cipher to get the block size from.
526 *
527 * @return the block size of the cipher.
528 *
529 * @ingroup hcrypto_evp
530 */
531
532 size_t
533 EVP_CIPHER_block_size(const EVP_CIPHER *c)
/* [<][>][^][v][top][bottom][index][help] */
534 {
535 return c->block_size;
536 }
537
538 /**
539 * Return the key size of the cipher.
540 *
541 * @param c cipher to get the key size from.
542 *
543 * @return the key size of the cipher.
544 *
545 * @ingroup hcrypto_evp
546 */
547
548 size_t
549 EVP_CIPHER_key_length(const EVP_CIPHER *c)
/* [<][>][^][v][top][bottom][index][help] */
550 {
551 return c->key_len;
552 }
553
554 /**
555 * Return the IV size of the cipher.
556 *
557 * @param c cipher to get the IV size from.
558 *
559 * @return the IV size of the cipher.
560 *
561 * @ingroup hcrypto_evp
562 */
563
564 size_t
565 EVP_CIPHER_iv_length(const EVP_CIPHER *c)
/* [<][>][^][v][top][bottom][index][help] */
566 {
567 return c->iv_len;
568 }
569
570 /**
571 * Initiate a EVP_CIPHER_CTX context. Clean up with
572 * EVP_CIPHER_CTX_cleanup().
573 *
574 * @param c the cipher initiate.
575 *
576 * @ingroup hcrypto_evp
577 */
578
579 void
580 EVP_CIPHER_CTX_init(EVP_CIPHER_CTX *c)
/* [<][>][^][v][top][bottom][index][help] */
581 {
582 memset(c, 0, sizeof(*c));
583 }
584
585 /**
586 * Clean up the EVP_CIPHER_CTX context.
587 *
588 * @param c the cipher to clean up.
589 *
590 * @return 1 on success.
591 *
592 * @ingroup hcrypto_evp
593 */
594
595 int
596 EVP_CIPHER_CTX_cleanup(EVP_CIPHER_CTX *c)
/* [<][>][^][v][top][bottom][index][help] */
597 {
598 if (c->cipher && c->cipher->cleanup)
599 c->cipher->cleanup(c);
600 if (c->cipher_data) {
601 free(c->cipher_data);
602 c->cipher_data = NULL;
603 }
604 return 1;
605 }
606
607 #if 0
608 int
609 EVP_CIPHER_CTX_set_key_length(EVP_CIPHER_CTX *c, int length)
/* [<][>][^][v][top][bottom][index][help] */
610 {
611 return 0;
612 }
613
614 int
615 EVP_CIPHER_CTX_set_padding(EVP_CIPHER_CTX *c, int pad)
/* [<][>][^][v][top][bottom][index][help] */
616 {
617 return 0;
618 }
619 #endif
620
621 /**
622 * Return the EVP_CIPHER for a EVP_CIPHER_CTX context.
623 *
624 * @param ctx the context to get the cipher type from.
625 *
626 * @return the EVP_CIPHER pointer.
627 *
628 * @ingroup hcrypto_evp
629 */
630
631 const EVP_CIPHER *
632 EVP_CIPHER_CTX_cipher(EVP_CIPHER_CTX *ctx)
/* [<][>][^][v][top][bottom][index][help] */
633 {
634 return ctx->cipher;
635 }
636
637 /**
638 * Return the block size of the cipher context.
639 *
640 * @param ctx cipher context to get the block size from.
641 *
642 * @return the block size of the cipher context.
643 *
644 * @ingroup hcrypto_evp
645 */
646
647 size_t
648 EVP_CIPHER_CTX_block_size(const EVP_CIPHER_CTX *ctx)
/* [<][>][^][v][top][bottom][index][help] */
649 {
650 return EVP_CIPHER_block_size(ctx->cipher);
651 }
652
653 /**
654 * Return the key size of the cipher context.
655 *
656 * @param ctx cipher context to get the key size from.
657 *
658 * @return the key size of the cipher context.
659 *
660 * @ingroup hcrypto_evp
661 */
662
663 size_t
664 EVP_CIPHER_CTX_key_length(const EVP_CIPHER_CTX *ctx)
/* [<][>][^][v][top][bottom][index][help] */
665 {
666 return EVP_CIPHER_key_length(ctx->cipher);
667 }
668
669 /**
670 * Return the IV size of the cipher context.
671 *
672 * @param ctx cipher context to get the IV size from.
673 *
674 * @return the IV size of the cipher context.
675 *
676 * @ingroup hcrypto_evp
677 */
678
679 size_t
680 EVP_CIPHER_CTX_iv_length(const EVP_CIPHER_CTX *ctx)
/* [<][>][^][v][top][bottom][index][help] */
681 {
682 return EVP_CIPHER_iv_length(ctx->cipher);
683 }
684
685 /**
686 * Get the flags for an EVP_CIPHER_CTX context.
687 *
688 * @param ctx the EVP_CIPHER_CTX to get the flags from
689 *
690 * @return the flags for an EVP_CIPHER_CTX.
691 *
692 * @ingroup hcrypto_evp
693 */
694
695 unsigned long
696 EVP_CIPHER_CTX_flags(const EVP_CIPHER_CTX *ctx)
/* [<][>][^][v][top][bottom][index][help] */
697 {
698 return ctx->cipher->flags;
699 }
700
701 /**
702 * Get the mode for an EVP_CIPHER_CTX context.
703 *
704 * @param ctx the EVP_CIPHER_CTX to get the mode from
705 *
706 * @return the mode for an EVP_CIPHER_CTX.
707 *
708 * @ingroup hcrypto_evp
709 */
710
711 int
712 EVP_CIPHER_CTX_mode(const EVP_CIPHER_CTX *ctx)
/* [<][>][^][v][top][bottom][index][help] */
713 {
714 return EVP_CIPHER_CTX_flags(ctx) & EVP_CIPH_MODE;
715 }
716
717 /**
718 * Get the app data for an EVP_CIPHER_CTX context.
719 *
720 * @param ctx the EVP_CIPHER_CTX to get the app data from
721 *
722 * @return the app data for an EVP_CIPHER_CTX.
723 *
724 * @ingroup hcrypto_evp
725 */
726
727 void *
728 EVP_CIPHER_CTX_get_app_data(EVP_CIPHER_CTX *ctx)
/* [<][>][^][v][top][bottom][index][help] */
729 {
730 return ctx->app_data;
731 }
732
733 /**
734 * Set the app data for an EVP_CIPHER_CTX context.
735 *
736 * @param ctx the EVP_CIPHER_CTX to set the app data for
737 * @param data the app data to set for an EVP_CIPHER_CTX.
738 *
739 * @ingroup hcrypto_evp
740 */
741
742 void
743 EVP_CIPHER_CTX_set_app_data(EVP_CIPHER_CTX *ctx, void *data)
/* [<][>][^][v][top][bottom][index][help] */
744 {
745 ctx->app_data = data;
746 }
747
748 /**
749 * Initiate the EVP_CIPHER_CTX context to encrypt or decrypt data.
750 * Clean up with EVP_CIPHER_CTX_cleanup().
751 *
752 * @param ctx context to initiate
753 * @param c cipher to use.
754 * @param engine crypto engine to use, NULL to select default.
755 * @param key the crypto key to use, NULL will use the previous value.
756 * @param iv the IV to use, NULL will use the previous value.
757 * @param encp non zero will encrypt, -1 use the previous value.
758 *
759 * @return 1 on success.
760 *
761 * @ingroup hcrypto_evp
762 */
763
764 int
765 EVP_CipherInit_ex(EVP_CIPHER_CTX *ctx, const EVP_CIPHER *c, ENGINE *engine,
/* [<][>][^][v][top][bottom][index][help] */
766 const void *key, const void *iv, int encp)
767 {
768 ctx->buf_len = 0;
769
770 if (encp == -1)
771 encp = ctx->encrypt;
772 else
773 ctx->encrypt = (encp ? 1 : 0);
774
775 if (c && (c != ctx->cipher)) {
776 EVP_CIPHER_CTX_cleanup(ctx);
777 ctx->cipher = c;
778 ctx->key_len = c->key_len;
779
780 ctx->cipher_data = malloc(c->ctx_size);
781 if (ctx->cipher_data == NULL && c->ctx_size != 0)
782 return 0;
783
784 /* assume block size is a multiple of 2 */
785 ctx->block_mask = EVP_CIPHER_block_size(c) - 1;
786
787 } else if (ctx->cipher == NULL) {
788 /* reuse of cipher, but not any cipher ever set! */
789 return 0;
790 }
791
792 switch (EVP_CIPHER_CTX_flags(ctx)) {
793 case EVP_CIPH_CBC_MODE:
794
795 assert(EVP_CIPHER_CTX_iv_length(ctx) <= sizeof(ctx->iv));
796
797 if (iv)
798 memcpy(ctx->oiv, iv, EVP_CIPHER_CTX_iv_length(ctx));
799 memcpy(ctx->iv, ctx->oiv, EVP_CIPHER_CTX_iv_length(ctx));
800 break;
801 default:
802 return 0;
803 }
804
805 if (key || (ctx->cipher->flags & EVP_CIPH_ALWAYS_CALL_INIT))
806 ctx->cipher->init(ctx, key, iv, encp);
807
808 return 1;
809 }
810
811 /**
812 * Encipher/decipher partial data
813 *
814 * @param ctx the cipher context.
815 * @param out output data from the operation.
816 * @param outlen output length
817 * @param in input data to the operation.
818 * @param inlen length of data.
819 *
820 * The output buffer length should at least be EVP_CIPHER_block_size()
821 * byte longer then the input length.
822 *
823 * See @ref evp_cipher for an example how to use this function.
824 *
825 * @return 1 on success.
826 *
827 * @ingroup hcrypto_evp
828 */
829
830 int
831 EVP_CipherUpdate(EVP_CIPHER_CTX *ctx, void *out, int *outlen,
/* [<][>][^][v][top][bottom][index][help] */
832 void *in, size_t inlen)
833 {
834 int ret, left, blocksize;
835
836 *outlen = 0;
837
838 /**
839 * If there in no spare bytes in the left from last Update and the
840 * input length is on the block boundery, the EVP_CipherUpdate()
841 * function can take a shortcut (and preformance gain) and
842 * directly encrypt the data, otherwise we hav to fix it up and
843 * store extra it the EVP_CIPHER_CTX.
844 */
845 if (ctx->buf_len == 0 && (inlen & ctx->block_mask) == 0) {
846 ret = (*ctx->cipher->do_cipher)(ctx, out, in, inlen);
847 if (ret == 1)
848 *outlen = inlen;
849 else
850 *outlen = 0;
851 return ret;
852 }
853
854
855 blocksize = EVP_CIPHER_CTX_block_size(ctx);
856 left = blocksize - ctx->buf_len;
857 assert(left > 0);
858
859 if (ctx->buf_len) {
860
861 /* if total buffer is smaller then input, store locally */
862 if (inlen < left) {
863 memcpy(ctx->buf + ctx->buf_len, in, inlen);
864 ctx->buf_len += inlen;
865 return 1;
866 }
867
868 /* fill in local buffer and encrypt */
869 memcpy(ctx->buf + ctx->buf_len, in, left);
870 ret = (*ctx->cipher->do_cipher)(ctx, out, ctx->buf, blocksize);
871 memset(ctx->buf, 0, blocksize);
872 if (ret != 1)
873 return ret;
874
875 *outlen += blocksize;
876 inlen -= left;
877 in = ((unsigned char *)in) + left;
878 out = ((unsigned char *)out) + blocksize;
879 ctx->buf_len = 0;
880 }
881
882 if (inlen) {
883 ctx->buf_len = (inlen & ctx->block_mask);
884 inlen &= ~ctx->block_mask;
885
886 ret = (*ctx->cipher->do_cipher)(ctx, out, in, inlen);
887 if (ret != 1)
888 return ret;
889
890 *outlen += inlen;
891
892 in = ((unsigned char *)in) + inlen;
893 memcpy(ctx->buf, in, ctx->buf_len);
894 }
895
896 return 1;
897 }
898
899 /**
900 * Encipher/decipher final data
901 *
902 * @param ctx the cipher context.
903 * @param out output data from the operation.
904 * @param outlen output length
905 *
906 * The input length needs to be at least EVP_CIPHER_block_size() bytes
907 * long.
908 *
909 * See @ref evp_cipher for an example how to use this function.
910 *
911 * @return 1 on success.
912 *
913 * @ingroup hcrypto_evp
914 */
915
916 int
917 EVP_CipherFinal_ex(EVP_CIPHER_CTX *ctx, void *out, int *outlen)
/* [<][>][^][v][top][bottom][index][help] */
918 {
919 *outlen = 0;
920
921 if (ctx->buf_len) {
922 int ret, left, blocksize;
923
924 blocksize = EVP_CIPHER_CTX_block_size(ctx);
925
926 left = blocksize - ctx->buf_len;
927 assert(left > 0);
928
929 /* zero fill local buffer */
930 memset(ctx->buf + ctx->buf_len, 0, left);
931 ret = (*ctx->cipher->do_cipher)(ctx, out, ctx->buf, blocksize);
932 memset(ctx->buf, 0, blocksize);
933 if (ret != 1)
934 return ret;
935
936 *outlen += blocksize;
937 }
938
939 return 1;
940 }
941
942 /**
943 * Encipher/decipher data
944 *
945 * @param ctx the cipher context.
946 * @param out out data from the operation.
947 * @param in in data to the operation.
948 * @param size length of data.
949 *
950 * @return 1 on success.
951 */
952
953 int
954 EVP_Cipher(EVP_CIPHER_CTX *ctx, void *out, const void *in,size_t size)
/* [<][>][^][v][top][bottom][index][help] */
955 {
956 return ctx->cipher->do_cipher(ctx, out, in, size);
957 }
958
959 /*
960 *
961 */
962
963 static int
964 enc_null_init(EVP_CIPHER_CTX *ctx,
/* [<][>][^][v][top][bottom][index][help] */
965 const unsigned char * key,
966 const unsigned char * iv,
967 int encp)
968 {
969 return 1;
970 }
971
972 static int
973 enc_null_do_cipher(EVP_CIPHER_CTX *ctx,
/* [<][>][^][v][top][bottom][index][help] */
974 unsigned char *out,
975 const unsigned char *in,
976 unsigned int size)
977 {
978 memmove(out, in, size);
979 return 1;
980 }
981
982 static int
983 enc_null_cleanup(EVP_CIPHER_CTX *ctx)
/* [<][>][^][v][top][bottom][index][help] */
984 {
985 return 1;
986 }
987
988 /**
989 * The NULL cipher type, does no encryption/decryption.
990 *
991 * @return the null EVP_CIPHER pointer.
992 *
993 * @ingroup hcrypto_evp
994 */
995
996 const EVP_CIPHER *
997 EVP_enc_null(void)
/* [<][>][^][v][top][bottom][index][help] */
998 {
999 static const EVP_CIPHER enc_null = {
1000 0,
1001 0,
1002 0,
1003 0,
1004 EVP_CIPH_CBC_MODE,
1005 enc_null_init,
1006 enc_null_do_cipher,
1007 enc_null_cleanup,
1008 0,
1009 NULL,
1010 NULL,
1011 NULL,
1012 NULL
1013 };
1014 return &enc_null;
1015 }
1016
1017 /*
1018 *
1019 */
1020
1021 struct rc2_cbc {
1022 unsigned int maximum_effective_key;
1023 RC2_KEY key;
1024 };
1025
1026 static int
1027 rc2_init(EVP_CIPHER_CTX *ctx,
/* [<][>][^][v][top][bottom][index][help] */
1028 const unsigned char * key,
1029 const unsigned char * iv,
1030 int encp)
1031 {
1032 struct rc2_cbc *k = ctx->cipher_data;
1033 k->maximum_effective_key = EVP_CIPHER_CTX_key_length(ctx) * 8;
1034 RC2_set_key(&k->key,
1035 EVP_CIPHER_CTX_key_length(ctx),
1036 key,
1037 k->maximum_effective_key);
1038 return 1;
1039 }
1040
1041 static int
1042 rc2_do_cipher(EVP_CIPHER_CTX *ctx,
/* [<][>][^][v][top][bottom][index][help] */
1043 unsigned char *out,
1044 const unsigned char *in,
1045 unsigned int size)
1046 {
1047 struct rc2_cbc *k = ctx->cipher_data;
1048 RC2_cbc_encrypt(in, out, size, &k->key, ctx->iv, ctx->encrypt);
1049 return 1;
1050 }
1051
1052 static int
1053 rc2_cleanup(EVP_CIPHER_CTX *ctx)
/* [<][>][^][v][top][bottom][index][help] */
1054 {
1055 memset(ctx->cipher_data, 0, sizeof(struct rc2_cbc));
1056 return 1;
1057 }
1058
1059 /**
1060 * The RC2 cipher type
1061 *
1062 * @return the RC2 EVP_CIPHER pointer.
1063 *
1064 * @ingroup hcrypto_evp
1065 */
1066
1067 const EVP_CIPHER *
1068 EVP_rc2_cbc(void)
/* [<][>][^][v][top][bottom][index][help] */
1069 {
1070 static const EVP_CIPHER rc2_cbc = {
1071 0,
1072 RC2_BLOCK_SIZE,
1073 RC2_KEY_LENGTH,
1074 RC2_BLOCK_SIZE,
1075 EVP_CIPH_CBC_MODE,
1076 rc2_init,
1077 rc2_do_cipher,
1078 rc2_cleanup,
1079 sizeof(struct rc2_cbc),
1080 NULL,
1081 NULL,
1082 NULL,
1083 NULL
1084 };
1085 return &rc2_cbc;
1086 }
1087
1088 /**
1089 * The RC2-40 cipher type
1090 *
1091 * @return the RC2-40 EVP_CIPHER pointer.
1092 *
1093 * @ingroup hcrypto_evp
1094 */
1095
1096 const EVP_CIPHER *
1097 EVP_rc2_40_cbc(void)
/* [<][>][^][v][top][bottom][index][help] */
1098 {
1099 static const EVP_CIPHER rc2_40_cbc = {
1100 0,
1101 RC2_BLOCK_SIZE,
1102 5,
1103 RC2_BLOCK_SIZE,
1104 EVP_CIPH_CBC_MODE,
1105 rc2_init,
1106 rc2_do_cipher,
1107 rc2_cleanup,
1108 sizeof(struct rc2_cbc),
1109 NULL,
1110 NULL,
1111 NULL,
1112 NULL
1113 };
1114 return &rc2_40_cbc;
1115 }
1116
1117 /**
1118 * The RC2-64 cipher type
1119 *
1120 * @return the RC2-64 EVP_CIPHER pointer.
1121 *
1122 * @ingroup hcrypto_evp
1123 */
1124
1125 const EVP_CIPHER *
1126 EVP_rc2_64_cbc(void)
/* [<][>][^][v][top][bottom][index][help] */
1127 {
1128 static const EVP_CIPHER rc2_64_cbc = {
1129 0,
1130 RC2_BLOCK_SIZE,
1131 8,
1132 RC2_BLOCK_SIZE,
1133 EVP_CIPH_CBC_MODE,
1134 rc2_init,
1135 rc2_do_cipher,
1136 rc2_cleanup,
1137 sizeof(struct rc2_cbc),
1138 NULL,
1139 NULL,
1140 NULL,
1141 NULL
1142 };
1143 return &rc2_64_cbc;
1144 }
1145
1146 /**
1147 * The RC4 cipher type
1148 *
1149 * @return the RC4 EVP_CIPHER pointer.
1150 *
1151 * @ingroup hcrypto_evp
1152 */
1153
1154 const EVP_CIPHER *
1155 EVP_rc4(void)
/* [<][>][^][v][top][bottom][index][help] */
1156 {
1157 printf("evp rc4\n");
1158 abort();
1159 return NULL;
1160 }
1161
1162 /**
1163 * The RC4-40 cipher type
1164 *
1165 * @return the RC4-40 EVP_CIPHER pointer.
1166 *
1167 * @ingroup hcrypto_evp
1168 */
1169
1170 const EVP_CIPHER *
1171 EVP_rc4_40(void)
/* [<][>][^][v][top][bottom][index][help] */
1172 {
1173 printf("evp rc4_40\n");
1174 abort();
1175 return NULL;
1176 }
1177
1178 /*
1179 *
1180 */
1181
1182 static int
1183 des_cbc_init(EVP_CIPHER_CTX *ctx,
/* [<][>][^][v][top][bottom][index][help] */
1184 const unsigned char * key,
1185 const unsigned char * iv,
1186 int encp)
1187 {
1188 DES_key_schedule *k = ctx->cipher_data;
1189 DES_cblock deskey;
1190 memcpy(&deskey, key, sizeof(deskey));
1191 DES_set_key_unchecked(&deskey, k);
1192 return 1;
1193 }
1194
1195 static int
1196 des_cbc_do_cipher(EVP_CIPHER_CTX *ctx,
/* [<][>][^][v][top][bottom][index][help] */
1197 unsigned char *out,
1198 const unsigned char *in,
1199 unsigned int size)
1200 {
1201 DES_key_schedule *k = ctx->cipher_data;
1202 DES_cbc_encrypt(in, out, size,
1203 k, (DES_cblock *)ctx->iv, ctx->encrypt);
1204 return 1;
1205 }
1206
1207 static int
1208 des_cbc_cleanup(EVP_CIPHER_CTX *ctx)
/* [<][>][^][v][top][bottom][index][help] */
1209 {
1210 memset(ctx->cipher_data, 0, sizeof(struct DES_key_schedule));
1211 return 1;
1212 }
1213
1214 /**
1215 * The DES cipher type
1216 *
1217 * @return the DES-CBC EVP_CIPHER pointer.
1218 *
1219 * @ingroup hcrypto_evp
1220 */
1221
1222 const EVP_CIPHER *
1223 EVP_des_cbc(void)
/* [<][>][^][v][top][bottom][index][help] */
1224 {
1225 static const EVP_CIPHER des_ede3_cbc = {
1226 0,
1227 8,
1228 8,
1229 8,
1230 EVP_CIPH_CBC_MODE,
1231 des_cbc_init,
1232 des_cbc_do_cipher,
1233 des_cbc_cleanup,
1234 sizeof(DES_key_schedule),
1235 NULL,
1236 NULL,
1237 NULL,
1238 NULL
1239 };
1240 return &des_ede3_cbc;
1241 }
1242
1243 /*
1244 *
1245 */
1246
1247 struct des_ede3_cbc {
1248 DES_key_schedule ks[3];
1249 };
1250
1251 static int
1252 des_ede3_cbc_init(EVP_CIPHER_CTX *ctx,
/* [<][>][^][v][top][bottom][index][help] */
1253 const unsigned char * key,
1254 const unsigned char * iv,
1255 int encp)
1256 {
1257 struct des_ede3_cbc *k = ctx->cipher_data;
1258 DES_cblock deskey;
1259
1260 memcpy(&deskey, key, sizeof(deskey));
1261 DES_set_odd_parity(&deskey);
1262 DES_set_key_unchecked(&deskey, &k->ks[0]);
1263
1264 memcpy(&deskey, key + 8, sizeof(deskey));
1265 DES_set_odd_parity(&deskey);
1266 DES_set_key_unchecked(&deskey, &k->ks[1]);
1267
1268 memcpy(&deskey, key + 16, sizeof(deskey));
1269 DES_set_odd_parity(&deskey);
1270 DES_set_key_unchecked(&deskey, &k->ks[2]);
1271
1272 return 1;
1273 }
1274
1275 static int
1276 des_ede3_cbc_do_cipher(EVP_CIPHER_CTX *ctx,
/* [<][>][^][v][top][bottom][index][help] */
1277 unsigned char *out,
1278 const unsigned char *in,
1279 unsigned int size)
1280 {
1281 struct des_ede3_cbc *k = ctx->cipher_data;
1282 DES_ede3_cbc_encrypt(in, out, size,
1283 &k->ks[0], &k->ks[1], &k->ks[2],
1284 (DES_cblock *)ctx->iv, ctx->encrypt);
1285 return 1;
1286 }
1287
1288 static int
1289 des_ede3_cbc_cleanup(EVP_CIPHER_CTX *ctx)
/* [<][>][^][v][top][bottom][index][help] */
1290 {
1291 memset(ctx->cipher_data, 0, sizeof(struct des_ede3_cbc));
1292 return 1;
1293 }
1294
1295 /**
1296 * The tripple DES cipher type
1297 *
1298 * @return the DES-EDE3-CBC EVP_CIPHER pointer.
1299 *
1300 * @ingroup hcrypto_evp
1301 */
1302
1303 const EVP_CIPHER *
1304 EVP_des_ede3_cbc(void)
/* [<][>][^][v][top][bottom][index][help] */
1305 {
1306 static const EVP_CIPHER des_ede3_cbc = {
1307 0,
1308 8,
1309 24,
1310 8,
1311 EVP_CIPH_CBC_MODE,
1312 des_ede3_cbc_init,
1313 des_ede3_cbc_do_cipher,
1314 des_ede3_cbc_cleanup,
1315 sizeof(struct des_ede3_cbc),
1316 NULL,
1317 NULL,
1318 NULL,
1319 NULL
1320 };
1321 return &des_ede3_cbc;
1322 }
1323
1324 /**
1325 * The AES-128 cipher type
1326 *
1327 * @return the AES-128 EVP_CIPHER pointer.
1328 *
1329 * @ingroup hcrypto_evp
1330 */
1331
1332 const EVP_CIPHER *
1333 EVP_aes_128_cbc(void)
/* [<][>][^][v][top][bottom][index][help] */
1334 {
1335 return EVP_hcrypto_aes_128_cbc();
1336 }
1337
1338 /**
1339 * The AES-192 cipher type
1340 *
1341 * @return the AES-192 EVP_CIPHER pointer.
1342 *
1343 * @ingroup hcrypto_evp
1344 */
1345
1346 const EVP_CIPHER *
1347 EVP_aes_192_cbc(void)
/* [<][>][^][v][top][bottom][index][help] */
1348 {
1349 return EVP_hcrypto_aes_192_cbc();
1350 }
1351
1352 /**
1353 * The AES-256 cipher type
1354 *
1355 * @return the AES-256 EVP_CIPHER pointer.
1356 *
1357 * @ingroup hcrypto_evp
1358 */
1359
1360 const EVP_CIPHER *
1361 EVP_aes_256_cbc(void)
/* [<][>][^][v][top][bottom][index][help] */
1362 {
1363 return EVP_hcrypto_aes_256_cbc();
1364 }
1365
1366 static int
1367 camellia_init(EVP_CIPHER_CTX *ctx,
/* [<][>][^][v][top][bottom][index][help] */
1368 const unsigned char * key,
1369 const unsigned char * iv,
1370 int encp)
1371 {
1372 CAMELLIA_KEY *k = ctx->cipher_data;
1373 k->bits = ctx->cipher->key_len * 8;
1374 CAMELLIA_set_key(key, ctx->cipher->key_len * 8, k);
1375 return 1;
1376 }
1377
1378 static int
1379 camellia_do_cipher(EVP_CIPHER_CTX *ctx,
/* [<][>][^][v][top][bottom][index][help] */
1380 unsigned char *out,
1381 const unsigned char *in,
1382 unsigned int size)
1383 {
1384 CAMELLIA_KEY *k = ctx->cipher_data;
1385 CAMELLIA_cbc_encrypt(in, out, size, k, ctx->iv, ctx->encrypt);
1386 return 1;
1387 }
1388
1389 static int
1390 camellia_cleanup(EVP_CIPHER_CTX *ctx)
/* [<][>][^][v][top][bottom][index][help] */
1391 {
1392 memset(ctx->cipher_data, 0, sizeof(CAMELLIA_KEY));
1393 return 1;
1394 }
1395
1396 /**
1397 * The Camellia-128 cipher type
1398 *
1399 * @return the Camellia-128 EVP_CIPHER pointer.
1400 *
1401 * @ingroup hcrypto_evp
1402 */
1403
1404 const EVP_CIPHER *
1405 EVP_camellia_128_cbc(void)
/* [<][>][^][v][top][bottom][index][help] */
1406 {
1407 static const EVP_CIPHER cipher = {
1408 0,
1409 16,
1410 16,
1411 16,
1412 EVP_CIPH_CBC_MODE,
1413 camellia_init,
1414 camellia_do_cipher,
1415 camellia_cleanup,
1416 sizeof(CAMELLIA_KEY),
1417 NULL,
1418 NULL,
1419 NULL,
1420 NULL
1421 };
1422 return &cipher;
1423 }
1424
1425 /**
1426 * The Camellia-198 cipher type
1427 *
1428 * @return the Camellia-198 EVP_CIPHER pointer.
1429 *
1430 * @ingroup hcrypto_evp
1431 */
1432
1433 const EVP_CIPHER *
1434 EVP_camellia_192_cbc(void)
/* [<][>][^][v][top][bottom][index][help] */
1435 {
1436 static const EVP_CIPHER cipher = {
1437 0,
1438 16,
1439 24,
1440 16,
1441 EVP_CIPH_CBC_MODE,
1442 camellia_init,
1443 camellia_do_cipher,
1444 camellia_cleanup,
1445 sizeof(CAMELLIA_KEY),
1446 NULL,
1447 NULL,
1448 NULL,
1449 NULL
1450 };
1451 return &cipher;
1452 }
1453
1454 /**
1455 * The Camellia-256 cipher type
1456 *
1457 * @return the Camellia-256 EVP_CIPHER pointer.
1458 *
1459 * @ingroup hcrypto_evp
1460 */
1461
1462 const EVP_CIPHER *
1463 EVP_camellia_256_cbc(void)
/* [<][>][^][v][top][bottom][index][help] */
1464 {
1465 static const EVP_CIPHER cipher = {
1466 0,
1467 16,
1468 32,
1469 16,
1470 EVP_CIPH_CBC_MODE,
1471 camellia_init,
1472 camellia_do_cipher,
1473 camellia_cleanup,
1474 sizeof(CAMELLIA_KEY),
1475 NULL,
1476 NULL,
1477 NULL,
1478 NULL
1479 };
1480 return &cipher;
1481 }
1482
1483 /*
1484 *
1485 */
1486
1487 static const struct cipher_name {
1488 const char *name;
1489 const EVP_CIPHER *(*func)(void);
1490 } cipher_name[] = {
1491 { "des-ede3-cbc", EVP_des_ede3_cbc },
1492 { "aes-128-cbc", EVP_aes_128_cbc },
1493 { "aes-192-cbc", EVP_aes_192_cbc },
1494 { "aes-256-cbc", EVP_aes_256_cbc },
1495 { "camellia-128-cbc", EVP_camellia_128_cbc },
1496 { "camellia-192-cbc", EVP_camellia_192_cbc },
1497 { "camellia-256-cbc", EVP_camellia_256_cbc }
1498 };
1499
1500 /**
1501 * Get the cipher type using their name.
1502 *
1503 * @param name the name of the cipher.
1504 *
1505 * @return the selected EVP_CIPHER pointer or NULL if not found.
1506 *
1507 * @ingroup hcrypto_evp
1508 */
1509
1510 const EVP_CIPHER *
1511 EVP_get_cipherbyname(const char *name)
/* [<][>][^][v][top][bottom][index][help] */
1512 {
1513 int i;
1514 for (i = 0; i < sizeof(cipher_name)/sizeof(cipher_name[0]); i++) {
1515 if (strcasecmp(cipher_name[i].name, name) == 0)
1516 return (*cipher_name[i].func)();
1517 }
1518 return NULL;
1519 }
1520
1521
1522 /*
1523 *
1524 */
1525
1526 #ifndef min
1527 #define min(a,b) (((a)>(b))?(b):(a))
1528 #endif
1529
1530 /**
1531 * Provides a legancy string to key function, used in PEM files.
1532 *
1533 * New protocols should use new string to key functions like NIST
1534 * SP56-800A or PKCS#5 v2.0 (see PKCS5_PBKDF2_HMAC_SHA1()).
1535 *
1536 * @param type type of cipher to use
1537 * @param md message digest to use
1538 * @param salt salt salt string, should be an binary 8 byte buffer.
1539 * @param data the password/input key string.
1540 * @param datalen length of data parameter.
1541 * @param count iteration counter.
1542 * @param keydata output keydata, needs to of the size EVP_CIPHER_key_length().
1543 * @param ivdata output ivdata, needs to of the size EVP_CIPHER_block_size().
1544 *
1545 * @return the size of derived key.
1546 *
1547 * @ingroup hcrypto_evp
1548 */
1549
1550 int
1551 EVP_BytesToKey(const EVP_CIPHER *type,
/* [<][>][^][v][top][bottom][index][help] */
1552 const EVP_MD *md,
1553 const void *salt,
1554 const void *data, size_t datalen,
1555 unsigned int count,
1556 void *keydata,
1557 void *ivdata)
1558 {
1559 int ivlen, keylen, first = 0;
1560 unsigned int mds = 0, i;
1561 unsigned char *key = keydata;
1562 unsigned char *iv = ivdata;
1563 unsigned char *buf;
1564 EVP_MD_CTX c;
1565
1566 keylen = EVP_CIPHER_key_length(type);
1567 ivlen = EVP_CIPHER_iv_length(type);
1568
1569 if (data == NULL)
1570 return keylen;
1571
1572 buf = malloc(EVP_MD_size(md));
1573 if (buf == NULL)
1574 return -1;
1575
1576 EVP_MD_CTX_init(&c);
1577
1578 first = 1;
1579 while (1) {
1580 EVP_DigestInit_ex(&c, md, NULL);
1581 if (!first)
1582 EVP_DigestUpdate(&c, buf, mds);
1583 first = 0;
1584 EVP_DigestUpdate(&c,data,datalen);
1585
1586 #define PKCS5_SALT_LEN 8
1587
1588 if (salt)
1589 EVP_DigestUpdate(&c, salt, PKCS5_SALT_LEN);
1590
1591 EVP_DigestFinal_ex(&c, buf, &mds);
1592 assert(mds == EVP_MD_size(md));
1593
1594 for (i = 1; i < count; i++) {
1595 EVP_DigestInit_ex(&c, md, NULL);
1596 EVP_DigestUpdate(&c, buf, mds);
1597 EVP_DigestFinal_ex(&c, buf, &mds);
1598 assert(mds == EVP_MD_size(md));
1599 }
1600
1601 i = 0;
1602 if (keylen) {
1603 size_t sz = min(keylen, mds);
1604 if (key) {
1605 memcpy(key, buf, sz);
1606 key += sz;
1607 }
1608 keylen -= sz;
1609 i += sz;
1610 }
1611 if (ivlen && mds > i) {
1612 size_t sz = min(ivlen, (mds - i));
1613 if (iv) {
1614 memcpy(iv, &buf[i], sz);
1615 iv += sz;
1616 }
1617 ivlen -= sz;
1618 }
1619 if (keylen == 0 && ivlen == 0)
1620 break;
1621 }
1622
1623 EVP_MD_CTX_cleanup(&c);
1624 free(buf);
1625
1626 return EVP_CIPHER_key_length(type);
1627 }
1628
1629 /**
1630 * Generate a random key for the specificed EVP_CIPHER.
1631 *
1632 * @param ctx EVP_CIPHER_CTX type to build the key for.
1633 * @param key return key, must be at least EVP_CIPHER_key_length() byte long.
1634 *
1635 * @return 1 for success, 0 for failure.
1636 *
1637 * @ingroup hcrypto_core
1638 */
1639
1640 int
1641 EVP_CIPHER_CTX_rand_key(EVP_CIPHER_CTX *ctx, void *key)
/* [<][>][^][v][top][bottom][index][help] */
1642 {
1643 if (ctx->cipher->flags & EVP_CIPH_RAND_KEY)
1644 return EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_RAND_KEY, 0, key);
1645 if (RAND_bytes(key, ctx->key_len) != 1)
1646 return 0;
1647 return 1;
1648 }
1649
1650 /**
1651 * Perform a operation on a ctx
1652 *
1653 * @return 1 for success, 0 for failure.
1654 *
1655 * @ingroup hcrypto_core
1656 */
1657
1658 int
1659 EVP_CIPHER_CTX_ctrl(EVP_CIPHER_CTX *ctx, int type, int arg, void *data)
/* [<][>][^][v][top][bottom][index][help] */
1660 {
1661 if (ctx->cipher == NULL || ctx->cipher->ctrl == NULL)
1662 return 0;
1663 return (*ctx->cipher->ctrl)(ctx, type, arg, data);
1664 }
1665
1666 /**
1667 * Add all algorithms to the crypto core.
1668 *
1669 * @ingroup hcrypto_core
1670 */
1671
1672 void
1673 OpenSSL_add_all_algorithms(void)
/* [<][>][^][v][top][bottom][index][help] */
1674 {
1675 return;
1676 }
1677
1678 /**
1679 * Add all algorithms to the crypto core using configuration file.
1680 *
1681 * @ingroup hcrypto_core
1682 */
1683
1684 void
1685 OpenSSL_add_all_algorithms_conf(void)
/* [<][>][^][v][top][bottom][index][help] */
1686 {
1687 return;
1688 }
1689
1690 /**
1691 * Add all algorithms to the crypto core, but don't use the
1692 * configuration file.
1693 *
1694 * @ingroup hcrypto_core
1695 */
1696
1697 void
1698 OpenSSL_add_all_algorithms_noconf(void)
/* [<][>][^][v][top][bottom][index][help] */
1699 {
1700 return;
1701 }