Make EVP_CIPHER_CTX opaque and renew the creator / destructor functions
[openssl.git] / crypto / evp / evp_lib.c
1 /* crypto/evp/evp_lib.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 "internal/cryptlib.h"
61 #include <openssl/evp.h>
62 #include <openssl/objects.h>
63 #include "internal/evp_int.h"
64 #include "evp_locl.h"
65
66 int EVP_CIPHER_param_to_asn1(EVP_CIPHER_CTX *c, ASN1_TYPE *type)
67 {
68     int ret;
69
70     if (c->cipher->set_asn1_parameters != NULL)
71         ret = c->cipher->set_asn1_parameters(c, type);
72     else if (c->cipher->flags & EVP_CIPH_FLAG_DEFAULT_ASN1) {
73         switch (EVP_CIPHER_CTX_mode(c)) {
74         case EVP_CIPH_WRAP_MODE:
75             if (EVP_CIPHER_CTX_nid(c) == NID_id_smime_alg_CMS3DESwrap)
76                 ASN1_TYPE_set(type, V_ASN1_NULL, NULL);
77             ret = 1;
78             break;
79
80         case EVP_CIPH_GCM_MODE:
81         case EVP_CIPH_CCM_MODE:
82         case EVP_CIPH_XTS_MODE:
83         case EVP_CIPH_OCB_MODE:
84             ret = -1;
85             break;
86
87         default:
88             ret = EVP_CIPHER_set_asn1_iv(c, type);
89         }
90     } else
91         ret = -1;
92     return (ret);
93 }
94
95 int EVP_CIPHER_asn1_to_param(EVP_CIPHER_CTX *c, ASN1_TYPE *type)
96 {
97     int ret;
98
99     if (c->cipher->get_asn1_parameters != NULL)
100         ret = c->cipher->get_asn1_parameters(c, type);
101     else if (c->cipher->flags & EVP_CIPH_FLAG_DEFAULT_ASN1) {
102         switch (EVP_CIPHER_CTX_mode(c)) {
103
104         case EVP_CIPH_WRAP_MODE:
105             ret = 1;
106             break;
107
108         case EVP_CIPH_GCM_MODE:
109         case EVP_CIPH_CCM_MODE:
110         case EVP_CIPH_XTS_MODE:
111         case EVP_CIPH_OCB_MODE:
112             ret = -1;
113             break;
114
115         default:
116             ret = EVP_CIPHER_get_asn1_iv(c, type);
117             break;
118         }
119     } else
120         ret = -1;
121     return (ret);
122 }
123
124 int EVP_CIPHER_get_asn1_iv(EVP_CIPHER_CTX *c, ASN1_TYPE *type)
125 {
126     int i = 0;
127     unsigned int l;
128
129     if (type != NULL) {
130         l = EVP_CIPHER_CTX_iv_length(c);
131         OPENSSL_assert(l <= sizeof(c->iv));
132         i = ASN1_TYPE_get_octetstring(type, c->oiv, l);
133         if (i != (int)l)
134             return (-1);
135         else if (i > 0)
136             memcpy(c->iv, c->oiv, l);
137     }
138     return (i);
139 }
140
141 int EVP_CIPHER_set_asn1_iv(EVP_CIPHER_CTX *c, ASN1_TYPE *type)
142 {
143     int i = 0;
144     unsigned int j;
145
146     if (type != NULL) {
147         j = EVP_CIPHER_CTX_iv_length(c);
148         OPENSSL_assert(j <= sizeof(c->iv));
149         i = ASN1_TYPE_set_octetstring(type, c->oiv, j);
150     }
151     return (i);
152 }
153
154 /* Convert the various cipher NIDs and dummies to a proper OID NID */
155 int EVP_CIPHER_type(const EVP_CIPHER *ctx)
156 {
157     int nid;
158     ASN1_OBJECT *otmp;
159     nid = EVP_CIPHER_nid(ctx);
160
161     switch (nid) {
162
163     case NID_rc2_cbc:
164     case NID_rc2_64_cbc:
165     case NID_rc2_40_cbc:
166
167         return NID_rc2_cbc;
168
169     case NID_rc4:
170     case NID_rc4_40:
171
172         return NID_rc4;
173
174     case NID_aes_128_cfb128:
175     case NID_aes_128_cfb8:
176     case NID_aes_128_cfb1:
177
178         return NID_aes_128_cfb128;
179
180     case NID_aes_192_cfb128:
181     case NID_aes_192_cfb8:
182     case NID_aes_192_cfb1:
183
184         return NID_aes_192_cfb128;
185
186     case NID_aes_256_cfb128:
187     case NID_aes_256_cfb8:
188     case NID_aes_256_cfb1:
189
190         return NID_aes_256_cfb128;
191
192     case NID_des_cfb64:
193     case NID_des_cfb8:
194     case NID_des_cfb1:
195
196         return NID_des_cfb64;
197
198     case NID_des_ede3_cfb64:
199     case NID_des_ede3_cfb8:
200     case NID_des_ede3_cfb1:
201
202         return NID_des_cfb64;
203
204     default:
205         /* Check it has an OID and it is valid */
206         otmp = OBJ_nid2obj(nid);
207         if (OBJ_get0_data(otmp) == NULL)
208             nid = NID_undef;
209         ASN1_OBJECT_free(otmp);
210         return nid;
211     }
212 }
213
214 int EVP_CIPHER_block_size(const EVP_CIPHER *e)
215 {
216     return e->block_size;
217 }
218
219 int EVP_CIPHER_CTX_block_size(const EVP_CIPHER_CTX *ctx)
220 {
221     return ctx->cipher->block_size;
222 }
223
224 int EVP_Cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
225                const unsigned char *in, unsigned int inl)
226 {
227     return ctx->cipher->do_cipher(ctx, out, in, inl);
228 }
229
230 const EVP_CIPHER *EVP_CIPHER_CTX_cipher(const EVP_CIPHER_CTX *ctx)
231 {
232     return ctx->cipher;
233 }
234
235 unsigned long EVP_CIPHER_flags(const EVP_CIPHER *cipher)
236 {
237     return cipher->flags;
238 }
239
240 unsigned long EVP_CIPHER_CTX_flags(const EVP_CIPHER_CTX *ctx)
241 {
242     return ctx->cipher->flags;
243 }
244
245 void *EVP_CIPHER_CTX_get_app_data(const EVP_CIPHER_CTX *ctx)
246 {
247     return ctx->app_data;
248 }
249
250 void EVP_CIPHER_CTX_set_app_data(EVP_CIPHER_CTX *ctx, void *data)
251 {
252     ctx->app_data = data;
253 }
254
255 int EVP_CIPHER_iv_length(const EVP_CIPHER *cipher)
256 {
257     return cipher->iv_len;
258 }
259
260 int EVP_CIPHER_CTX_iv_length(const EVP_CIPHER_CTX *ctx)
261 {
262     return ctx->cipher->iv_len;
263 }
264
265 int EVP_CIPHER_key_length(const EVP_CIPHER *cipher)
266 {
267     return cipher->key_len;
268 }
269
270 int EVP_CIPHER_CTX_key_length(const EVP_CIPHER_CTX *ctx)
271 {
272     return ctx->key_len;
273 }
274
275 int EVP_CIPHER_nid(const EVP_CIPHER *cipher)
276 {
277     return cipher->nid;
278 }
279
280 int EVP_CIPHER_CTX_nid(const EVP_CIPHER_CTX *ctx)
281 {
282     return ctx->cipher->nid;
283 }
284
285 int EVP_MD_block_size(const EVP_MD *md)
286 {
287     return md->block_size;
288 }
289
290 int EVP_MD_type(const EVP_MD *md)
291 {
292     return md->type;
293 }
294
295 int EVP_MD_pkey_type(const EVP_MD *md)
296 {
297     return md->pkey_type;
298 }
299
300 int EVP_MD_size(const EVP_MD *md)
301 {
302     if (!md) {
303         EVPerr(EVP_F_EVP_MD_SIZE, EVP_R_MESSAGE_DIGEST_IS_NULL);
304         return -1;
305     }
306     return md->md_size;
307 }
308
309 unsigned long EVP_MD_flags(const EVP_MD *md)
310 {
311     return md->flags;
312 }
313
314 EVP_MD *EVP_MD_meth_new(int md_type, int pkey_type)
315 {
316     EVP_MD *md = (EVP_MD *)OPENSSL_zalloc(sizeof(EVP_MD));
317     if (md != NULL) {
318         md->type = md_type;
319         md->pkey_type = pkey_type;
320     }
321     return md;
322 }
323 EVP_MD *EVP_MD_meth_dup(const EVP_MD *md)
324 {
325     EVP_MD *to = EVP_MD_meth_new(md->type, md->pkey_type);
326     if (md != NULL)
327         memcpy(to, md, sizeof(*to));
328     return to;
329 }
330 void EVP_MD_meth_free(EVP_MD *md)
331 {
332     OPENSSL_free(md);
333 }
334 int EVP_MD_meth_set_input_blocksize(EVP_MD *md, int blocksize)
335 {
336     md->block_size = blocksize;
337     return 1;
338 }
339 int EVP_MD_meth_set_result_size(EVP_MD *md, int resultsize)
340 {
341     md->md_size = resultsize;
342     return 1;
343 }
344 int EVP_MD_meth_set_app_datasize(EVP_MD *md, int datasize)
345 {
346     md->ctx_size = datasize;
347     return 1;
348 }
349 int EVP_MD_meth_set_flags(EVP_MD *md, unsigned long flags)
350 {
351     md->flags = flags;
352     return 1;
353 }
354 int EVP_MD_meth_set_init(EVP_MD *md, int (*init)(EVP_MD_CTX *ctx))
355 {
356     md->init = init;
357     return 1;
358 }
359 int EVP_MD_meth_set_update(EVP_MD *md, int (*update)(EVP_MD_CTX *ctx,
360                                                      const void *data,
361                                                      size_t count))
362 {
363     md->update = update;
364     return 1;
365 }
366 int EVP_MD_meth_set_final(EVP_MD *md, int (*final)(EVP_MD_CTX *ctx,
367                                                    unsigned char *md))
368 {
369     md->final = final;
370     return 1;
371 }
372 int EVP_MD_meth_set_copy(EVP_MD *md, int (*copy)(EVP_MD_CTX *to,
373                                                  const EVP_MD_CTX *from))
374 {
375     md->copy = copy;
376     return 1;
377 }
378 int EVP_MD_meth_set_cleanup(EVP_MD *md, int (*cleanup)(EVP_MD_CTX *ctx))
379 {
380     md->cleanup = cleanup;
381     return 1;
382 }
383 int EVP_MD_meth_set_ctrl(EVP_MD *md, int (*ctrl)(EVP_MD_CTX *ctx, int cmd,
384                                                  int p1, void *p2))
385 {
386     md->md_ctrl = ctrl;
387     return 1;
388 }
389
390 int EVP_MD_meth_get_input_blocksize(const EVP_MD *md)
391 {
392     return md->block_size;
393 }
394 int EVP_MD_meth_get_result_size(const EVP_MD *md)
395 {
396     return md->md_size;
397 }
398 int EVP_MD_meth_get_app_datasize(const EVP_MD *md)
399 {
400     return md->ctx_size;
401 }
402 unsigned long EVP_MD_meth_get_flags(const EVP_MD *md)
403 {
404     return md->block_size;
405 }
406 int (*EVP_MD_meth_get_init(const EVP_MD *md))(EVP_MD_CTX *ctx)
407 {
408     return md->init;
409 }
410 int (*EVP_MD_meth_get_update(const EVP_MD *md))(EVP_MD_CTX *ctx,
411                                                 const void *data,
412                                                 size_t count)
413 {
414     return md->update;
415 }
416 int (*EVP_MD_meth_get_final(const EVP_MD *md))(EVP_MD_CTX *ctx,
417                                                unsigned char *md)
418 {
419     return md->final;
420 }
421 int (*EVP_MD_meth_get_copy(const EVP_MD *md))(EVP_MD_CTX *to,
422                                               const EVP_MD_CTX *from)
423 {
424     return md->copy;
425 }
426 int (*EVP_MD_meth_get_cleanup(const EVP_MD *md))(EVP_MD_CTX *ctx)
427 {
428     return md->cleanup;
429 }
430 int (*EVP_MD_meth_get_ctrl(const EVP_MD *md))(EVP_MD_CTX *ctx, int cmd,
431                                               int p1, void *p2)
432 {
433     return md->md_ctrl;
434 }
435
436 const EVP_MD *EVP_MD_CTX_md(const EVP_MD_CTX *ctx)
437 {
438     if (!ctx)
439         return NULL;
440     return ctx->digest;
441 }
442
443 EVP_PKEY_CTX *EVP_MD_CTX_pkey_ctx(const EVP_MD_CTX *ctx)
444 {
445     return ctx->pctx;
446 }
447
448 void *EVP_MD_CTX_md_data(const EVP_MD_CTX *ctx)
449 {
450     return ctx->md_data;
451 }
452
453 int (*EVP_MD_CTX_update_fn(EVP_MD_CTX *ctx))(EVP_MD_CTX *ctx,
454                                              const void *data, size_t count)
455 {
456     return ctx->update;
457 }
458
459 void EVP_MD_CTX_set_update_fn(EVP_MD_CTX *ctx,
460                               int (*update) (EVP_MD_CTX *ctx,
461                                              const void *data, size_t count))
462 {
463     ctx->update = update;
464 }
465
466 void EVP_MD_CTX_set_flags(EVP_MD_CTX *ctx, int flags)
467 {
468     ctx->flags |= flags;
469 }
470
471 void EVP_MD_CTX_clear_flags(EVP_MD_CTX *ctx, int flags)
472 {
473     ctx->flags &= ~flags;
474 }
475
476 int EVP_MD_CTX_test_flags(const EVP_MD_CTX *ctx, int flags)
477 {
478     return (ctx->flags & flags);
479 }
480
481 void EVP_CIPHER_CTX_set_flags(EVP_CIPHER_CTX *ctx, int flags)
482 {
483     ctx->flags |= flags;
484 }
485
486 void EVP_CIPHER_CTX_clear_flags(EVP_CIPHER_CTX *ctx, int flags)
487 {
488     ctx->flags &= ~flags;
489 }
490
491 int EVP_CIPHER_CTX_test_flags(const EVP_CIPHER_CTX *ctx, int flags)
492 {
493     return (ctx->flags & flags);
494 }