1 /* crypto/evp/digest.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  * Copyright (c) 1998-2001 The OpenSSL Project.  All rights reserved.
60  *
61  * Redistribution and use in source and binary forms, with or without
62  * modification, are permitted provided that the following conditions
63  * are met:
64  *
65  * 1. Redistributions of source code must retain the above copyright
66  *    notice, this list of conditions and the following disclaimer.
67  *
68  * 2. Redistributions in binary form must reproduce the above copyright
69  *    notice, this list of conditions and the following disclaimer in
70  *    the documentation and/or other materials provided with the
71  *    distribution.
72  *
73  * 3. All advertising materials mentioning features or use of this
74  *    software must display the following acknowledgment:
75  *    "This product includes software developed by the OpenSSL Project
76  *    for use in the OpenSSL Toolkit. (http://www.openssl.org/)"
77  *
78  * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
79  *    endorse or promote products derived from this software without
80  *    prior written permission. For written permission, please contact
81  *    openssl-core@openssl.org.
82  *
83  * 5. Products derived from this software may not be called "OpenSSL"
84  *    nor may "OpenSSL" appear in their names without prior written
85  *    permission of the OpenSSL Project.
86  *
87  * 6. Redistributions of any form whatsoever must retain the following
88  *    acknowledgment:
89  *    "This product includes software developed by the OpenSSL Project
90  *    for use in the OpenSSL Toolkit (http://www.openssl.org/)"
91  *
92  * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
93  * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
94  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
95  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE OpenSSL PROJECT OR
96  * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
97  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
98  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
99  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
100  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
101  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
102  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
103  * OF THE POSSIBILITY OF SUCH DAMAGE.
104  * ====================================================================
105  *
106  * This product includes cryptographic software written by Eric Young
107  * (eay@cryptsoft.com).  This product includes software written by Tim
108  * Hudson (tjh@cryptsoft.com).
109  *
110  */
111 
112 #include <stdio.h>
113 #include "cryptlib.h"
114 #include <openssl/objects.h>
115 #include <openssl/evp.h>
116 #ifndef OPENSSL_NO_ENGINE
117 #include <openssl/engine.h>
118 #endif
119 
120 void EVP_MD_CTX_init(EVP_MD_CTX *ctx)
121 	{
122 	memset(ctx,'\0',sizeof *ctx);
123 	}
124 
125 EVP_MD_CTX *EVP_MD_CTX_create(void)
126 	{
127 	EVP_MD_CTX *ctx=OPENSSL_malloc(sizeof *ctx);
128 
129 	if (ctx)
130 		EVP_MD_CTX_init(ctx);
131 
132 	return ctx;
133 	}
134 
135 int EVP_DigestInit(EVP_MD_CTX *ctx, const EVP_MD *type)
136 	{
137 	EVP_MD_CTX_init(ctx);
138 	return EVP_DigestInit_ex(ctx, type, NULL);
139 	}
140 
141 int EVP_DigestInit_ex(EVP_MD_CTX *ctx, const EVP_MD *type, ENGINE *impl)
142 	{
143 	EVP_MD_CTX_clear_flags(ctx,EVP_MD_CTX_FLAG_CLEANED);
144 #ifndef OPENSSL_NO_ENGINE
145 	/* Whether it's nice or not, "Inits" can be used on "Final"'d contexts
146 	 * so this context may already have an ENGINE! Try to avoid releasing
147 	 * the previous handle, re-querying for an ENGINE, and having a
148 	 * reinitialisation, when it may all be unecessary. */
149 	if (ctx->engine && ctx->digest && (!type ||
150 			(type && (type->type == ctx->digest->type))))
151 		goto skip_to_init;
152 	if (type)
153 		{
154 		/* Ensure an ENGINE left lying around from last time is cleared
155 		 * (the previous check attempted to avoid this if the same
156 		 * ENGINE and EVP_MD could be used). */
157 		if(ctx->engine)
158 			ENGINE_finish(ctx->engine);
159 		if(impl)
160 			{
161 			if (!ENGINE_init(impl))
162 				{
163 				EVPerr(EVP_F_EVP_DIGESTINIT_EX,EVP_R_INITIALIZATION_ERROR);
164 				return 0;
165 				}
166 			}
167 		else
168 			/* Ask if an ENGINE is reserved for this job */
169 			impl = ENGINE_get_digest_engine(type->type);
170 		if(impl)
171 			{
172 			/* There's an ENGINE for this job ... (apparently) */
173 			const EVP_MD *d = ENGINE_get_digest(impl, type->type);
174 			if(!d)
175 				{
176 				/* Same comment from evp_enc.c */
177 				EVPerr(EVP_F_EVP_DIGESTINIT_EX,EVP_R_INITIALIZATION_ERROR);
178 				return 0;
179 				}
180 			/* We'll use the ENGINE's private digest definition */
181 			type = d;
182 			/* Store the ENGINE functional reference so we know
183 			 * 'type' came from an ENGINE and we need to release
184 			 * it when done. */
185 			ctx->engine = impl;
186 			}
187 		else
188 			ctx->engine = NULL;
189 		}
190 	else
191 	if(!ctx->digest)
192 		{
193 		EVPerr(EVP_F_EVP_DIGESTINIT_EX,EVP_R_NO_DIGEST_SET);
194 		return 0;
195 		}
196 #endif
197 	if (ctx->digest != type)
198 		{
199 		if (ctx->digest && ctx->digest->ctx_size)
200 			OPENSSL_free(ctx->md_data);
201 		ctx->digest=type;
202 		if (!(ctx->flags & EVP_MD_CTX_FLAG_NO_INIT) && type->ctx_size)
203 			{
204 			ctx->update = type->update;
205 			ctx->md_data=OPENSSL_malloc(type->ctx_size);
206 			if (ctx->md_data == NULL)
207 				{
208 				EVPerr(EVP_F_EVP_DIGESTINIT_EX,
209 							ERR_R_MALLOC_FAILURE);
210 				return 0;
211 				}
212 			}
213 		}
214 #ifndef OPENSSL_NO_ENGINE
215 skip_to_init:
216 #endif
217 	if (ctx->pctx)
218 		{
219 		int r;
220 		r = EVP_PKEY_CTX_ctrl(ctx->pctx, -1, EVP_PKEY_OP_TYPE_SIG,
221 					EVP_PKEY_CTRL_DIGESTINIT, 0, ctx);
222 		if (r <= 0 && (r != -2))
223 			return 0;
224 		}
225 	if (ctx->flags & EVP_MD_CTX_FLAG_NO_INIT)
226 		return 1;
227 	return ctx->digest->init(ctx);
228 	}
229 
230 int EVP_DigestUpdate(EVP_MD_CTX *ctx, const void *data, size_t count)
231 	{
232 	return ctx->update(ctx,data,count);
233 	}
234 
235 /* The caller can assume that this removes any secret data from the context */
236 int EVP_DigestFinal(EVP_MD_CTX *ctx, unsigned char *md, unsigned int *size)
237 	{
238 	int ret;
239 	ret = EVP_DigestFinal_ex(ctx, md, size);
240 	EVP_MD_CTX_cleanup(ctx);
241 	return ret;
242 	}
243 
244 /* The caller can assume that this removes any secret data from the context */
245 int EVP_DigestFinal_ex(EVP_MD_CTX *ctx, unsigned char *md, unsigned int *size)
246 	{
247 	int ret;
248 
249 	OPENSSL_assert(ctx->digest->md_size <= EVP_MAX_MD_SIZE);
250 	ret=ctx->digest->final(ctx,md);
251 	if (size != NULL)
252 		*size=ctx->digest->md_size;
253 	if (ctx->digest->cleanup)
254 		{
255 		ctx->digest->cleanup(ctx);
256 		EVP_MD_CTX_set_flags(ctx,EVP_MD_CTX_FLAG_CLEANED);
257 		}
258 	memset(ctx->md_data,0,ctx->digest->ctx_size);
259 	return ret;
260 	}
261 
262 int EVP_MD_CTX_copy(EVP_MD_CTX *out, const EVP_MD_CTX *in)
263 	{
264 	EVP_MD_CTX_init(out);
265 	return EVP_MD_CTX_copy_ex(out, in);
266 	}
267 
268 int EVP_MD_CTX_copy_ex(EVP_MD_CTX *out, const EVP_MD_CTX *in)
269 	{
270 	unsigned char *tmp_buf;
271 	if ((in == NULL) || (in->digest == NULL))
272 		{
273 		EVPerr(EVP_F_EVP_MD_CTX_COPY_EX,EVP_R_INPUT_NOT_INITIALIZED);
274 		return 0;
275 		}
276 #ifndef OPENSSL_NO_ENGINE
277 	/* Make sure it's safe to copy a digest context using an ENGINE */
278 	if (in->engine && !ENGINE_init(in->engine))
279 		{
280 		EVPerr(EVP_F_EVP_MD_CTX_COPY_EX,ERR_R_ENGINE_LIB);
281 		return 0;
282 		}
283 #endif
284 
285 	if (out->digest == in->digest)
286 		{
287 		tmp_buf = out->md_data;
288 	    	EVP_MD_CTX_set_flags(out,EVP_MD_CTX_FLAG_REUSE);
289 		}
290 	else tmp_buf = NULL;
291 	EVP_MD_CTX_cleanup(out);
292 	memcpy(out,in,sizeof *out);
293 
294 	if (in->md_data && out->digest->ctx_size)
295 		{
296 		if (tmp_buf)
297 			out->md_data = tmp_buf;
298 		else
299 			{
300 			out->md_data=OPENSSL_malloc(out->digest->ctx_size);
301 			if (!out->md_data)
302 				{
303 				EVPerr(EVP_F_EVP_MD_CTX_COPY_EX,ERR_R_MALLOC_FAILURE);
304 				return 0;
305 				}
306 			}
307 		memcpy(out->md_data,in->md_data,out->digest->ctx_size);
308 		}
309 
310 	out->update = in->update;
311 
312 	if (in->pctx)
313 		{
314 		out->pctx = EVP_PKEY_CTX_dup(in->pctx);
315 		if (!out->pctx)
316 			{
317 			EVP_MD_CTX_cleanup(out);
318 			return 0;
319 			}
320 		}
321 
322 	if (out->digest->copy)
323 		return out->digest->copy(out,in);
324 
325 	return 1;
326 	}
327 
328 int EVP_Digest(const void *data, size_t count,
329 		unsigned char *md, unsigned int *size, const EVP_MD *type, ENGINE *impl)
330 	{
331 	EVP_MD_CTX ctx;
332 	int ret;
333 
334 	EVP_MD_CTX_init(&ctx);
335 	EVP_MD_CTX_set_flags(&ctx,EVP_MD_CTX_FLAG_ONESHOT);
336 	ret=EVP_DigestInit_ex(&ctx, type, impl)
337 	  && EVP_DigestUpdate(&ctx, data, count)
338 	  && EVP_DigestFinal_ex(&ctx, md, size);
339 	EVP_MD_CTX_cleanup(&ctx);
340 
341 	return ret;
342 	}
343 
344 void EVP_MD_CTX_destroy(EVP_MD_CTX *ctx)
345 	{
346 	EVP_MD_CTX_cleanup(ctx);
347 	OPENSSL_free(ctx);
348 	}
349 
350 /* This call frees resources associated with the context */
351 int EVP_MD_CTX_cleanup(EVP_MD_CTX *ctx)
352 	{
353 	/* Don't assume ctx->md_data was cleaned in EVP_Digest_Final,
354 	 * because sometimes only copies of the context are ever finalised.
355 	 */
356 	if (ctx->digest && ctx->digest->cleanup
357 	    && !EVP_MD_CTX_test_flags(ctx,EVP_MD_CTX_FLAG_CLEANED))
358 		ctx->digest->cleanup(ctx);
359 	if (ctx->digest && ctx->digest->ctx_size && ctx->md_data
360 	    && !EVP_MD_CTX_test_flags(ctx, EVP_MD_CTX_FLAG_REUSE))
361 		{
362 		OPENSSL_cleanse(ctx->md_data,ctx->digest->ctx_size);
363 		OPENSSL_free(ctx->md_data);
364 		}
365 	if (ctx->pctx)
366 		EVP_PKEY_CTX_free(ctx->pctx);
367 #ifndef OPENSSL_NO_ENGINE
368 	if(ctx->engine)
369 		/* The EVP_MD we used belongs to an ENGINE, release the
370 		 * functional reference we held for this reason. */
371 		ENGINE_finish(ctx->engine);
372 #endif
373 	memset(ctx,'\0',sizeof *ctx);
374 
375 	return 1;
376 	}
377