1 /* crypto/evp/bio_md.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  © Portions copyright (c) 2006 Nokia Corporation.  All rights reserved.

    60  */

    61 

    62 

    63 #include <stdio.h>

    64 #include <errno.h>

    65 #include "cryptlib.h"

    66 #include <openssl/buffer.h>

    67 #include <openssl/evp.h>

    68 #if (defined(SYMBIAN) && (defined(__WINSCW__) || defined(__WINS__)))

    69 #include "libcrypto_wsd_macros.h"

    70 #include "libcrypto_wsd.h"

    71 #endif

    72 

    73 /* BIO_put and BIO_get both add to the digest,

    74  * BIO_gets returns the digest */

    75 

    76 static int md_write(BIO *h, char const *buf, int num);

    77 static int md_read(BIO *h, char *buf, int size);

    78 /*static int md_puts(BIO *h, const char *str); */

    79 static int md_gets(BIO *h, char *str, int size);

    80 static long md_ctrl(BIO *h, int cmd, long arg1, void *arg2);

    81 static int md_new(BIO *h);

    82 static int md_free(BIO *data);

    83 static long md_callback_ctrl(BIO *h,int cmd,bio_info_cb *fp);

    84 

    85 #ifndef EMULATOR

    86 static BIO_METHOD methods_md=

    87 	{

    88 	BIO_TYPE_MD,"message digest",

    89 	md_write,

    90 	md_read,

    91 	NULL, /* md_puts, */

    92 	md_gets,

    93 	md_ctrl,

    94 	md_new,

    95 	md_free,

    96 	md_callback_ctrl,

    97 	};

    98 #else

    99 GET_STATIC_VAR_FROM_TLS(methods_md,bio_md,BIO_METHOD)

   100 #define methods_md (*GET_WSD_VAR_NAME(methods_md,bio_md, s)())

   101 const BIO_METHOD temp_s_methods_md=

   102 	{

   103 	BIO_TYPE_MD,"message digest",

   104 	md_write,

   105 	md_read,

   106 	NULL, /* md_puts, */

   107 	md_gets,

   108 	md_ctrl,

   109 	md_new,

   110 	md_free,

   111 	md_callback_ctrl,

   112 	};

   113 #endif

   114 EXPORT_C BIO_METHOD *BIO_f_md(void)

   115 	{

   116 	return(&methods_md);

   117 	}

   118 

   119 static int md_new(BIO *bi)

   120 	{

   121 	EVP_MD_CTX *ctx;

   122 

   123 	ctx=EVP_MD_CTX_create();

   124 	if (ctx == NULL) return(0);

   125 

   126 	bi->init=0;

   127 	bi->ptr=(char *)ctx;

   128 	bi->flags=0;

   129 	return(1);

   130 	}

   131 

   132 static int md_free(BIO *a)

   133 	{

   134 	if (a == NULL) return(0);

   135 	EVP_MD_CTX_destroy(a->ptr);

   136 	a->ptr=NULL;

   137 	a->init=0;

   138 	a->flags=0;

   139 	return(1);

   140 	}

   141 	

   142 static int md_read(BIO *b, char *out, int outl)

   143 	{

   144 	int ret=0;

   145 	EVP_MD_CTX *ctx;

   146 

   147 	if (out == NULL) return(0);

   148 	ctx=b->ptr;

   149 

   150 	if ((ctx == NULL) || (b->next_bio == NULL)) return(0);

   151 

   152 	ret=BIO_read(b->next_bio,out,outl);

   153 	if (b->init)

   154 		{

   155 		if (ret > 0)

   156 			{

   157 			EVP_DigestUpdate(ctx,(unsigned char *)out,

   158 				(unsigned int)ret);

   159 			}

   160 		}

   161 	BIO_clear_retry_flags(b);

   162 	BIO_copy_next_retry(b);

   163 	return(ret);

   164 	}

   165 

   166 static int md_write(BIO *b, const char *in, int inl)

   167 	{

   168 	int ret=0;

   169 	EVP_MD_CTX *ctx;

   170 

   171 	if ((in == NULL) || (inl <= 0)) return(0);

   172 	ctx=b->ptr;

   173 

   174 	if ((ctx != NULL) && (b->next_bio != NULL))

   175 		ret=BIO_write(b->next_bio,in,inl);

   176 	if (b->init)

   177 		{

   178 		if (ret > 0)

   179 			{

   180 			EVP_DigestUpdate(ctx,(const unsigned char *)in,

   181 				(unsigned int)ret);

   182 			}

   183 		}

   184 	BIO_clear_retry_flags(b);

   185 	BIO_copy_next_retry(b);

   186 	return(ret);

   187 	}

   188 

   189 static long md_ctrl(BIO *b, int cmd, long num, void *ptr)

   190 	{

   191 	EVP_MD_CTX *ctx,*dctx,**pctx;

   192 	const EVP_MD **ppmd;

   193 	EVP_MD *md;

   194 	long ret=1;

   195 	BIO *dbio;

   196 

   197 	ctx=b->ptr;

   198 

   199 	switch (cmd)

   200 		{

   201 	case BIO_CTRL_RESET:

   202 		if (b->init)

   203 			ret = EVP_DigestInit_ex(ctx,ctx->digest, NULL);

   204 		else

   205 			ret=0;

   206 		if (ret > 0)

   207 			ret=BIO_ctrl(b->next_bio,cmd,num,ptr);

   208 		break;

   209 	case BIO_C_GET_MD:

   210 		if (b->init)

   211 			{

   212 			ppmd=ptr;

   213 			*ppmd=ctx->digest;

   214 			}

   215 		else

   216 			ret=0;

   217 		break;

   218 	case BIO_C_GET_MD_CTX:

   219 		if (b->init)

   220 			{

   221 			pctx=ptr;

   222 			*pctx=ctx;

   223 			}

   224 		else

   225 			ret=0;

   226 		break;

   227 	case BIO_C_SET_MD_CTX:

   228 		if (b->init)

   229 			b->ptr=ptr;

   230 		else

   231 			ret=0;

   232 		break;

   233 	case BIO_C_DO_STATE_MACHINE:

   234 		BIO_clear_retry_flags(b);

   235 		ret=BIO_ctrl(b->next_bio,cmd,num,ptr);

   236 		BIO_copy_next_retry(b);

   237 		break;

   238 

   239 	case BIO_C_SET_MD:

   240 		md=ptr;

   241 		ret = EVP_DigestInit_ex(ctx,md, NULL);

   242 		if (ret > 0)

   243 			b->init=1;

   244 		break;

   245 	case BIO_CTRL_DUP:

   246 		dbio=ptr;

   247 		dctx=dbio->ptr;

   248 		EVP_MD_CTX_copy_ex(dctx,ctx);

   249 		b->init=1;

   250 		break;

   251 	default:

   252 		ret=BIO_ctrl(b->next_bio,cmd,num,ptr);

   253 		break;

   254 		}

   255 	return(ret);

   256 	}

   257 

   258 static long md_callback_ctrl(BIO *b, int cmd, bio_info_cb *fp)

   259 	{

   260 	long ret=1;

   261 

   262 	if (b->next_bio == NULL) return(0);

   263 	switch (cmd)

   264 		{

   265 	default:

   266 		ret=BIO_callback_ctrl(b->next_bio,cmd,fp);

   267 		break;

   268 		}

   269 	return(ret);

   270 	}

   271 

   272 static int md_gets(BIO *bp, char *buf, int size)

   273 	{

   274 	EVP_MD_CTX *ctx;

   275 	unsigned int ret;

   276 

   277 

   278 	ctx=bp->ptr;

   279 	if (size < ctx->digest->md_size)

   280 		return(0);

   281 	EVP_DigestFinal_ex(ctx,(unsigned char *)buf,&ret);

   282 	return((int)ret);

   283 	}

   284 

   285 /*

   286 static int md_puts(bp,str)

   287 BIO *bp;

   288 char *str;

   289 	{

   290 	return(-1);

   291 	}

   292 */

   293