Add accessors and writers for EVP_CIPHER_CTX
[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 int EVP_CIPHER_CTX_encrypting(const EVP_CIPHER_CTX *ctx)
236 {
237     return ctx->encrypt;
238 }
239
240 unsigned long EVP_CIPHER_flags(const EVP_CIPHER *cipher)
241 {
242     return cipher->flags;
243 }
244
245 unsigned long EVP_CIPHER_CTX_flags(const EVP_CIPHER_CTX *ctx)
246 {
247     return ctx->cipher->flags;
248 }
249
250 void *EVP_CIPHER_CTX_get_app_data(const EVP_CIPHER_CTX *ctx)
251 {
252     return ctx->app_data;
253 }
254
255 void EVP_CIPHER_CTX_set_app_data(EVP_CIPHER_CTX *ctx, void *data)
256 {
257     ctx->app_data = data;
258 }
259
260 void *EVP_CIPHER_CTX_cipher_data(const EVP_CIPHER_CTX *ctx)
261 {
262     return ctx->cipher_data;
263 }
264
265 /* FIXME: temporary until EVP_CIPHER goes opaque */
266 void EVP_CIPHER_CTX_new_cipher_data(EVP_CIPHER_CTX *ctx, size_t size)
267 {
268     if (ctx->cipher_data == NULL && ctx->cipher->ctx_size == 0)
269         ctx->cipher_data = OPENSSL_zalloc(size);
270 }
271
272 int EVP_CIPHER_iv_length(const EVP_CIPHER *cipher)
273 {
274     return cipher->iv_len;
275 }
276
277 int EVP_CIPHER_CTX_iv_length(const EVP_CIPHER_CTX *ctx)
278 {
279     return ctx->cipher->iv_len;
280 }
281
282 const unsigned char *EVP_CIPHER_CTX_original_iv(const EVP_CIPHER_CTX *ctx)
283 {
284     return ctx->oiv;
285 }
286
287 const unsigned char *EVP_CIPHER_CTX_iv(const EVP_CIPHER_CTX *ctx)
288 {
289     return ctx->iv;
290 }
291
292 unsigned char *EVP_CIPHER_CTX_iv_noconst(EVP_CIPHER_CTX *ctx)
293 {
294     return ctx->iv;
295 }
296
297 unsigned char *EVP_CIPHER_CTX_buf_noconst(EVP_CIPHER_CTX *ctx)
298 {
299     return ctx->buf;
300 }
301
302 int EVP_CIPHER_CTX_num(const EVP_CIPHER_CTX *ctx)
303 {
304     return ctx->num;
305 }
306
307 void EVP_CIPHER_CTX_set_num(EVP_CIPHER_CTX *ctx, int num)
308 {
309     ctx->num = num;
310 }
311
312 int EVP_CIPHER_key_length(const EVP_CIPHER *cipher)
313 {
314     return cipher->key_len;
315 }
316
317 int EVP_CIPHER_CTX_key_length(const EVP_CIPHER_CTX *ctx)
318 {
319     return ctx->key_len;
320 }
321
322 int EVP_CIPHER_nid(const EVP_CIPHER *cipher)
323 {
324     return cipher->nid;
325 }
326
327 int EVP_CIPHER_CTX_nid(const EVP_CIPHER_CTX *ctx)
328 {
329     return ctx->cipher->nid;
330 }
331
332 int EVP_MD_block_size(const EVP_MD *md)
333 {
334     return md->block_size;
335 }
336
337 int EVP_MD_type(const EVP_MD *md)
338 {
339     return md->type;
340 }
341
342 int EVP_MD_pkey_type(const EVP_MD *md)
343 {
344     return md->pkey_type;
345 }
346
347 int EVP_MD_size(const EVP_MD *md)
348 {
349     if (!md) {
350         EVPerr(EVP_F_EVP_MD_SIZE, EVP_R_MESSAGE_DIGEST_IS_NULL);
351         return -1;
352     }
353     return md->md_size;
354 }
355
356 unsigned long EVP_MD_flags(const EVP_MD *md)
357 {
358     return md->flags;
359 }
360
361 EVP_MD *EVP_MD_meth_new(int md_type, int pkey_type)
362 {
363     EVP_MD *md = (EVP_MD *)OPENSSL_zalloc(sizeof(EVP_MD));
364     if (md != NULL) {
365         md->type = md_type;
366         md->pkey_type = pkey_type;
367     }
368     return md;
369 }
370 EVP_MD *EVP_MD_meth_dup(const EVP_MD *md)
371 {
372     EVP_MD *to = EVP_MD_meth_new(md->type, md->pkey_type);
373     if (md != NULL)
374         memcpy(to, md, sizeof(*to));
375     return to;
376 }
377 void EVP_MD_meth_free(EVP_MD *md)
378 {
379     OPENSSL_free(md);
380 }
381 int EVP_MD_meth_set_input_blocksize(EVP_MD *md, int blocksize)
382 {
383     md->block_size = blocksize;
384     return 1;
385 }
386 int EVP_MD_meth_set_result_size(EVP_MD *md, int resultsize)
387 {
388     md->md_size = resultsize;
389     return 1;
390 }
391 int EVP_MD_meth_set_app_datasize(EVP_MD *md, int datasize)
392 {
393     md->ctx_size = datasize;
394     return 1;
395 }
396 int EVP_MD_meth_set_flags(EVP_MD *md, unsigned long flags)
397 {
398     md->flags = flags;
399     return 1;
400 }
401 int EVP_MD_meth_set_init(EVP_MD *md, int (*init)(EVP_MD_CTX *ctx))
402 {
403     md->init = init;
404     return 1;
405 }
406 int EVP_MD_meth_set_update(EVP_MD *md, int (*update)(EVP_MD_CTX *ctx,
407                                                      const void *data,
408                                                      size_t count))
409 {
410     md->update = update;
411     return 1;
412 }
413 int EVP_MD_meth_set_final(EVP_MD *md, int (*final)(EVP_MD_CTX *ctx,
414                                                    unsigned char *md))
415 {
416     md->final = final;
417     return 1;
418 }
419 int EVP_MD_meth_set_copy(EVP_MD *md, int (*copy)(EVP_MD_CTX *to,
420                                                  const EVP_MD_CTX *from))
421 {
422     md->copy = copy;
423     return 1;
424 }
425 int EVP_MD_meth_set_cleanup(EVP_MD *md, int (*cleanup)(EVP_MD_CTX *ctx))
426 {
427     md->cleanup = cleanup;
428     return 1;
429 }
430 int EVP_MD_meth_set_ctrl(EVP_MD *md, int (*ctrl)(EVP_MD_CTX *ctx, int cmd,
431                                                  int p1, void *p2))
432 {
433     md->md_ctrl = ctrl;
434     return 1;
435 }
436
437 int EVP_MD_meth_get_input_blocksize(const EVP_MD *md)
438 {
439     return md->block_size;
440 }
441 int EVP_MD_meth_get_result_size(const EVP_MD *md)
442 {
443     return md->md_size;
444 }
445 int EVP_MD_meth_get_app_datasize(const EVP_MD *md)
446 {
447     return md->ctx_size;
448 }
449 unsigned long EVP_MD_meth_get_flags(const EVP_MD *md)
450 {
451     return md->block_size;
452 }
453 int (*EVP_MD_meth_get_init(const EVP_MD *md))(EVP_MD_CTX *ctx)
454 {
455     return md->init;
456 }
457 int (*EVP_MD_meth_get_update(const EVP_MD *md))(EVP_MD_CTX *ctx,
458                                                 const void *data,
459                                                 size_t count)
460 {
461     return md->update;
462 }
463 int (*EVP_MD_meth_get_final(const EVP_MD *md))(EVP_MD_CTX *ctx,
464                                                unsigned char *md)
465 {
466     return md->final;
467 }
468 int (*EVP_MD_meth_get_copy(const EVP_MD *md))(EVP_MD_CTX *to,
469                                               const EVP_MD_CTX *from)
470 {
471     return md->copy;
472 }
473 int (*EVP_MD_meth_get_cleanup(const EVP_MD *md))(EVP_MD_CTX *ctx)
474 {
475     return md->cleanup;
476 }
477 int (*EVP_MD_meth_get_ctrl(const EVP_MD *md))(EVP_MD_CTX *ctx, int cmd,
478                                               int p1, void *p2)
479 {
480     return md->md_ctrl;
481 }
482
483 const EVP_MD *EVP_MD_CTX_md(const EVP_MD_CTX *ctx)
484 {
485     if (!ctx)
486         return NULL;
487     return ctx->digest;
488 }
489
490 EVP_PKEY_CTX *EVP_MD_CTX_pkey_ctx(const EVP_MD_CTX *ctx)
491 {
492     return ctx->pctx;
493 }
494
495 void *EVP_MD_CTX_md_data(const EVP_MD_CTX *ctx)
496 {
497     return ctx->md_data;
498 }
499
500 int (*EVP_MD_CTX_update_fn(EVP_MD_CTX *ctx))(EVP_MD_CTX *ctx,
501                                              const void *data, size_t count)
502 {
503     return ctx->update;
504 }
505
506 void EVP_MD_CTX_set_update_fn(EVP_MD_CTX *ctx,
507                               int (*update) (EVP_MD_CTX *ctx,
508                                              const void *data, size_t count))
509 {
510     ctx->update = update;
511 }
512
513 void EVP_MD_CTX_set_flags(EVP_MD_CTX *ctx, int flags)
514 {
515     ctx->flags |= flags;
516 }
517
518 void EVP_MD_CTX_clear_flags(EVP_MD_CTX *ctx, int flags)
519 {
520     ctx->flags &= ~flags;
521 }
522
523 int EVP_MD_CTX_test_flags(const EVP_MD_CTX *ctx, int flags)
524 {
525     return (ctx->flags & flags);
526 }
527
528 void EVP_CIPHER_CTX_set_flags(EVP_CIPHER_CTX *ctx, int flags)
529 {
530     ctx->flags |= flags;
531 }
532
533 void EVP_CIPHER_CTX_clear_flags(EVP_CIPHER_CTX *ctx, int flags)
534 {
535     ctx->flags &= ~flags;
536 }
537
538 int EVP_CIPHER_CTX_test_flags(const EVP_CIPHER_CTX *ctx, int flags)
539 {
540     return (ctx->flags & flags);
541 }