Branch data Line data Source code
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 : 6476 : void EVP_CIPHER_CTX_init(EVP_CIPHER_CTX *ctx)
72 : : {
73 : : memset(ctx,0,sizeof(EVP_CIPHER_CTX));
74 : : /* ctx->cipher=NULL; */
75 : 6476 : }
76 : :
77 : 2249 : EVP_CIPHER_CTX *EVP_CIPHER_CTX_new(void)
78 : : {
79 : 2249 : EVP_CIPHER_CTX *ctx=OPENSSL_malloc(sizeof *ctx);
80 [ + - ]: 2249 : if (ctx)
81 : 2249 : EVP_CIPHER_CTX_init(ctx);
82 : 2249 : return ctx;
83 : : }
84 : :
85 : 0 : int EVP_CipherInit(EVP_CIPHER_CTX *ctx, const EVP_CIPHER *cipher,
86 : : const unsigned char *key, const unsigned char *iv, int enc)
87 : : {
88 [ # # ]: 0 : if (cipher)
89 : 0 : EVP_CIPHER_CTX_init(ctx);
90 : 0 : return EVP_CipherInit_ex(ctx,cipher,NULL,key,iv,enc);
91 : : }
92 : :
93 : 6578 : 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 [ + + ]: 6578 : if (enc == -1)
97 : 2 : enc = ctx->encrypt;
98 : : else
99 : : {
100 [ + + ]: 6576 : if (enc)
101 : 3706 : enc = 1;
102 : 6576 : 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 [ - + ][ # # ]: 6578 : if (ctx->engine && ctx->cipher && (!cipher ||
[ # # ][ # # ]
110 : 0 : (cipher && (cipher->nid == ctx->cipher->nid))))
111 : : goto skip_to_init;
112 : : #endif
113 [ + + ]: 6578 : 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 [ + + ]: 6238 : if (ctx->cipher)
119 : : {
120 : 119 : unsigned long flags = ctx->flags;
121 : 119 : EVP_CIPHER_CTX_cleanup(ctx);
122 : : /* Restore encrypt and flags */
123 : 119 : ctx->encrypt = enc;
124 : 119 : ctx->flags = flags;
125 : : }
126 : : #ifndef OPENSSL_NO_ENGINE
127 [ + + ]: 6238 : if(impl)
128 : : {
129 [ - + ]: 8 : if (!ENGINE_init(impl))
130 : : {
131 : 0 : EVPerr(EVP_F_EVP_CIPHERINIT_EX, EVP_R_INITIALIZATION_ERROR);
132 : 0 : return 0;
133 : : }
134 : : }
135 : : else
136 : : /* Ask if an ENGINE is reserved for this job */
137 : 6230 : impl = ENGINE_get_cipher_engine(cipher->nid);
138 [ + + ]: 6238 : if(impl)
139 : : {
140 : : /* There's an ENGINE for this job ... (apparently) */
141 : 8 : const EVP_CIPHER *c = ENGINE_get_cipher(impl, cipher->nid);
142 [ - + ]: 8 : if(!c)
143 : : {
144 : : /* One positive side-effect of US's export
145 : : * control history, is that we should at least
146 : : * be able to avoid using US mispellings of
147 : : * "initialisation"? */
148 : 0 : EVPerr(EVP_F_EVP_CIPHERINIT_EX, EVP_R_INITIALIZATION_ERROR);
149 : 0 : return 0;
150 : : }
151 : : /* We'll use the ENGINE's private cipher definition */
152 : 8 : cipher = c;
153 : : /* Store the ENGINE functional reference so we know
154 : : * 'cipher' came from an ENGINE and we need to release
155 : : * it when done. */
156 : 8 : ctx->engine = impl;
157 : : }
158 : : else
159 : 6230 : ctx->engine = NULL;
160 : : #endif
161 : :
162 : 6238 : ctx->cipher=cipher;
163 [ + + ]: 6238 : if (ctx->cipher->ctx_size)
164 : : {
165 : 6106 : ctx->cipher_data=OPENSSL_malloc(ctx->cipher->ctx_size);
166 [ - + ]: 6106 : if (!ctx->cipher_data)
167 : : {
168 : 0 : EVPerr(EVP_F_EVP_CIPHERINIT_EX, ERR_R_MALLOC_FAILURE);
169 : 0 : return 0;
170 : : }
171 : : }
172 : : else
173 : : {
174 : 132 : ctx->cipher_data = NULL;
175 : : }
176 : 6238 : ctx->key_len = cipher->key_len;
177 : : /* Preserve wrap enable flag, zero everything else */
178 : 6238 : ctx->flags &= EVP_CIPHER_CTX_FLAG_WRAP_ALLOW;
179 [ + + ]: 6238 : if(ctx->cipher->flags & EVP_CIPH_CTRL_INIT)
180 : : {
181 [ - + ]: 738 : if(!EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_INIT, 0, NULL))
182 : : {
183 : 0 : EVPerr(EVP_F_EVP_CIPHERINIT_EX, EVP_R_INITIALIZATION_ERROR);
184 : 0 : return 0;
185 : : }
186 : : }
187 : : }
188 [ - + ]: 340 : else if(!ctx->cipher)
189 : : {
190 : 0 : EVPerr(EVP_F_EVP_CIPHERINIT_EX, EVP_R_NO_CIPHER_SET);
191 : 0 : return 0;
192 : : }
193 : : #ifndef OPENSSL_NO_ENGINE
194 : : skip_to_init:
195 : : #endif
196 : : /* we assume block size is a power of 2 in *cryptUpdate */
197 [ + + ][ - + ]: 6578 : OPENSSL_assert(ctx->cipher->block_size == 1
198 : : || ctx->cipher->block_size == 8
199 : : || ctx->cipher->block_size == 16);
200 : :
201 [ + + ]: 6578 : if(!(ctx->flags & EVP_CIPHER_CTX_FLAG_WRAP_ALLOW)
202 [ - + ]: 6153 : && EVP_CIPHER_CTX_mode(ctx) == EVP_CIPH_WRAP_MODE)
203 : : {
204 : 0 : EVPerr(EVP_F_EVP_CIPHERINIT_EX, EVP_R_WRAP_MODE_NOT_ALLOWED);
205 : 0 : return 0;
206 : : }
207 : :
208 [ + + ]: 6578 : if(!(EVP_CIPHER_CTX_flags(ctx) & EVP_CIPH_CUSTOM_IV)) {
209 [ + + + + : 5824 : switch(EVP_CIPHER_CTX_mode(ctx)) {
- ]
210 : :
211 : : case EVP_CIPH_STREAM_CIPHER:
212 : : case EVP_CIPH_ECB_MODE:
213 : : break;
214 : :
215 : : case EVP_CIPH_CFB_MODE:
216 : : case EVP_CIPH_OFB_MODE:
217 : :
218 : 224 : ctx->num = 0;
219 : : /* fall-through */
220 : :
221 : : case EVP_CIPH_CBC_MODE:
222 : :
223 [ - + ]: 5329 : OPENSSL_assert(EVP_CIPHER_CTX_iv_length(ctx) <=
224 : : (int)sizeof(ctx->iv));
225 [ + + ]: 5329 : if(iv) memcpy(ctx->oiv, iv, EVP_CIPHER_CTX_iv_length(ctx));
226 : 5329 : memcpy(ctx->iv, ctx->oiv, EVP_CIPHER_CTX_iv_length(ctx));
227 : : break;
228 : :
229 : : case EVP_CIPH_CTR_MODE:
230 : 9 : ctx->num = 0;
231 : : /* Don't reuse IV for CTR mode */
232 [ + - ]: 9 : if(iv)
233 : 9 : memcpy(ctx->iv, iv, EVP_CIPHER_CTX_iv_length(ctx));
234 : : break;
235 : :
236 : : default:
237 : : return 0;
238 : : break;
239 : : }
240 : : }
241 : :
242 : :
243 [ + + ][ + + ]: 6578 : if(key || (ctx->cipher->flags & EVP_CIPH_ALWAYS_CALL_INIT)) {
244 [ + - ]: 6296 : if(!ctx->cipher->init(ctx,key,iv,enc)) return 0;
245 : : }
246 : 6578 : ctx->buf_len=0;
247 : 6578 : ctx->final_used=0;
248 : 6578 : ctx->block_mask=ctx->cipher->block_size-1;
249 : 6578 : return 1;
250 : : }
251 : :
252 : 1890 : int EVP_CipherUpdate(EVP_CIPHER_CTX *ctx, unsigned char *out, int *outl,
253 : : const unsigned char *in, int inl)
254 : : {
255 [ + + ]: 1890 : if (ctx->encrypt)
256 : 1059 : return EVP_EncryptUpdate(ctx,out,outl,in,inl);
257 : 831 : else return EVP_DecryptUpdate(ctx,out,outl,in,inl);
258 : : }
259 : :
260 : 278 : int EVP_CipherFinal_ex(EVP_CIPHER_CTX *ctx, unsigned char *out, int *outl)
261 : : {
262 [ + + ]: 278 : if (ctx->encrypt)
263 : 139 : return EVP_EncryptFinal_ex(ctx,out,outl);
264 : 139 : else return EVP_DecryptFinal_ex(ctx,out,outl);
265 : : }
266 : :
267 : 0 : int EVP_CipherFinal(EVP_CIPHER_CTX *ctx, unsigned char *out, int *outl)
268 : : {
269 [ # # ]: 0 : if (ctx->encrypt)
270 : 0 : return EVP_EncryptFinal(ctx,out,outl);
271 : 0 : else return EVP_DecryptFinal(ctx,out,outl);
272 : : }
273 : :
274 : 0 : int EVP_EncryptInit(EVP_CIPHER_CTX *ctx, const EVP_CIPHER *cipher,
275 : : const unsigned char *key, const unsigned char *iv)
276 : : {
277 : 0 : return EVP_CipherInit(ctx, cipher, key, iv, 1);
278 : : }
279 : :
280 : 1264 : int EVP_EncryptInit_ex(EVP_CIPHER_CTX *ctx,const EVP_CIPHER *cipher, ENGINE *impl,
281 : : const unsigned char *key, const unsigned char *iv)
282 : : {
283 : 1264 : return EVP_CipherInit_ex(ctx, cipher, impl, key, iv, 1);
284 : : }
285 : :
286 : 0 : int EVP_DecryptInit(EVP_CIPHER_CTX *ctx, const EVP_CIPHER *cipher,
287 : : const unsigned char *key, const unsigned char *iv)
288 : : {
289 : 0 : return EVP_CipherInit(ctx, cipher, key, iv, 0);
290 : : }
291 : :
292 : 428 : int EVP_DecryptInit_ex(EVP_CIPHER_CTX *ctx, const EVP_CIPHER *cipher, ENGINE *impl,
293 : : const unsigned char *key, const unsigned char *iv)
294 : : {
295 : 428 : return EVP_CipherInit_ex(ctx, cipher, impl, key, iv, 0);
296 : : }
297 : :
298 : 3054 : int EVP_EncryptUpdate(EVP_CIPHER_CTX *ctx, unsigned char *out, int *outl,
299 : : const unsigned char *in, int inl)
300 : : {
301 : : int i,j,bl;
302 : :
303 [ + + ]: 3054 : if (ctx->cipher->flags & EVP_CIPH_FLAG_CUSTOM_CIPHER)
304 : : {
305 : 56 : i = ctx->cipher->do_cipher(ctx, out, in, inl);
306 [ + - ]: 56 : if (i < 0)
307 : : return 0;
308 : : else
309 : 56 : *outl = i;
310 : 56 : return 1;
311 : : }
312 : :
313 [ - + ]: 2998 : if (inl <= 0)
314 : : {
315 : 0 : *outl = 0;
316 : 0 : return inl == 0;
317 : : }
318 : :
319 [ + + ][ + + ]: 2998 : if(ctx->buf_len == 0 && (inl&(ctx->block_mask)) == 0)
320 : : {
321 [ + - ]: 957 : if(ctx->cipher->do_cipher(ctx,out,in,inl))
322 : : {
323 : 957 : *outl=inl;
324 : 957 : return 1;
325 : : }
326 : : else
327 : : {
328 : 0 : *outl=0;
329 : 0 : return 0;
330 : : }
331 : : }
332 : 2041 : i=ctx->buf_len;
333 : 2041 : bl=ctx->cipher->block_size;
334 [ - + ]: 2041 : OPENSSL_assert(bl <= (int)sizeof(ctx->buf));
335 [ + + ]: 2041 : if (i != 0)
336 : : {
337 [ - + ]: 1044 : if (i+inl < bl)
338 : : {
339 : 0 : memcpy(&(ctx->buf[i]),in,inl);
340 : 0 : ctx->buf_len+=inl;
341 : 0 : *outl=0;
342 : 0 : return 1;
343 : : }
344 : : else
345 : : {
346 : 1044 : j=bl-i;
347 : 1044 : memcpy(&(ctx->buf[i]),in,j);
348 [ + - ]: 1044 : if(!ctx->cipher->do_cipher(ctx,out,ctx->buf,bl)) return 0;
349 : 1044 : inl-=j;
350 : 1044 : in+=j;
351 : 1044 : out+=bl;
352 : 1044 : *outl=bl;
353 : : }
354 : : }
355 : : else
356 : 997 : *outl = 0;
357 : 2041 : i=inl&(bl-1);
358 : 2041 : inl-=i;
359 [ + - ]: 2041 : if (inl > 0)
360 : : {
361 [ + - ]: 2041 : if(!ctx->cipher->do_cipher(ctx,out,in,inl)) return 0;
362 : 2041 : *outl+=inl;
363 : : }
364 : :
365 [ + + ]: 2041 : if (i != 0)
366 : 1915 : memcpy(ctx->buf,&(in[inl]),i);
367 : 2041 : ctx->buf_len=i;
368 : 2041 : return 1;
369 : : }
370 : :
371 : 816 : int EVP_EncryptFinal(EVP_CIPHER_CTX *ctx, unsigned char *out, int *outl)
372 : : {
373 : : int ret;
374 : 816 : ret = EVP_EncryptFinal_ex(ctx, out, outl);
375 : 816 : return ret;
376 : : }
377 : :
378 : 1149 : int EVP_EncryptFinal_ex(EVP_CIPHER_CTX *ctx, unsigned char *out, int *outl)
379 : : {
380 : : int n,ret;
381 : : unsigned int i, b, bl;
382 : :
383 [ + + ]: 1149 : if (ctx->cipher->flags & EVP_CIPH_FLAG_CUSTOM_CIPHER)
384 : : {
385 : 34 : ret = ctx->cipher->do_cipher(ctx, out, NULL, 0);
386 [ + - ]: 34 : if (ret < 0)
387 : : return 0;
388 : : else
389 : 34 : *outl = ret;
390 : 34 : return 1;
391 : : }
392 : :
393 : 1115 : b=ctx->cipher->block_size;
394 [ - + ]: 1115 : OPENSSL_assert(b <= sizeof ctx->buf);
395 [ + + ]: 1115 : if (b == 1)
396 : : {
397 : 126 : *outl=0;
398 : 126 : return 1;
399 : : }
400 : 989 : bl=ctx->buf_len;
401 [ + + ]: 989 : if (ctx->flags & EVP_CIPH_NO_PADDING)
402 : : {
403 [ - + ]: 70 : if(bl)
404 : : {
405 : 0 : EVPerr(EVP_F_EVP_ENCRYPTFINAL_EX,EVP_R_DATA_NOT_MULTIPLE_OF_BLOCK_LENGTH);
406 : 0 : return 0;
407 : : }
408 : 70 : *outl = 0;
409 : 70 : return 1;
410 : : }
411 : :
412 : 919 : n=b-bl;
413 [ + + ]: 8848 : for (i=bl; i<b; i++)
414 : 7929 : ctx->buf[i]=n;
415 : 919 : ret=ctx->cipher->do_cipher(ctx,out,ctx->buf,b);
416 : :
417 : :
418 [ + - ]: 919 : if(ret)
419 : 919 : *outl=b;
420 : :
421 : 919 : return ret;
422 : : }
423 : :
424 : 1025 : int EVP_DecryptUpdate(EVP_CIPHER_CTX *ctx, unsigned char *out, int *outl,
425 : : const unsigned char *in, int inl)
426 : : {
427 : : int fix_len;
428 : : unsigned int b;
429 : :
430 [ + + ]: 1025 : if (ctx->cipher->flags & EVP_CIPH_FLAG_CUSTOM_CIPHER)
431 : : {
432 : 54 : fix_len = ctx->cipher->do_cipher(ctx, out, in, inl);
433 [ - + ]: 54 : if (fix_len < 0)
434 : : {
435 : 0 : *outl = 0;
436 : 0 : return 0;
437 : : }
438 : : else
439 : 54 : *outl = fix_len;
440 : 54 : return 1;
441 : : }
442 : :
443 [ - + ]: 971 : if (inl <= 0)
444 : : {
445 : 0 : *outl = 0;
446 : 0 : return inl == 0;
447 : : }
448 : :
449 [ + + ]: 971 : if (ctx->flags & EVP_CIPH_NO_PADDING)
450 : 137 : return EVP_EncryptUpdate(ctx, out, outl, in, inl);
451 : :
452 : 834 : b=ctx->cipher->block_size;
453 [ - + ]: 834 : OPENSSL_assert(b <= sizeof ctx->final);
454 : :
455 [ - + ]: 834 : if(ctx->final_used)
456 : : {
457 : 0 : memcpy(out,ctx->final,b);
458 : 0 : out+=b;
459 : 0 : fix_len = 1;
460 : : }
461 : : else
462 : : fix_len = 0;
463 : :
464 : :
465 [ + - ]: 834 : if(!EVP_EncryptUpdate(ctx,out,outl,in,inl))
466 : : return 0;
467 : :
468 : : /* if we have 'decrypted' a multiple of block size, make sure
469 : : * we have a copy of this last block */
470 [ + + ][ + + ]: 834 : if (b > 1 && !ctx->buf_len)
471 : : {
472 : 114 : *outl-=b;
473 : 114 : ctx->final_used=1;
474 : 114 : memcpy(ctx->final,&out[*outl],b);
475 : : }
476 : : else
477 : 720 : ctx->final_used = 0;
478 : :
479 [ - + ]: 834 : if (fix_len)
480 : 0 : *outl += b;
481 : :
482 : : return 1;
483 : : }
484 : :
485 : 11 : int EVP_DecryptFinal(EVP_CIPHER_CTX *ctx, unsigned char *out, int *outl)
486 : : {
487 : : int ret;
488 : 11 : ret = EVP_DecryptFinal_ex(ctx, out, outl);
489 : 11 : return ret;
490 : : }
491 : :
492 : 320 : int EVP_DecryptFinal_ex(EVP_CIPHER_CTX *ctx, unsigned char *out, int *outl)
493 : : {
494 : : int i,n;
495 : : unsigned int b;
496 : 320 : *outl=0;
497 : :
498 [ + + ]: 320 : if (ctx->cipher->flags & EVP_CIPH_FLAG_CUSTOM_CIPHER)
499 : : {
500 : 33 : i = ctx->cipher->do_cipher(ctx, out, NULL, 0);
501 [ + - ]: 33 : if (i < 0)
502 : : return 0;
503 : : else
504 : 33 : *outl = i;
505 : 33 : return 1;
506 : : }
507 : :
508 : 287 : b=ctx->cipher->block_size;
509 [ + + ]: 287 : if (ctx->flags & EVP_CIPH_NO_PADDING)
510 : : {
511 [ - + ]: 137 : if(ctx->buf_len)
512 : : {
513 : 0 : EVPerr(EVP_F_EVP_DECRYPTFINAL_EX,EVP_R_DATA_NOT_MULTIPLE_OF_BLOCK_LENGTH);
514 : 0 : return 0;
515 : : }
516 : : *outl = 0;
517 : : return 1;
518 : : }
519 [ + + ]: 150 : if (b > 1)
520 : : {
521 [ + - ][ - + ]: 114 : if (ctx->buf_len || !ctx->final_used)
522 : : {
523 : 0 : EVPerr(EVP_F_EVP_DECRYPTFINAL_EX,EVP_R_WRONG_FINAL_BLOCK_LENGTH);
524 : 0 : return(0);
525 : : }
526 [ - + ]: 114 : OPENSSL_assert(b <= sizeof ctx->final);
527 : 114 : n=ctx->final[b-1];
528 [ + - ]: 114 : if (n == 0 || n > (int)b)
529 : : {
530 : 0 : EVPerr(EVP_F_EVP_DECRYPTFINAL_EX,EVP_R_BAD_DECRYPT);
531 : 0 : return(0);
532 : : }
533 [ + + ]: 1084 : for (i=0; i<n; i++)
534 : : {
535 [ - + ]: 970 : if (ctx->final[--b] != n)
536 : : {
537 : 0 : EVPerr(EVP_F_EVP_DECRYPTFINAL_EX,EVP_R_BAD_DECRYPT);
538 : 0 : return(0);
539 : : }
540 : : }
541 : 114 : n=ctx->cipher->block_size-n;
542 [ + + ]: 456 : for (i=0; i<n; i++)
543 : 342 : out[i]=ctx->final[i];
544 : 114 : *outl=n;
545 : : }
546 : : else
547 : : *outl=0;
548 : : return(1);
549 : : }
550 : :
551 : 595 : void EVP_CIPHER_CTX_free(EVP_CIPHER_CTX *ctx)
552 : : {
553 [ + - ]: 595 : if (ctx)
554 : : {
555 : 595 : EVP_CIPHER_CTX_cleanup(ctx);
556 : 595 : OPENSSL_free(ctx);
557 : : }
558 : 595 : }
559 : :
560 : 6960 : int EVP_CIPHER_CTX_cleanup(EVP_CIPHER_CTX *c)
561 : : {
562 [ + + ]: 6960 : if (c->cipher != NULL)
563 : : {
564 [ + + ][ + - ]: 6595 : if(c->cipher->cleanup && !c->cipher->cleanup(c))
565 : : return 0;
566 : : /* Cleanse cipher context data */
567 [ + + ]: 6595 : if (c->cipher_data)
568 : 6463 : OPENSSL_cleanse(c->cipher_data, c->cipher->ctx_size);
569 : : }
570 [ + + ]: 6960 : if (c->cipher_data)
571 : 6463 : OPENSSL_free(c->cipher_data);
572 : : #ifndef OPENSSL_NO_ENGINE
573 [ + + ]: 6960 : if (c->engine)
574 : : /* The EVP_CIPHER we used belongs to an ENGINE, release the
575 : : * functional reference we held for this reason. */
576 : 8 : ENGINE_finish(c->engine);
577 : : #endif
578 : : memset(c,0,sizeof(EVP_CIPHER_CTX));
579 : 6960 : return 1;
580 : : }
581 : :
582 : 4 : int EVP_CIPHER_CTX_set_key_length(EVP_CIPHER_CTX *c, int keylen)
583 : : {
584 [ - + ]: 4 : if(c->cipher->flags & EVP_CIPH_CUSTOM_KEY_LENGTH)
585 : 0 : return EVP_CIPHER_CTX_ctrl(c, EVP_CTRL_SET_KEY_LENGTH, keylen, NULL);
586 [ + + ]: 4 : if(c->key_len == keylen) return 1;
587 [ + - ][ + - ]: 2 : if((keylen > 0) && (c->cipher->flags & EVP_CIPH_VARIABLE_LENGTH))
588 : : {
589 : 2 : c->key_len = keylen;
590 : 2 : return 1;
591 : : }
592 : 0 : EVPerr(EVP_F_EVP_CIPHER_CTX_SET_KEY_LENGTH,EVP_R_INVALID_KEY_LENGTH);
593 : 0 : return 0;
594 : : }
595 : :
596 : 357 : int EVP_CIPHER_CTX_set_padding(EVP_CIPHER_CTX *ctx, int pad)
597 : : {
598 [ - + ]: 357 : if (pad) ctx->flags &= ~EVP_CIPH_NO_PADDING;
599 : 357 : else ctx->flags |= EVP_CIPH_NO_PADDING;
600 : 357 : return 1;
601 : : }
602 : :
603 : 5494 : int EVP_CIPHER_CTX_ctrl(EVP_CIPHER_CTX *ctx, int type, int arg, void *ptr)
604 : : {
605 : : int ret;
606 [ - + ]: 5494 : if(!ctx->cipher) {
607 : 0 : EVPerr(EVP_F_EVP_CIPHER_CTX_CTRL, EVP_R_NO_CIPHER_SET);
608 : 0 : return 0;
609 : : }
610 : :
611 [ - + ]: 5494 : if(!ctx->cipher->ctrl) {
612 : 0 : EVPerr(EVP_F_EVP_CIPHER_CTX_CTRL, EVP_R_CTRL_NOT_IMPLEMENTED);
613 : 0 : return 0;
614 : : }
615 : :
616 : 5494 : ret = ctx->cipher->ctrl(ctx, type, arg, ptr);
617 [ - + ]: 5494 : if(ret == -1) {
618 : 0 : EVPerr(EVP_F_EVP_CIPHER_CTX_CTRL, EVP_R_CTRL_OPERATION_NOT_IMPLEMENTED);
619 : 0 : return 0;
620 : : }
621 : : return ret;
622 : : }
623 : :
624 : 46 : int EVP_CIPHER_CTX_rand_key(EVP_CIPHER_CTX *ctx, unsigned char *key)
625 : : {
626 [ + + ]: 46 : if (ctx->cipher->flags & EVP_CIPH_RAND_KEY)
627 : 27 : return EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_RAND_KEY, 0, key);
628 [ + - ]: 19 : if (RAND_bytes(key, ctx->key_len) <= 0)
629 : : return 0;
630 : 19 : return 1;
631 : : }
632 : :
633 : 357 : int EVP_CIPHER_CTX_copy(EVP_CIPHER_CTX *out, const EVP_CIPHER_CTX *in)
634 : : {
635 [ + - ][ - + ]: 357 : if ((in == NULL) || (in->cipher == NULL))
636 : : {
637 : 0 : EVPerr(EVP_F_EVP_CIPHER_CTX_COPY,EVP_R_INPUT_NOT_INITIALIZED);
638 : 0 : return 0;
639 : : }
640 : : #ifndef OPENSSL_NO_ENGINE
641 : : /* Make sure it's safe to copy a cipher context using an ENGINE */
642 [ - + ][ # # ]: 357 : if (in->engine && !ENGINE_init(in->engine))
643 : : {
644 : 0 : EVPerr(EVP_F_EVP_CIPHER_CTX_COPY,ERR_R_ENGINE_LIB);
645 : 0 : return 0;
646 : : }
647 : : #endif
648 : :
649 : 357 : EVP_CIPHER_CTX_cleanup(out);
650 : : memcpy(out,in,sizeof *out);
651 : :
652 [ + - ][ + - ]: 357 : if (in->cipher_data && in->cipher->ctx_size)
653 : : {
654 : 357 : out->cipher_data=OPENSSL_malloc(in->cipher->ctx_size);
655 [ - + ]: 357 : if (!out->cipher_data)
656 : : {
657 : 0 : EVPerr(EVP_F_EVP_CIPHER_CTX_COPY,ERR_R_MALLOC_FAILURE);
658 : 0 : return 0;
659 : : }
660 : 357 : memcpy(out->cipher_data,in->cipher_data,in->cipher->ctx_size);
661 : : }
662 : :
663 [ + + ]: 357 : if (in->cipher->flags & EVP_CIPH_CUSTOM_COPY)
664 : 90 : return in->cipher->ctrl((EVP_CIPHER_CTX *)in, EVP_CTRL_COPY, 0, out);
665 : : return 1;
666 : : }
667 : :
|
