914a19cc5e0abf729e0bd2823632bc5cc401f12f
[openssl.git] / crypto / evp / evp_lib.c
1 /*
2  * Copyright 1995-2018 The OpenSSL Project Authors. All Rights Reserved.
3  *
4  * Licensed under the Apache License 2.0 (the "License").  You may not use
5  * this file except in compliance with the License.  You can obtain a copy
6  * in the file LICENSE in the source distribution or at
7  * https://www.openssl.org/source/license.html
8  */
9
10 #include <stdio.h>
11 #include "internal/cryptlib.h"
12 #include <openssl/evp.h>
13 #include <openssl/objects.h>
14 #include "internal/evp_int.h"
15 #include "internal/provider.h"
16 #include "evp_locl.h"
17
18 int EVP_CIPHER_param_to_asn1(EVP_CIPHER_CTX *c, ASN1_TYPE *type)
19 {
20     int ret;
21
22     if (c->cipher->set_asn1_parameters != NULL)
23         ret = c->cipher->set_asn1_parameters(c, type);
24     else if (c->cipher->flags & EVP_CIPH_FLAG_DEFAULT_ASN1) {
25         switch (EVP_CIPHER_CTX_mode(c)) {
26         case EVP_CIPH_WRAP_MODE:
27             if (EVP_CIPHER_CTX_nid(c) == NID_id_smime_alg_CMS3DESwrap)
28                 ASN1_TYPE_set(type, V_ASN1_NULL, NULL);
29             ret = 1;
30             break;
31
32         case EVP_CIPH_GCM_MODE:
33         case EVP_CIPH_CCM_MODE:
34         case EVP_CIPH_XTS_MODE:
35         case EVP_CIPH_OCB_MODE:
36             ret = -2;
37             break;
38
39         default:
40             ret = EVP_CIPHER_set_asn1_iv(c, type);
41         }
42     } else
43         ret = -1;
44     if (ret <= 0)
45         EVPerr(EVP_F_EVP_CIPHER_PARAM_TO_ASN1, ret == -2 ?
46                ASN1_R_UNSUPPORTED_CIPHER :
47                EVP_R_CIPHER_PARAMETER_ERROR);
48     if (ret < -1)
49         ret = -1;
50     return ret;
51 }
52
53 int EVP_CIPHER_asn1_to_param(EVP_CIPHER_CTX *c, ASN1_TYPE *type)
54 {
55     int ret;
56
57     if (c->cipher->get_asn1_parameters != NULL)
58         ret = c->cipher->get_asn1_parameters(c, type);
59     else if (c->cipher->flags & EVP_CIPH_FLAG_DEFAULT_ASN1) {
60         switch (EVP_CIPHER_CTX_mode(c)) {
61
62         case EVP_CIPH_WRAP_MODE:
63             ret = 1;
64             break;
65
66         case EVP_CIPH_GCM_MODE:
67         case EVP_CIPH_CCM_MODE:
68         case EVP_CIPH_XTS_MODE:
69         case EVP_CIPH_OCB_MODE:
70             ret = -2;
71             break;
72
73         default:
74             ret = EVP_CIPHER_get_asn1_iv(c, type);
75             break;
76         }
77     } else
78         ret = -1;
79     if (ret <= 0)
80         EVPerr(EVP_F_EVP_CIPHER_ASN1_TO_PARAM, ret == -2 ?
81                EVP_R_UNSUPPORTED_CIPHER :
82                EVP_R_CIPHER_PARAMETER_ERROR);
83     if (ret < -1)
84         ret = -1;
85     return ret;
86 }
87
88 int EVP_CIPHER_get_asn1_iv(EVP_CIPHER_CTX *c, ASN1_TYPE *type)
89 {
90     int i = 0;
91     unsigned int l;
92
93     if (type != NULL) {
94         l = EVP_CIPHER_CTX_iv_length(c);
95         OPENSSL_assert(l <= sizeof(c->iv));
96         i = ASN1_TYPE_get_octetstring(type, c->oiv, l);
97         if (i != (int)l)
98             return -1;
99         else if (i > 0)
100             memcpy(c->iv, c->oiv, l);
101     }
102     return i;
103 }
104
105 int EVP_CIPHER_set_asn1_iv(EVP_CIPHER_CTX *c, ASN1_TYPE *type)
106 {
107     int i = 0;
108     unsigned int j;
109
110     if (type != NULL) {
111         j = EVP_CIPHER_CTX_iv_length(c);
112         OPENSSL_assert(j <= sizeof(c->iv));
113         i = ASN1_TYPE_set_octetstring(type, c->oiv, j);
114     }
115     return i;
116 }
117
118 /* Convert the various cipher NIDs and dummies to a proper OID NID */
119 int EVP_CIPHER_type(const EVP_CIPHER *ctx)
120 {
121     int nid;
122     ASN1_OBJECT *otmp;
123     nid = EVP_CIPHER_nid(ctx);
124
125     switch (nid) {
126
127     case NID_rc2_cbc:
128     case NID_rc2_64_cbc:
129     case NID_rc2_40_cbc:
130
131         return NID_rc2_cbc;
132
133     case NID_rc4:
134     case NID_rc4_40:
135
136         return NID_rc4;
137
138     case NID_aes_128_cfb128:
139     case NID_aes_128_cfb8:
140     case NID_aes_128_cfb1:
141
142         return NID_aes_128_cfb128;
143
144     case NID_aes_192_cfb128:
145     case NID_aes_192_cfb8:
146     case NID_aes_192_cfb1:
147
148         return NID_aes_192_cfb128;
149
150     case NID_aes_256_cfb128:
151     case NID_aes_256_cfb8:
152     case NID_aes_256_cfb1:
153
154         return NID_aes_256_cfb128;
155
156     case NID_des_cfb64:
157     case NID_des_cfb8:
158     case NID_des_cfb1:
159
160         return NID_des_cfb64;
161
162     case NID_des_ede3_cfb64:
163     case NID_des_ede3_cfb8:
164     case NID_des_ede3_cfb1:
165
166         return NID_des_cfb64;
167
168     default:
169         /* Check it has an OID and it is valid */
170         otmp = OBJ_nid2obj(nid);
171         if (OBJ_get0_data(otmp) == NULL)
172             nid = NID_undef;
173         ASN1_OBJECT_free(otmp);
174         return nid;
175     }
176 }
177
178 int EVP_CIPHER_block_size(const EVP_CIPHER *e)
179 {
180     return e->block_size;
181 }
182
183 int EVP_CIPHER_CTX_block_size(const EVP_CIPHER_CTX *ctx)
184 {
185     return ctx->cipher->block_size;
186 }
187
188 int EVP_CIPHER_impl_ctx_size(const EVP_CIPHER *e)
189 {
190     return e->ctx_size;
191 }
192
193 int EVP_Cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
194                const unsigned char *in, unsigned int inl)
195 {
196     return ctx->cipher->do_cipher(ctx, out, in, inl);
197 }
198
199 const EVP_CIPHER *EVP_CIPHER_CTX_cipher(const EVP_CIPHER_CTX *ctx)
200 {
201     return ctx->cipher;
202 }
203
204 int EVP_CIPHER_CTX_encrypting(const EVP_CIPHER_CTX *ctx)
205 {
206     return ctx->encrypt;
207 }
208
209 unsigned long EVP_CIPHER_flags(const EVP_CIPHER *cipher)
210 {
211     return cipher->flags;
212 }
213
214 void *EVP_CIPHER_CTX_get_app_data(const EVP_CIPHER_CTX *ctx)
215 {
216     return ctx->app_data;
217 }
218
219 void EVP_CIPHER_CTX_set_app_data(EVP_CIPHER_CTX *ctx, void *data)
220 {
221     ctx->app_data = data;
222 }
223
224 void *EVP_CIPHER_CTX_get_cipher_data(const EVP_CIPHER_CTX *ctx)
225 {
226     return ctx->cipher_data;
227 }
228
229 void *EVP_CIPHER_CTX_set_cipher_data(EVP_CIPHER_CTX *ctx, void *cipher_data)
230 {
231     void *old_cipher_data;
232
233     old_cipher_data = ctx->cipher_data;
234     ctx->cipher_data = cipher_data;
235
236     return old_cipher_data;
237 }
238
239 int EVP_CIPHER_iv_length(const EVP_CIPHER *cipher)
240 {
241     return cipher->iv_len;
242 }
243
244 int EVP_CIPHER_CTX_iv_length(const EVP_CIPHER_CTX *ctx)
245 {
246     return ctx->cipher->iv_len;
247 }
248
249 const unsigned char *EVP_CIPHER_CTX_original_iv(const EVP_CIPHER_CTX *ctx)
250 {
251     return ctx->oiv;
252 }
253
254 const unsigned char *EVP_CIPHER_CTX_iv(const EVP_CIPHER_CTX *ctx)
255 {
256     return ctx->iv;
257 }
258
259 unsigned char *EVP_CIPHER_CTX_iv_noconst(EVP_CIPHER_CTX *ctx)
260 {
261     return ctx->iv;
262 }
263
264 unsigned char *EVP_CIPHER_CTX_buf_noconst(EVP_CIPHER_CTX *ctx)
265 {
266     return ctx->buf;
267 }
268
269 int EVP_CIPHER_CTX_num(const EVP_CIPHER_CTX *ctx)
270 {
271     return ctx->num;
272 }
273
274 void EVP_CIPHER_CTX_set_num(EVP_CIPHER_CTX *ctx, int num)
275 {
276     ctx->num = num;
277 }
278
279 int EVP_CIPHER_key_length(const EVP_CIPHER *cipher)
280 {
281     return cipher->key_len;
282 }
283
284 int EVP_CIPHER_CTX_key_length(const EVP_CIPHER_CTX *ctx)
285 {
286     return ctx->key_len;
287 }
288
289 int EVP_CIPHER_nid(const EVP_CIPHER *cipher)
290 {
291     return cipher->nid;
292 }
293
294 int EVP_CIPHER_CTX_nid(const EVP_CIPHER_CTX *ctx)
295 {
296     return ctx->cipher->nid;
297 }
298
299 int EVP_MD_block_size(const EVP_MD *md)
300 {
301     if (md == NULL) {
302         EVPerr(EVP_F_EVP_MD_BLOCK_SIZE, EVP_R_MESSAGE_DIGEST_IS_NULL);
303         return -1;
304     }
305
306     if (md->prov != NULL && md->dblock_size != NULL)
307         return (int)md->dblock_size();
308
309     return md->block_size;
310 }
311
312 int EVP_MD_type(const EVP_MD *md)
313 {
314     return md->type;
315 }
316
317 int EVP_MD_pkey_type(const EVP_MD *md)
318 {
319     return md->pkey_type;
320 }
321
322 int EVP_MD_size(const EVP_MD *md)
323 {
324     if (!md) {
325         EVPerr(EVP_F_EVP_MD_SIZE, EVP_R_MESSAGE_DIGEST_IS_NULL);
326         return -1;
327     }
328
329     if (md->prov != NULL && md->size != NULL)
330         return (int)md->size();
331
332     return md->md_size;
333 }
334
335 unsigned long EVP_MD_flags(const EVP_MD *md)
336 {
337     return md->flags;
338 }
339
340 EVP_MD *EVP_MD_meth_new(int md_type, int pkey_type)
341 {
342     EVP_MD *md = OPENSSL_zalloc(sizeof(*md));
343
344     if (md != NULL) {
345         md->type = md_type;
346         md->pkey_type = pkey_type;
347         md->lock = CRYPTO_THREAD_lock_new();
348         if (md->lock == NULL) {
349             OPENSSL_free(md);
350             return NULL;
351         }
352         md->refcnt = 1;
353     }
354     return md;
355 }
356 EVP_MD *EVP_MD_meth_dup(const EVP_MD *md)
357 {
358     EVP_MD *to = EVP_MD_meth_new(md->type, md->pkey_type);
359
360     if (to != NULL)
361         memcpy(to, md, sizeof(*to));
362     return to;
363 }
364
365 int EVP_MD_upref(EVP_MD *md)
366 {
367     int ref = 0;
368
369     CRYPTO_UP_REF(&md->refcnt, &ref, md->lock);
370     return 1;
371 }
372
373 void EVP_MD_meth_free(EVP_MD *md)
374 {
375     if (md != NULL) {
376         int i;
377
378         CRYPTO_DOWN_REF(&md->refcnt, &i, md->lock);
379         if (i > 0)
380             return;
381         ossl_provider_free(md->prov);
382         CRYPTO_THREAD_lock_free(md->lock);
383         OPENSSL_free(md);
384     }
385 }
386 int EVP_MD_meth_set_input_blocksize(EVP_MD *md, int blocksize)
387 {
388     md->block_size = blocksize;
389     return 1;
390 }
391 int EVP_MD_meth_set_result_size(EVP_MD *md, int resultsize)
392 {
393     md->md_size = resultsize;
394     return 1;
395 }
396 int EVP_MD_meth_set_app_datasize(EVP_MD *md, int datasize)
397 {
398     md->ctx_size = datasize;
399     return 1;
400 }
401 int EVP_MD_meth_set_flags(EVP_MD *md, unsigned long flags)
402 {
403     md->flags = flags;
404     return 1;
405 }
406 int EVP_MD_meth_set_init(EVP_MD *md, int (*init)(EVP_MD_CTX *ctx))
407 {
408     md->init = init;
409     return 1;
410 }
411 int EVP_MD_meth_set_update(EVP_MD *md, int (*update)(EVP_MD_CTX *ctx,
412                                                      const void *data,
413                                                      size_t count))
414 {
415     md->update = update;
416     return 1;
417 }
418 int EVP_MD_meth_set_final(EVP_MD *md, int (*final)(EVP_MD_CTX *ctx,
419                                                    unsigned char *md))
420 {
421     md->final = final;
422     return 1;
423 }
424 int EVP_MD_meth_set_copy(EVP_MD *md, int (*copy)(EVP_MD_CTX *to,
425                                                  const EVP_MD_CTX *from))
426 {
427     md->copy = copy;
428     return 1;
429 }
430 int EVP_MD_meth_set_cleanup(EVP_MD *md, int (*cleanup)(EVP_MD_CTX *ctx))
431 {
432     md->cleanup = cleanup;
433     return 1;
434 }
435 int EVP_MD_meth_set_ctrl(EVP_MD *md, int (*ctrl)(EVP_MD_CTX *ctx, int cmd,
436                                                  int p1, void *p2))
437 {
438     md->md_ctrl = ctrl;
439     return 1;
440 }
441
442 int EVP_MD_meth_get_input_blocksize(const EVP_MD *md)
443 {
444     return md->block_size;
445 }
446 int EVP_MD_meth_get_result_size(const EVP_MD *md)
447 {
448     return md->md_size;
449 }
450 int EVP_MD_meth_get_app_datasize(const EVP_MD *md)
451 {
452     return md->ctx_size;
453 }
454 unsigned long EVP_MD_meth_get_flags(const EVP_MD *md)
455 {
456     return md->flags;
457 }
458 int (*EVP_MD_meth_get_init(const EVP_MD *md))(EVP_MD_CTX *ctx)
459 {
460     return md->init;
461 }
462 int (*EVP_MD_meth_get_update(const EVP_MD *md))(EVP_MD_CTX *ctx,
463                                                 const void *data,
464                                                 size_t count)
465 {
466     return md->update;
467 }
468 int (*EVP_MD_meth_get_final(const EVP_MD *md))(EVP_MD_CTX *ctx,
469                                                unsigned char *md)
470 {
471     return md->final;
472 }
473 int (*EVP_MD_meth_get_copy(const EVP_MD *md))(EVP_MD_CTX *to,
474                                               const EVP_MD_CTX *from)
475 {
476     return md->copy;
477 }
478 int (*EVP_MD_meth_get_cleanup(const EVP_MD *md))(EVP_MD_CTX *ctx)
479 {
480     return md->cleanup;
481 }
482 int (*EVP_MD_meth_get_ctrl(const EVP_MD *md))(EVP_MD_CTX *ctx, int cmd,
483                                               int p1, void *p2)
484 {
485     return md->md_ctrl;
486 }
487
488 const EVP_MD *EVP_MD_CTX_md(const EVP_MD_CTX *ctx)
489 {
490     if (ctx == NULL)
491         return NULL;
492     return ctx->reqdigest;
493 }
494
495 EVP_PKEY_CTX *EVP_MD_CTX_pkey_ctx(const EVP_MD_CTX *ctx)
496 {
497     return ctx->pctx;
498 }
499
500 void EVP_MD_CTX_set_pkey_ctx(EVP_MD_CTX *ctx, EVP_PKEY_CTX *pctx)
501 {
502     /*
503      * it's reasonable to set NULL pctx (a.k.a clear the ctx->pctx), so
504      * we have to deal with the cleanup job here.
505      */
506     if (!EVP_MD_CTX_test_flags(ctx, EVP_MD_CTX_FLAG_KEEP_PKEY_CTX))
507         EVP_PKEY_CTX_free(ctx->pctx);
508
509     ctx->pctx = pctx;
510
511     if (pctx != NULL) {
512         /* make sure pctx is not freed when destroying EVP_MD_CTX */
513         EVP_MD_CTX_set_flags(ctx, EVP_MD_CTX_FLAG_KEEP_PKEY_CTX);
514     } else {
515         EVP_MD_CTX_clear_flags(ctx, EVP_MD_CTX_FLAG_KEEP_PKEY_CTX);
516     }
517 }
518
519 void *EVP_MD_CTX_md_data(const EVP_MD_CTX *ctx)
520 {
521     return ctx->md_data;
522 }
523
524 int (*EVP_MD_CTX_update_fn(EVP_MD_CTX *ctx))(EVP_MD_CTX *ctx,
525                                              const void *data, size_t count)
526 {
527     return ctx->update;
528 }
529
530 void EVP_MD_CTX_set_update_fn(EVP_MD_CTX *ctx,
531                               int (*update) (EVP_MD_CTX *ctx,
532                                              const void *data, size_t count))
533 {
534     ctx->update = update;
535 }
536
537 void EVP_MD_CTX_set_flags(EVP_MD_CTX *ctx, int flags)
538 {
539     ctx->flags |= flags;
540 }
541
542 void EVP_MD_CTX_clear_flags(EVP_MD_CTX *ctx, int flags)
543 {
544     ctx->flags &= ~flags;
545 }
546
547 int EVP_MD_CTX_test_flags(const EVP_MD_CTX *ctx, int flags)
548 {
549     return (ctx->flags & flags);
550 }
551
552 void EVP_CIPHER_CTX_set_flags(EVP_CIPHER_CTX *ctx, int flags)
553 {
554     ctx->flags |= flags;
555 }
556
557 void EVP_CIPHER_CTX_clear_flags(EVP_CIPHER_CTX *ctx, int flags)
558 {
559     ctx->flags &= ~flags;
560 }
561
562 int EVP_CIPHER_CTX_test_flags(const EVP_CIPHER_CTX *ctx, int flags)
563 {
564     return (ctx->flags & flags);
565 }
566
567 int EVP_str2ctrl(int (*cb)(void *ctx, int cmd, void *buf, size_t buflen),
568                  void *ctx, int cmd, const char *value)
569 {
570     size_t len;
571
572     len = strlen(value);
573     if (len > INT_MAX)
574         return -1;
575     return cb(ctx, cmd, (void *)value, len);
576 }
577
578 int EVP_hex2ctrl(int (*cb)(void *ctx, int cmd, void *buf, size_t buflen),
579                  void *ctx, int cmd, const char *hex)
580 {
581     unsigned char *bin;
582     long binlen;
583     int rv = -1;
584
585     bin = OPENSSL_hexstr2buf(hex, &binlen);
586     if (bin == NULL)
587         return 0;
588     if (binlen <= INT_MAX)
589         rv = cb(ctx, cmd, bin, binlen);
590     OPENSSL_free(bin);
591     return rv;
592 }