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 "cryptlib.h"

    61 #include <openssl/evp.h>

    62 #include <openssl/objects.h>

    63 

    64 EXPORT_C 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

    71 		ret=-1;

    72 	return(ret);

    73 	}

    74 

    75 EXPORT_C int EVP_CIPHER_asn1_to_param(EVP_CIPHER_CTX *c, ASN1_TYPE *type)

    76 	{

    77 	int ret;

    78 

    79 	if (c->cipher->get_asn1_parameters != NULL)

    80 		ret=c->cipher->get_asn1_parameters(c,type);

    81 	else

    82 		ret=-1;

    83 	return(ret);

    84 	}

    85 

    86 EXPORT_C int EVP_CIPHER_get_asn1_iv(EVP_CIPHER_CTX *c, ASN1_TYPE *type)

    87 	{

    88 	int i=0;

    89 	unsigned int l;

    90 

    91 	if (type != NULL) 

    92 		{

    93 		l=EVP_CIPHER_CTX_iv_length(c);

    94 		OPENSSL_assert(l <= sizeof(c->iv));

    95 		i=ASN1_TYPE_get_octetstring(type,c->oiv,l);

    96 		if (i != (int)l)

    97 			return(-1);

    98 		else if (i > 0)

    99 			memcpy(c->iv,c->oiv,l);

   100 		}

   101 	return(i);

   102 	}

   103 

   104 EXPORT_C int EVP_CIPHER_set_asn1_iv(EVP_CIPHER_CTX *c, ASN1_TYPE *type)

   105 	{

   106 	int i=0;

   107 	unsigned int j;

   108 

   109 	if (type != NULL)

   110 		{

   111 		j=EVP_CIPHER_CTX_iv_length(c);

   112 		OPENSSL_assert(j <= sizeof(c->iv));

   113 		i=ASN1_TYPE_set_octetstring(type,c->oiv,j);

   114 		}

   115 	return(i);

   116 	}

   117 

   118 /* Convert the various cipher NIDs and dummies to a proper OID NID */

   119 EXPORT_C int EVP_CIPHER_type(const EVP_CIPHER *ctx)

   120 {

   121 	int nid;

   122 	ASN1_OBJECT *otmp;

   123 	nid = EVP_CIPHER_nid(ctx);

   124 

   125 	switch(nid) {

   126 

   127 		case NID_rc2_cbc:

   128 		case NID_rc2_64_cbc:

   129 		case NID_rc2_40_cbc:

   130 

   131 		return NID_rc2_cbc;

   132 

   133 		case NID_rc4:

   134 		case NID_rc4_40:

   135 

   136 		return NID_rc4;

   137 

   138 		case NID_aes_128_cfb128:

   139 		case NID_aes_128_cfb8:

   140 		case NID_aes_128_cfb1:

   141 

   142 		return NID_aes_128_cfb128;

   143 

   144 		case NID_aes_192_cfb128:

   145 		case NID_aes_192_cfb8:

   146 		case NID_aes_192_cfb1:

   147 

   148 		return NID_aes_192_cfb128;

   149 

   150 		case NID_aes_256_cfb128:

   151 		case NID_aes_256_cfb8:

   152 		case NID_aes_256_cfb1:

   153 

   154 		return NID_aes_256_cfb128;

   155 

   156 		case NID_des_cfb64:

   157 		case NID_des_cfb8:

   158 		case NID_des_cfb1:

   159 

   160 		return NID_des_cfb64;

   161 

   162 		default:

   163 		/* Check it has an OID and it is valid */

   164 		otmp = OBJ_nid2obj(nid);

   165 		if(!otmp || !otmp->data) nid = NID_undef;

   166 		ASN1_OBJECT_free(otmp);

   167 		return nid;

   168 	}

   169 }

   170 

   171 EXPORT_C int EVP_CIPHER_block_size(const EVP_CIPHER *e)

   172 	{

   173 	return e->block_size;

   174 	}

   175 

   176 EXPORT_C int EVP_CIPHER_CTX_block_size(const EVP_CIPHER_CTX *ctx)

   177 	{

   178 	return ctx->cipher->block_size;

   179 	}

   180 

   181 EXPORT_C int EVP_Cipher(EVP_CIPHER_CTX *ctx, unsigned char *out, const unsigned char *in, unsigned int inl)

   182 	{

   183 	return ctx->cipher->do_cipher(ctx,out,in,inl);

   184 	}

   185 

   186 EXPORT_C const EVP_CIPHER *EVP_CIPHER_CTX_cipher(const EVP_CIPHER_CTX *ctx)

   187 	{

   188 	return ctx->cipher;

   189 	}

   190 

   191 EXPORT_C unsigned long EVP_CIPHER_flags(const EVP_CIPHER *cipher)

   192 	{

   193 	return cipher->flags;

   194 	}

   195 

   196 EXPORT_C unsigned long EVP_CIPHER_CTX_flags(const EVP_CIPHER_CTX *ctx)

   197 	{

   198 	return ctx->cipher->flags;

   199 	}

   200 

   201 EXPORT_C void *EVP_CIPHER_CTX_get_app_data(const EVP_CIPHER_CTX *ctx)

   202 	{

   203 	return ctx->app_data;

   204 	}

   205 

   206 EXPORT_C void EVP_CIPHER_CTX_set_app_data(EVP_CIPHER_CTX *ctx, void *data)

   207 	{

   208 	ctx->app_data = data;

   209 	}

   210 

   211 EXPORT_C int EVP_CIPHER_iv_length(const EVP_CIPHER *cipher)

   212 	{

   213 	return cipher->iv_len;

   214 	}

   215 

   216 EXPORT_C int EVP_CIPHER_CTX_iv_length(const EVP_CIPHER_CTX *ctx)

   217 	{

   218 	return ctx->cipher->iv_len;

   219 	}

   220 

   221 EXPORT_C int EVP_CIPHER_key_length(const EVP_CIPHER *cipher)

   222 	{

   223 	return cipher->key_len;

   224 	}

   225 

   226 EXPORT_C int EVP_CIPHER_CTX_key_length(const EVP_CIPHER_CTX *ctx)

   227 	{

   228 	return ctx->key_len;

   229 	}

   230 

   231 EXPORT_C int EVP_CIPHER_nid(const EVP_CIPHER *cipher)

   232 	{

   233 	return cipher->nid;

   234 	}

   235 

   236 EXPORT_C int EVP_CIPHER_CTX_nid(const EVP_CIPHER_CTX *ctx)

   237 	{

   238 	return ctx->cipher->nid;

   239 	}

   240 

   241 EXPORT_C int EVP_MD_block_size(const EVP_MD *md) 

   242 	{

   243 	return md->block_size;

   244 	}

   245 

   246 EXPORT_C int EVP_MD_type(const EVP_MD *md)

   247 	{

   248 	return md->type;

   249 	}

   250 

   251 EXPORT_C int EVP_MD_pkey_type(const EVP_MD *md)

   252 	{

   253 	return md->pkey_type;

   254 	}

   255 

   256 EXPORT_C int EVP_MD_size(const EVP_MD *md)

   257 	{

   258 	return md->md_size;

   259 	}

   260 

   261 EXPORT_C const EVP_MD * EVP_MD_CTX_md(const EVP_MD_CTX *ctx)

   262 	{

   263 	return ctx->digest;

   264 	}

   265 

   266 EXPORT_C void EVP_MD_CTX_set_flags(EVP_MD_CTX *ctx, int flags)

   267 	{

   268 	ctx->flags |= flags;

   269 	}

   270 

   271 EXPORT_C void EVP_MD_CTX_clear_flags(EVP_MD_CTX *ctx, int flags)

   272 	{

   273 	ctx->flags &= ~flags;

   274 	}

   275 

   276 EXPORT_C int EVP_MD_CTX_test_flags(const EVP_MD_CTX *ctx, int flags)

   277 	{

   278 	return (ctx->flags & flags);

   279 	}