Fix the update target and remove duplicate file updates
[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
64 int EVP_CIPHER_param_to_asn1(EVP_CIPHER_CTX *c, ASN1_TYPE *type)
65 {
66     int ret;
67
68     if (c->cipher->set_asn1_parameters != NULL)
69         ret = c->cipher->set_asn1_parameters(c, type);
70     else if (c->cipher->flags & EVP_CIPH_FLAG_DEFAULT_ASN1) {
71         if (EVP_CIPHER_CTX_mode(c) == EVP_CIPH_WRAP_MODE) {
72             ASN1_TYPE_set(type, V_ASN1_NULL, NULL);
73             ret = 1;
74         } else
75             ret = EVP_CIPHER_set_asn1_iv(c, type);
76     } else
77         ret = -1;
78     return (ret);
79 }
80
81 int EVP_CIPHER_asn1_to_param(EVP_CIPHER_CTX *c, ASN1_TYPE *type)
82 {
83     int ret;
84
85     if (c->cipher->get_asn1_parameters != NULL)
86         ret = c->cipher->get_asn1_parameters(c, type);
87     else if (c->cipher->flags & EVP_CIPH_FLAG_DEFAULT_ASN1) {
88         if (EVP_CIPHER_CTX_mode(c) == EVP_CIPH_WRAP_MODE)
89             return 1;
90         ret = EVP_CIPHER_get_asn1_iv(c, type);
91     } else
92         ret = -1;
93     return (ret);
94 }
95
96 int EVP_CIPHER_get_asn1_iv(EVP_CIPHER_CTX *c, ASN1_TYPE *type)
97 {
98     int i = 0;
99     unsigned int l;
100
101     if (type != NULL) {
102         l = EVP_CIPHER_CTX_iv_length(c);
103         OPENSSL_assert(l <= sizeof(c->iv));
104         i = ASN1_TYPE_get_octetstring(type, c->oiv, l);
105         if (i != (int)l)
106             return (-1);
107         else if (i > 0)
108             memcpy(c->iv, c->oiv, l);
109     }
110     return (i);
111 }
112
113 int EVP_CIPHER_set_asn1_iv(EVP_CIPHER_CTX *c, ASN1_TYPE *type)
114 {
115     int i = 0;
116     unsigned int j;
117
118     if (type != NULL) {
119         j = EVP_CIPHER_CTX_iv_length(c);
120         OPENSSL_assert(j <= sizeof(c->iv));
121         i = ASN1_TYPE_set_octetstring(type, c->oiv, j);
122     }
123     return (i);
124 }
125
126 /* Convert the various cipher NIDs and dummies to a proper OID NID */
127 int EVP_CIPHER_type(const EVP_CIPHER *ctx)
128 {
129     int nid;
130     ASN1_OBJECT *otmp;
131     nid = EVP_CIPHER_nid(ctx);
132
133     switch (nid) {
134
135     case NID_rc2_cbc:
136     case NID_rc2_64_cbc:
137     case NID_rc2_40_cbc:
138
139         return NID_rc2_cbc;
140
141     case NID_rc4:
142     case NID_rc4_40:
143
144         return NID_rc4;
145
146     case NID_aes_128_cfb128:
147     case NID_aes_128_cfb8:
148     case NID_aes_128_cfb1:
149
150         return NID_aes_128_cfb128;
151
152     case NID_aes_192_cfb128:
153     case NID_aes_192_cfb8:
154     case NID_aes_192_cfb1:
155
156         return NID_aes_192_cfb128;
157
158     case NID_aes_256_cfb128:
159     case NID_aes_256_cfb8:
160     case NID_aes_256_cfb1:
161
162         return NID_aes_256_cfb128;
163
164     case NID_des_cfb64:
165     case NID_des_cfb8:
166     case NID_des_cfb1:
167
168         return NID_des_cfb64;
169
170     case NID_des_ede3_cfb64:
171     case NID_des_ede3_cfb8:
172     case NID_des_ede3_cfb1:
173
174         return NID_des_cfb64;
175
176     default:
177         /* Check it has an OID and it is valid */
178         otmp = OBJ_nid2obj(nid);
179         if (OBJ_get0_data(otmp) == NULL)
180             nid = NID_undef;
181         ASN1_OBJECT_free(otmp);
182         return nid;
183     }
184 }
185
186 int EVP_CIPHER_block_size(const EVP_CIPHER *e)
187 {
188     return e->block_size;
189 }
190
191 int EVP_CIPHER_CTX_block_size(const EVP_CIPHER_CTX *ctx)
192 {
193     return ctx->cipher->block_size;
194 }
195
196 int EVP_Cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
197                const unsigned char *in, unsigned int inl)
198 {
199     return ctx->cipher->do_cipher(ctx, out, in, inl);
200 }
201
202 const EVP_CIPHER *EVP_CIPHER_CTX_cipher(const EVP_CIPHER_CTX *ctx)
203 {
204     return ctx->cipher;
205 }
206
207 unsigned long EVP_CIPHER_flags(const EVP_CIPHER *cipher)
208 {
209     return cipher->flags;
210 }
211
212 unsigned long EVP_CIPHER_CTX_flags(const EVP_CIPHER_CTX *ctx)
213 {
214     return ctx->cipher->flags;
215 }
216
217 void *EVP_CIPHER_CTX_get_app_data(const EVP_CIPHER_CTX *ctx)
218 {
219     return ctx->app_data;
220 }
221
222 void EVP_CIPHER_CTX_set_app_data(EVP_CIPHER_CTX *ctx, void *data)
223 {
224     ctx->app_data = data;
225 }
226
227 int EVP_CIPHER_iv_length(const EVP_CIPHER *cipher)
228 {
229     return cipher->iv_len;
230 }
231
232 int EVP_CIPHER_CTX_iv_length(const EVP_CIPHER_CTX *ctx)
233 {
234     return ctx->cipher->iv_len;
235 }
236
237 int EVP_CIPHER_key_length(const EVP_CIPHER *cipher)
238 {
239     return cipher->key_len;
240 }
241
242 int EVP_CIPHER_CTX_key_length(const EVP_CIPHER_CTX *ctx)
243 {
244     return ctx->key_len;
245 }
246
247 int EVP_CIPHER_nid(const EVP_CIPHER *cipher)
248 {
249     return cipher->nid;
250 }
251
252 int EVP_CIPHER_CTX_nid(const EVP_CIPHER_CTX *ctx)
253 {
254     return ctx->cipher->nid;
255 }
256
257 int EVP_MD_block_size(const EVP_MD *md)
258 {
259     return md->block_size;
260 }
261
262 int EVP_MD_type(const EVP_MD *md)
263 {
264     return md->type;
265 }
266
267 int EVP_MD_pkey_type(const EVP_MD *md)
268 {
269     return md->pkey_type;
270 }
271
272 int EVP_MD_size(const EVP_MD *md)
273 {
274     if (!md) {
275         EVPerr(EVP_F_EVP_MD_SIZE, EVP_R_MESSAGE_DIGEST_IS_NULL);
276         return -1;
277     }
278     return md->md_size;
279 }
280
281 unsigned long EVP_MD_flags(const EVP_MD *md)
282 {
283     return md->flags;
284 }
285
286 const EVP_MD *EVP_MD_CTX_md(const EVP_MD_CTX *ctx)
287 {
288     if (!ctx)
289         return NULL;
290     return ctx->digest;
291 }
292
293 void EVP_MD_CTX_set_flags(EVP_MD_CTX *ctx, int flags)
294 {
295     ctx->flags |= flags;
296 }
297
298 void EVP_MD_CTX_clear_flags(EVP_MD_CTX *ctx, int flags)
299 {
300     ctx->flags &= ~flags;
301 }
302
303 int EVP_MD_CTX_test_flags(const EVP_MD_CTX *ctx, int flags)
304 {
305     return (ctx->flags & flags);
306 }
307
308 void EVP_CIPHER_CTX_set_flags(EVP_CIPHER_CTX *ctx, int flags)
309 {
310     ctx->flags |= flags;
311 }
312
313 void EVP_CIPHER_CTX_clear_flags(EVP_CIPHER_CTX *ctx, int flags)
314 {
315     ctx->flags &= ~flags;
316 }
317
318 int EVP_CIPHER_CTX_test_flags(const EVP_CIPHER_CTX *ctx, int flags)
319 {
320     return (ctx->flags & flags);
321 }