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 EXPORT_C void EVP_MD_CTX_init(EVP_MD_CTX *ctx)

   121 	{

   122 	memset(ctx,'\0',sizeof *ctx);

   123 	}

   124 

   125 EXPORT_C EVP_MD_CTX *EVP_MD_CTX_create(void)

   126 	{

   127 	EVP_MD_CTX *ctx=OPENSSL_malloc(sizeof *ctx);

   128     if(ctx==NULL)

   129 	{

   130 	   return ctx;

   131 	}

   132 	EVP_MD_CTX_init(ctx);

   133 

   134 	return ctx;

   135 	}

   136 

   137 EXPORT_C int EVP_DigestInit(EVP_MD_CTX *ctx, const EVP_MD *type)

   138 	{

   139 	EVP_MD_CTX_init(ctx);

   140 	return EVP_DigestInit_ex(ctx, type, NULL);

   141 	}

   142 

   143 EXPORT_C int EVP_DigestInit_ex(EVP_MD_CTX *ctx, const EVP_MD *type, ENGINE *impl)

   144 	{

   145 	EVP_MD_CTX_clear_flags(ctx,EVP_MD_CTX_FLAG_CLEANED);

   146 #ifndef OPENSSL_NO_ENGINE

   147 	/* Whether it's nice or not, "Inits" can be used on "Final"'d contexts

   148 	 * so this context may already have an ENGINE! Try to avoid releasing

   149 	 * the previous handle, re-querying for an ENGINE, and having a

   150 	 * reinitialisation, when it may all be unecessary. */

   151 	if (ctx->engine && ctx->digest && (!type ||

   152 			(type && (type->type == ctx->digest->type))))

   153 		goto skip_to_init;

   154 	if (type)

   155 		{

   156 		/* Ensure an ENGINE left lying around from last time is cleared

   157 		 * (the previous check attempted to avoid this if the same

   158 		 * ENGINE and EVP_MD could be used). */

   159 		if(ctx->engine)

   160 			ENGINE_finish(ctx->engine);

   161 		if(impl)

   162 			{

   163 			if (!ENGINE_init(impl))

   164 				{

   165 				EVPerr(EVP_F_EVP_DIGESTINIT_EX,EVP_R_INITIALIZATION_ERROR);

   166 				return 0;

   167 				}

   168 			}

   169 		else

   170 			/* Ask if an ENGINE is reserved for this job */

   171 			impl = ENGINE_get_digest_engine(type->type);

   172 		if(impl)

   173 			{

   174 			/* There's an ENGINE for this job ... (apparently) */

   175 			const EVP_MD *d = ENGINE_get_digest(impl, type->type);

   176 			if(!d)

   177 				{

   178 				/* Same comment from evp_enc.c */

   179 				EVPerr(EVP_F_EVP_DIGESTINIT_EX,EVP_R_INITIALIZATION_ERROR);

   180 				return 0;

   181 				}

   182 			/* We'll use the ENGINE's private digest definition */

   183 			type = d;

   184 			/* Store the ENGINE functional reference so we know

   185 			 * 'type' came from an ENGINE and we need to release

   186 			 * it when done. */

   187 			ctx->engine = impl;

   188 			}

   189 		else

   190 			ctx->engine = NULL;

   191 		}

   192 	else

   193 	if(!ctx->digest)

   194 		{

   195 		EVPerr(EVP_F_EVP_DIGESTINIT_EX,EVP_R_NO_DIGEST_SET);

   196 		return 0;

   197 		}

   198 #endif

   199 	if (ctx->digest != type)

   200 		{

   201 		if (ctx->digest && ctx->digest->ctx_size)

   202 		  { if(ctx->md_data)

   203 			  OPENSSL_free(ctx->md_data);

   204 		  }

   205 		ctx->digest=type;

   206 		if (type->ctx_size)

   207 		{

   208 			ctx->md_data=OPENSSL_malloc(type->ctx_size);

   209 			if(ctx->md_data==NULL)

   210 			{

   211 			    EVPerr(EVP_F_EVP_DIGESTINIT_EX,ERR_R_MALLOC_FAILURE);

   212 			    return 0;

   213 			}

   214 		}

   215 

   216 		}

   217 #ifndef OPENSSL_NO_ENGINE

   218 skip_to_init:

   219 #endif

   220 	return ctx->digest->init(ctx);

   221 	}

   222 

   223 EXPORT_C int EVP_DigestUpdate(EVP_MD_CTX *ctx, const void *data,

   224 	     size_t count)

   225 	{

   226 	return ctx->digest->update(ctx,data,count);

   227 	}

   228 

   229 /* The caller can assume that this removes any secret data from the context */

   230 EXPORT_C int EVP_DigestFinal(EVP_MD_CTX *ctx, unsigned char *md, unsigned int *size)

   231 	{

   232 	int ret;

   233 	ret = EVP_DigestFinal_ex(ctx, md, size);

   234 	EVP_MD_CTX_cleanup(ctx);

   235 	return ret;

   236 	}

   237 

   238 /* The caller can assume that this removes any secret data from the context */

   239 EXPORT_C int EVP_DigestFinal_ex(EVP_MD_CTX *ctx, unsigned char *md, unsigned int *size)

   240 	{

   241 	int ret;

   242 

   243 	OPENSSL_assert(ctx->digest->md_size <= EVP_MAX_MD_SIZE);

   244 	ret=ctx->digest->final(ctx,md);

   245 	if (size != NULL)

   246 		*size=ctx->digest->md_size;

   247 	if (ctx->digest->cleanup)

   248 		{

   249 		ctx->digest->cleanup(ctx);

   250 		EVP_MD_CTX_set_flags(ctx,EVP_MD_CTX_FLAG_CLEANED);

   251 		}

   252 	if(ctx->md_data)	

   253 	memset(ctx->md_data,0,ctx->digest->ctx_size);

   254 	return ret;

   255 	}

   256 

   257 EXPORT_C int EVP_MD_CTX_copy(EVP_MD_CTX *out, const EVP_MD_CTX *in)

   258 	{

   259 	EVP_MD_CTX_init(out);

   260 	return EVP_MD_CTX_copy_ex(out, in);

   261 	}

   262 

   263 EXPORT_C int EVP_MD_CTX_copy_ex(EVP_MD_CTX *out, const EVP_MD_CTX *in)

   264 	{

   265 	unsigned char *tmp_buf;

   266 	if ((in == NULL) || (in->digest == NULL))

   267 		{

   268 		EVPerr(EVP_F_EVP_MD_CTX_COPY_EX,EVP_R_INPUT_NOT_INITIALIZED);

   269 		return 0;

   270 		}

   271 #ifndef OPENSSL_NO_ENGINE

   272 	/* Make sure it's safe to copy a digest context using an ENGINE */

   273 	if (in->engine && !ENGINE_init(in->engine))

   274 		{

   275 		EVPerr(EVP_F_EVP_MD_CTX_COPY_EX,ERR_R_ENGINE_LIB);

   276 		return 0;

   277 		}

   278 #endif

   279 

   280 	if (out->digest == in->digest)

   281 		{

   282 		tmp_buf = out->md_data;

   283 	    	EVP_MD_CTX_set_flags(out,EVP_MD_CTX_FLAG_REUSE);

   284 		}

   285 	else tmp_buf = NULL;

   286 	EVP_MD_CTX_cleanup(out);

   287 	memcpy(out,in,sizeof *out);

   288 

   289 	if (out->digest->ctx_size)

   290 		{

   291 		 if (tmp_buf) out->md_data = tmp_buf;

   292 		 else out->md_data=OPENSSL_malloc(out->digest->ctx_size);

   293      if(out->md_data==NULL||in->md_data==NULL)

   294         {

   295            EVPerr(EVP_F_EVP_MD_CTX_COPY_EX,ERR_R_MALLOC_FAILURE);

   296 		       return 0;

   297         } 

   298      memcpy(out->md_data,in->md_data,out->digest->ctx_size);

   299 		}

   300 

   301 	if (out->digest->copy)

   302 		return out->digest->copy(out,in);

   303 	

   304 	return 1;

   305 	}

   306 

   307 EXPORT_C int EVP_Digest(const void *data, size_t count,

   308 		unsigned char *md, unsigned int *size, const EVP_MD *type, ENGINE *impl)

   309 	{

   310 	EVP_MD_CTX ctx;

   311 	int ret;

   312 

   313 	EVP_MD_CTX_init(&ctx);

   314 	EVP_MD_CTX_set_flags(&ctx,EVP_MD_CTX_FLAG_ONESHOT);

   315 	ret=EVP_DigestInit_ex(&ctx, type, impl)

   316 	  && EVP_DigestUpdate(&ctx, data, count)

   317 	  && EVP_DigestFinal_ex(&ctx, md, size);

   318 	EVP_MD_CTX_cleanup(&ctx);

   319 

   320 	return ret;

   321 	}

   322 

   323 EXPORT_C void EVP_MD_CTX_destroy(EVP_MD_CTX *ctx)

   324 	{

   325 	EVP_MD_CTX_cleanup(ctx);

   326 	OPENSSL_free(ctx);

   327 	}

   328 

   329 /* This call frees resources associated with the context */

   330 EXPORT_C int EVP_MD_CTX_cleanup(EVP_MD_CTX *ctx)

   331 	{

   332 	/* Don't assume ctx->md_data was cleaned in EVP_Digest_Final,

   333 	 * because sometimes only copies of the context are ever finalised.

   334 	 */

   335 	if (ctx->digest && ctx->digest->cleanup

   336 	    && !EVP_MD_CTX_test_flags(ctx,EVP_MD_CTX_FLAG_CLEANED))

   337 		ctx->digest->cleanup(ctx);

   338 	if (ctx->digest && ctx->digest->ctx_size && ctx->md_data

   339 	    && !EVP_MD_CTX_test_flags(ctx, EVP_MD_CTX_FLAG_REUSE))

   340 		{

   341 		OPENSSL_cleanse(ctx->md_data,ctx->digest->ctx_size);

   342 		OPENSSL_free(ctx->md_data);

   343 		}

   344 #ifndef OPENSSL_NO_ENGINE

   345 	if(ctx->engine)

   346 		/* The EVP_MD we used belongs to an ENGINE, release the

   347 		 * functional reference we held for this reason. */

   348 		ENGINE_finish(ctx->engine);

   349 #endif

   350 	memset(ctx,'\0',sizeof *ctx);

   351 

   352 	return 1;

   353 	}