|
1 /* crypto/evp/evp_enc.c */ |
|
2 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com) |
|
3 * All rights reserved. |
|
4 * |
|
5 * This package is an SSL implementation written |
|
6 * by Eric Young (eay@cryptsoft.com). |
|
7 * The implementation was written so as to conform with Netscapes SSL. |
|
8 * |
|
9 * This library is free for commercial and non-commercial use as long as |
|
10 * the following conditions are aheared to. The following conditions |
|
11 * apply to all code found in this distribution, be it the RC4, RSA, |
|
12 * lhash, DES, etc., code; not just the SSL code. The SSL documentation |
|
13 * included with this distribution is covered by the same copyright terms |
|
14 * except that the holder is Tim Hudson (tjh@cryptsoft.com). |
|
15 * |
|
16 * Copyright remains Eric Young's, and as such any Copyright notices in |
|
17 * the code are not to be removed. |
|
18 * If this package is used in a product, Eric Young should be given attribution |
|
19 * as the author of the parts of the library used. |
|
20 * This can be in the form of a textual message at program startup or |
|
21 * in documentation (online or textual) provided with the package. |
|
22 * |
|
23 * Redistribution and use in source and binary forms, with or without |
|
24 * modification, are permitted provided that the following conditions |
|
25 * are met: |
|
26 * 1. Redistributions of source code must retain the copyright |
|
27 * notice, this list of conditions and the following disclaimer. |
|
28 * 2. Redistributions in binary form must reproduce the above copyright |
|
29 * notice, this list of conditions and the following disclaimer in the |
|
30 * documentation and/or other materials provided with the distribution. |
|
31 * 3. All advertising materials mentioning features or use of this software |
|
32 * must display the following acknowledgement: |
|
33 * "This product includes cryptographic software written by |
|
34 * Eric Young (eay@cryptsoft.com)" |
|
35 * The word 'cryptographic' can be left out if the rouines from the library |
|
36 * being used are not cryptographic related :-). |
|
37 * 4. If you include any Windows specific code (or a derivative thereof) from |
|
38 * the apps directory (application code) you must include an acknowledgement: |
|
39 * "This product includes software written by Tim Hudson (tjh@cryptsoft.com)" |
|
40 * |
|
41 * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND |
|
42 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
|
43 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE |
|
44 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE |
|
45 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL |
|
46 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS |
|
47 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) |
|
48 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT |
|
49 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY |
|
50 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF |
|
51 * SUCH DAMAGE. |
|
52 * |
|
53 * The licence and distribution terms for any publically available version or |
|
54 * derivative of this code cannot be changed. i.e. this code cannot simply be |
|
55 * copied and put under another distribution licence |
|
56 * [including the GNU Public Licence.] |
|
57 */ |
|
58 |
|
59 #include <stdio.h> |
|
60 #include "cryptlib.h" |
|
61 #include <openssl/evp.h> |
|
62 #include <openssl/err.h> |
|
63 #include <openssl/rand.h> |
|
64 #ifndef OPENSSL_NO_ENGINE |
|
65 #include <openssl/engine.h> |
|
66 #endif |
|
67 #include "evp_locl.h" |
|
68 |
|
69 const char EVP_version[]="EVP" OPENSSL_VERSION_PTEXT; |
|
70 |
|
71 EXPORT_C void EVP_CIPHER_CTX_init(EVP_CIPHER_CTX *ctx) |
|
72 { |
|
73 memset(ctx,0,sizeof(EVP_CIPHER_CTX)); |
|
74 /* ctx->cipher=NULL; */ |
|
75 } |
|
76 |
|
77 EXPORT_C EVP_CIPHER_CTX *EVP_CIPHER_CTX_new(void) |
|
78 { |
|
79 EVP_CIPHER_CTX *ctx=OPENSSL_malloc(sizeof *ctx); |
|
80 if (ctx) |
|
81 EVP_CIPHER_CTX_init(ctx); |
|
82 return ctx; |
|
83 } |
|
84 |
|
85 EXPORT_C int EVP_CipherInit(EVP_CIPHER_CTX *ctx, const EVP_CIPHER *cipher, |
|
86 const unsigned char *key, const unsigned char *iv, int enc) |
|
87 { |
|
88 if (cipher) |
|
89 EVP_CIPHER_CTX_init(ctx); |
|
90 return EVP_CipherInit_ex(ctx,cipher,NULL,key,iv,enc); |
|
91 } |
|
92 |
|
93 EXPORT_C int EVP_CipherInit_ex(EVP_CIPHER_CTX *ctx, const EVP_CIPHER *cipher, ENGINE *impl, |
|
94 const unsigned char *key, const unsigned char *iv, int enc) |
|
95 { |
|
96 if (enc == -1) |
|
97 enc = ctx->encrypt; |
|
98 else |
|
99 { |
|
100 if (enc) |
|
101 enc = 1; |
|
102 ctx->encrypt = enc; |
|
103 } |
|
104 #ifndef OPENSSL_NO_ENGINE |
|
105 /* Whether it's nice or not, "Inits" can be used on "Final"'d contexts |
|
106 * so this context may already have an ENGINE! Try to avoid releasing |
|
107 * the previous handle, re-querying for an ENGINE, and having a |
|
108 * reinitialisation, when it may all be unecessary. */ |
|
109 if (ctx->engine && ctx->cipher && (!cipher || |
|
110 (cipher && (cipher->nid == ctx->cipher->nid)))) |
|
111 goto skip_to_init; |
|
112 #endif |
|
113 if (cipher) |
|
114 { |
|
115 /* Ensure a context left lying around from last time is cleared |
|
116 * (the previous check attempted to avoid this if the same |
|
117 * ENGINE and EVP_CIPHER could be used). */ |
|
118 EVP_CIPHER_CTX_cleanup(ctx); |
|
119 |
|
120 /* Restore encrypt field: it is zeroed by cleanup */ |
|
121 ctx->encrypt = enc; |
|
122 #ifndef OPENSSL_NO_ENGINE |
|
123 if(impl) |
|
124 { |
|
125 if (!ENGINE_init(impl)) |
|
126 { |
|
127 EVPerr(EVP_F_EVP_CIPHERINIT_EX, EVP_R_INITIALIZATION_ERROR); |
|
128 return 0; |
|
129 } |
|
130 } |
|
131 else |
|
132 /* Ask if an ENGINE is reserved for this job */ |
|
133 impl = ENGINE_get_cipher_engine(cipher->nid); |
|
134 if(impl) |
|
135 { |
|
136 /* There's an ENGINE for this job ... (apparently) */ |
|
137 const EVP_CIPHER *c = ENGINE_get_cipher(impl, cipher->nid); |
|
138 if(!c) |
|
139 { |
|
140 /* One positive side-effect of US's export |
|
141 * control history, is that we should at least |
|
142 * be able to avoid using US mispellings of |
|
143 * "initialisation"? */ |
|
144 EVPerr(EVP_F_EVP_CIPHERINIT_EX, EVP_R_INITIALIZATION_ERROR); |
|
145 return 0; |
|
146 } |
|
147 /* We'll use the ENGINE's private cipher definition */ |
|
148 cipher = c; |
|
149 /* Store the ENGINE functional reference so we know |
|
150 * 'cipher' came from an ENGINE and we need to release |
|
151 * it when done. */ |
|
152 ctx->engine = impl; |
|
153 } |
|
154 else |
|
155 ctx->engine = NULL; |
|
156 #endif |
|
157 |
|
158 ctx->cipher=cipher; |
|
159 if (ctx->cipher->ctx_size) |
|
160 { |
|
161 ctx->cipher_data=OPENSSL_malloc(ctx->cipher->ctx_size); |
|
162 if (!ctx->cipher_data) |
|
163 { |
|
164 EVPerr(EVP_F_EVP_CIPHERINIT_EX, ERR_R_MALLOC_FAILURE); |
|
165 return 0; |
|
166 } |
|
167 } |
|
168 else |
|
169 { |
|
170 ctx->cipher_data = NULL; |
|
171 } |
|
172 ctx->key_len = cipher->key_len; |
|
173 ctx->flags = 0; |
|
174 if(ctx->cipher->flags & EVP_CIPH_CTRL_INIT) |
|
175 { |
|
176 if(!EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_INIT, 0, NULL)) |
|
177 { |
|
178 EVPerr(EVP_F_EVP_CIPHERINIT_EX, EVP_R_INITIALIZATION_ERROR); |
|
179 return 0; |
|
180 } |
|
181 } |
|
182 } |
|
183 else if(!ctx->cipher) |
|
184 { |
|
185 EVPerr(EVP_F_EVP_CIPHERINIT_EX, EVP_R_NO_CIPHER_SET); |
|
186 return 0; |
|
187 } |
|
188 #ifndef OPENSSL_NO_ENGINE |
|
189 skip_to_init: |
|
190 #endif |
|
191 /* we assume block size is a power of 2 in *cryptUpdate */ |
|
192 OPENSSL_assert(ctx->cipher->block_size == 1 |
|
193 || ctx->cipher->block_size == 8 |
|
194 || ctx->cipher->block_size == 16); |
|
195 |
|
196 if(!(EVP_CIPHER_CTX_flags(ctx) & EVP_CIPH_CUSTOM_IV)) { |
|
197 switch(EVP_CIPHER_CTX_mode(ctx)) { |
|
198 |
|
199 case EVP_CIPH_STREAM_CIPHER: |
|
200 case EVP_CIPH_ECB_MODE: |
|
201 break; |
|
202 |
|
203 case EVP_CIPH_CFB_MODE: |
|
204 case EVP_CIPH_OFB_MODE: |
|
205 |
|
206 ctx->num = 0; |
|
207 |
|
208 case EVP_CIPH_CBC_MODE: |
|
209 |
|
210 OPENSSL_assert(EVP_CIPHER_CTX_iv_length(ctx) <= |
|
211 (int)sizeof(ctx->iv)); |
|
212 if(iv) memcpy(ctx->oiv, iv, EVP_CIPHER_CTX_iv_length(ctx)); |
|
213 memcpy(ctx->iv, ctx->oiv, EVP_CIPHER_CTX_iv_length(ctx)); |
|
214 break; |
|
215 |
|
216 default: |
|
217 return 0; |
|
218 break; |
|
219 } |
|
220 } |
|
221 |
|
222 if(key || (ctx->cipher->flags & EVP_CIPH_ALWAYS_CALL_INIT)) { |
|
223 if(!ctx->cipher->init(ctx,key,iv,enc)) return 0; |
|
224 } |
|
225 ctx->buf_len=0; |
|
226 ctx->final_used=0; |
|
227 ctx->block_mask=ctx->cipher->block_size-1; |
|
228 return 1; |
|
229 } |
|
230 |
|
231 EXPORT_C int EVP_CipherUpdate(EVP_CIPHER_CTX *ctx, unsigned char *out, int *outl, |
|
232 const unsigned char *in, int inl) |
|
233 { |
|
234 if (ctx->encrypt) |
|
235 return EVP_EncryptUpdate(ctx,out,outl,in,inl); |
|
236 else return EVP_DecryptUpdate(ctx,out,outl,in,inl); |
|
237 } |
|
238 |
|
239 EXPORT_C int EVP_CipherFinal_ex(EVP_CIPHER_CTX *ctx, unsigned char *out, int *outl) |
|
240 { |
|
241 if (ctx->encrypt) |
|
242 return EVP_EncryptFinal_ex(ctx,out,outl); |
|
243 else return EVP_DecryptFinal_ex(ctx,out,outl); |
|
244 } |
|
245 |
|
246 EXPORT_C int EVP_CipherFinal(EVP_CIPHER_CTX *ctx, unsigned char *out, int *outl) |
|
247 { |
|
248 if (ctx->encrypt) |
|
249 return EVP_EncryptFinal(ctx,out,outl); |
|
250 else return EVP_DecryptFinal(ctx,out,outl); |
|
251 } |
|
252 |
|
253 EXPORT_C int EVP_EncryptInit(EVP_CIPHER_CTX *ctx, const EVP_CIPHER *cipher, |
|
254 const unsigned char *key, const unsigned char *iv) |
|
255 { |
|
256 return EVP_CipherInit(ctx, cipher, key, iv, 1); |
|
257 } |
|
258 |
|
259 EXPORT_C int EVP_EncryptInit_ex(EVP_CIPHER_CTX *ctx,const EVP_CIPHER *cipher, ENGINE *impl, |
|
260 const unsigned char *key, const unsigned char *iv) |
|
261 { |
|
262 return EVP_CipherInit_ex(ctx, cipher, impl, key, iv, 1); |
|
263 } |
|
264 |
|
265 EXPORT_C int EVP_DecryptInit(EVP_CIPHER_CTX *ctx, const EVP_CIPHER *cipher, |
|
266 const unsigned char *key, const unsigned char *iv) |
|
267 { |
|
268 return EVP_CipherInit(ctx, cipher, key, iv, 0); |
|
269 } |
|
270 |
|
271 EXPORT_C int EVP_DecryptInit_ex(EVP_CIPHER_CTX *ctx, const EVP_CIPHER *cipher, ENGINE *impl, |
|
272 const unsigned char *key, const unsigned char *iv) |
|
273 { |
|
274 return EVP_CipherInit_ex(ctx, cipher, impl, key, iv, 0); |
|
275 } |
|
276 |
|
277 EXPORT_C int EVP_EncryptUpdate(EVP_CIPHER_CTX *ctx, unsigned char *out, int *outl, |
|
278 const unsigned char *in, int inl) |
|
279 { |
|
280 int i,j,bl; |
|
281 |
|
282 OPENSSL_assert(inl > 0); |
|
283 if(ctx->buf_len == 0 && (inl&(ctx->block_mask)) == 0) |
|
284 { |
|
285 if(ctx->cipher->do_cipher(ctx,out,in,inl)) |
|
286 { |
|
287 *outl=inl; |
|
288 return 1; |
|
289 } |
|
290 else |
|
291 { |
|
292 *outl=0; |
|
293 return 0; |
|
294 } |
|
295 } |
|
296 i=ctx->buf_len; |
|
297 bl=ctx->cipher->block_size; |
|
298 OPENSSL_assert(bl <= (int)sizeof(ctx->buf)); |
|
299 if (i != 0) |
|
300 { |
|
301 if (i+inl < bl) |
|
302 { |
|
303 memcpy(&(ctx->buf[i]),in,inl); |
|
304 ctx->buf_len+=inl; |
|
305 *outl=0; |
|
306 return 1; |
|
307 } |
|
308 else |
|
309 { |
|
310 j=bl-i; |
|
311 memcpy(&(ctx->buf[i]),in,j); |
|
312 if(!ctx->cipher->do_cipher(ctx,out,ctx->buf,bl)) return 0; |
|
313 inl-=j; |
|
314 in+=j; |
|
315 out+=bl; |
|
316 *outl=bl; |
|
317 } |
|
318 } |
|
319 else |
|
320 *outl = 0; |
|
321 i=inl&(bl-1); |
|
322 inl-=i; |
|
323 if (inl > 0) |
|
324 { |
|
325 if(!ctx->cipher->do_cipher(ctx,out,in,inl)) return 0; |
|
326 *outl+=inl; |
|
327 } |
|
328 |
|
329 if (i != 0) |
|
330 memcpy(ctx->buf,&(in[inl]),i); |
|
331 ctx->buf_len=i; |
|
332 return 1; |
|
333 } |
|
334 |
|
335 EXPORT_C int EVP_EncryptFinal(EVP_CIPHER_CTX *ctx, unsigned char *out, int *outl) |
|
336 { |
|
337 int ret; |
|
338 ret = EVP_EncryptFinal_ex(ctx, out, outl); |
|
339 return ret; |
|
340 } |
|
341 |
|
342 EXPORT_C int EVP_EncryptFinal_ex(EVP_CIPHER_CTX *ctx, unsigned char *out, int *outl) |
|
343 { |
|
344 int n,ret; |
|
345 unsigned int i, b, bl; |
|
346 |
|
347 b=ctx->cipher->block_size; |
|
348 OPENSSL_assert(b <= sizeof ctx->buf); |
|
349 if (b == 1) |
|
350 { |
|
351 *outl=0; |
|
352 return 1; |
|
353 } |
|
354 bl=ctx->buf_len; |
|
355 if (ctx->flags & EVP_CIPH_NO_PADDING) |
|
356 { |
|
357 if(bl) |
|
358 { |
|
359 EVPerr(EVP_F_EVP_ENCRYPTFINAL_EX,EVP_R_DATA_NOT_MULTIPLE_OF_BLOCK_LENGTH); |
|
360 return 0; |
|
361 } |
|
362 *outl = 0; |
|
363 return 1; |
|
364 } |
|
365 |
|
366 n=b-bl; |
|
367 for (i=bl; i<b; i++) |
|
368 ctx->buf[i]=n; |
|
369 ret=ctx->cipher->do_cipher(ctx,out,ctx->buf,b); |
|
370 |
|
371 |
|
372 if(ret) |
|
373 *outl=b; |
|
374 |
|
375 return ret; |
|
376 } |
|
377 |
|
378 EXPORT_C int EVP_DecryptUpdate(EVP_CIPHER_CTX *ctx, unsigned char *out, int *outl, |
|
379 const unsigned char *in, int inl) |
|
380 { |
|
381 int fix_len; |
|
382 unsigned int b; |
|
383 |
|
384 if (inl == 0) |
|
385 { |
|
386 *outl=0; |
|
387 return 1; |
|
388 } |
|
389 |
|
390 if (ctx->flags & EVP_CIPH_NO_PADDING) |
|
391 return EVP_EncryptUpdate(ctx, out, outl, in, inl); |
|
392 |
|
393 b=ctx->cipher->block_size; |
|
394 OPENSSL_assert(b <= sizeof ctx->final); |
|
395 |
|
396 if(ctx->final_used) |
|
397 { |
|
398 memcpy(out,ctx->final,b); |
|
399 out+=b; |
|
400 fix_len = 1; |
|
401 } |
|
402 else |
|
403 fix_len = 0; |
|
404 |
|
405 |
|
406 if(!EVP_EncryptUpdate(ctx,out,outl,in,inl)) |
|
407 return 0; |
|
408 |
|
409 /* if we have 'decrypted' a multiple of block size, make sure |
|
410 * we have a copy of this last block */ |
|
411 if (b > 1 && !ctx->buf_len) |
|
412 { |
|
413 *outl-=b; |
|
414 ctx->final_used=1; |
|
415 memcpy(ctx->final,&out[*outl],b); |
|
416 } |
|
417 else |
|
418 ctx->final_used = 0; |
|
419 |
|
420 if (fix_len) |
|
421 *outl += b; |
|
422 |
|
423 return 1; |
|
424 } |
|
425 |
|
426 EXPORT_C int EVP_DecryptFinal(EVP_CIPHER_CTX *ctx, unsigned char *out, int *outl) |
|
427 { |
|
428 int ret; |
|
429 ret = EVP_DecryptFinal_ex(ctx, out, outl); |
|
430 return ret; |
|
431 } |
|
432 |
|
433 EXPORT_C int EVP_DecryptFinal_ex(EVP_CIPHER_CTX *ctx, unsigned char *out, int *outl) |
|
434 { |
|
435 int i,n; |
|
436 unsigned int b; |
|
437 |
|
438 *outl=0; |
|
439 b=ctx->cipher->block_size; |
|
440 if (ctx->flags & EVP_CIPH_NO_PADDING) |
|
441 { |
|
442 if(ctx->buf_len) |
|
443 { |
|
444 EVPerr(EVP_F_EVP_DECRYPTFINAL_EX,EVP_R_DATA_NOT_MULTIPLE_OF_BLOCK_LENGTH); |
|
445 return 0; |
|
446 } |
|
447 *outl = 0; |
|
448 return 1; |
|
449 } |
|
450 if (b > 1) |
|
451 { |
|
452 if (ctx->buf_len || !ctx->final_used) |
|
453 { |
|
454 EVPerr(EVP_F_EVP_DECRYPTFINAL_EX,EVP_R_WRONG_FINAL_BLOCK_LENGTH); |
|
455 return(0); |
|
456 } |
|
457 OPENSSL_assert(b <= sizeof ctx->final); |
|
458 n=ctx->final[b-1]; |
|
459 if (n == 0 || n > (int)b) |
|
460 { |
|
461 EVPerr(EVP_F_EVP_DECRYPTFINAL_EX,EVP_R_BAD_DECRYPT); |
|
462 return(0); |
|
463 } |
|
464 for (i=0; i<n; i++) |
|
465 { |
|
466 if (ctx->final[--b] != n) |
|
467 { |
|
468 EVPerr(EVP_F_EVP_DECRYPTFINAL_EX,EVP_R_BAD_DECRYPT); |
|
469 return(0); |
|
470 } |
|
471 } |
|
472 n=ctx->cipher->block_size-n; |
|
473 for (i=0; i<n; i++) |
|
474 out[i]=ctx->final[i]; |
|
475 *outl=n; |
|
476 } |
|
477 else |
|
478 *outl=0; |
|
479 return(1); |
|
480 } |
|
481 |
|
482 EXPORT_C void EVP_CIPHER_CTX_free(EVP_CIPHER_CTX *ctx) |
|
483 { |
|
484 if (ctx) |
|
485 { |
|
486 EVP_CIPHER_CTX_cleanup(ctx); |
|
487 OPENSSL_free(ctx); |
|
488 } |
|
489 } |
|
490 EXPORT_C int EVP_CIPHER_CTX_cleanup(EVP_CIPHER_CTX *c) |
|
491 { |
|
492 if (c->cipher != NULL) |
|
493 { |
|
494 if(c->cipher->cleanup && !c->cipher->cleanup(c)) |
|
495 return 0; |
|
496 /* Cleanse cipher context data */ |
|
497 if (c->cipher_data) |
|
498 OPENSSL_cleanse(c->cipher_data, c->cipher->ctx_size); |
|
499 } |
|
500 if (c->cipher_data) |
|
501 OPENSSL_free(c->cipher_data); |
|
502 #ifndef OPENSSL_NO_ENGINE |
|
503 if (c->engine) |
|
504 /* The EVP_CIPHER we used belongs to an ENGINE, release the |
|
505 * functional reference we held for this reason. */ |
|
506 ENGINE_finish(c->engine); |
|
507 #endif |
|
508 memset(c,0,sizeof(EVP_CIPHER_CTX)); |
|
509 return 1; |
|
510 } |
|
511 |
|
512 EXPORT_C int EVP_CIPHER_CTX_set_key_length(EVP_CIPHER_CTX *c, int keylen) |
|
513 { |
|
514 if(c->cipher->flags & EVP_CIPH_CUSTOM_KEY_LENGTH) |
|
515 return EVP_CIPHER_CTX_ctrl(c, EVP_CTRL_SET_KEY_LENGTH, keylen, NULL); |
|
516 if(c->key_len == keylen) return 1; |
|
517 if((keylen > 0) && (c->cipher->flags & EVP_CIPH_VARIABLE_LENGTH)) |
|
518 { |
|
519 c->key_len = keylen; |
|
520 return 1; |
|
521 } |
|
522 EVPerr(EVP_F_EVP_CIPHER_CTX_SET_KEY_LENGTH,EVP_R_INVALID_KEY_LENGTH); |
|
523 return 0; |
|
524 } |
|
525 |
|
526 EXPORT_C int EVP_CIPHER_CTX_set_padding(EVP_CIPHER_CTX *ctx, int pad) |
|
527 { |
|
528 if (pad) ctx->flags &= ~EVP_CIPH_NO_PADDING; |
|
529 else ctx->flags |= EVP_CIPH_NO_PADDING; |
|
530 return 1; |
|
531 } |
|
532 |
|
533 EXPORT_C int EVP_CIPHER_CTX_ctrl(EVP_CIPHER_CTX *ctx, int type, int arg, void *ptr) |
|
534 { |
|
535 int ret; |
|
536 if(!ctx->cipher) { |
|
537 EVPerr(EVP_F_EVP_CIPHER_CTX_CTRL, EVP_R_NO_CIPHER_SET); |
|
538 return 0; |
|
539 } |
|
540 |
|
541 if(!ctx->cipher->ctrl) { |
|
542 EVPerr(EVP_F_EVP_CIPHER_CTX_CTRL, EVP_R_CTRL_NOT_IMPLEMENTED); |
|
543 return 0; |
|
544 } |
|
545 |
|
546 ret = ctx->cipher->ctrl(ctx, type, arg, ptr); |
|
547 if(ret == -1) { |
|
548 EVPerr(EVP_F_EVP_CIPHER_CTX_CTRL, EVP_R_CTRL_OPERATION_NOT_IMPLEMENTED); |
|
549 return 0; |
|
550 } |
|
551 return ret; |
|
552 } |
|
553 |
|
554 EXPORT_C int EVP_CIPHER_CTX_rand_key(EVP_CIPHER_CTX *ctx, unsigned char *key) |
|
555 { |
|
556 if (ctx->cipher->flags & EVP_CIPH_RAND_KEY) |
|
557 return EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_RAND_KEY, 0, key); |
|
558 if (RAND_bytes(key, ctx->key_len) <= 0) |
|
559 return 0; |
|
560 return 1; |
|
561 } |
|
562 |