[thirdparty/openssl.git] / crypto / evp / evp_locl.h

/* evp_locl.h */
/* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
 * project 2000.
 */
/* ====================================================================
 * Copyright (c) 1999 The OpenSSL Project.  All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer. 
 *
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in
 *    the documentation and/or other materials provided with the
 *    distribution.
 *
 * 3. All advertising materials mentioning features or use of this
 *    software must display the following acknowledgment:
 *    "This product includes software developed by the OpenSSL Project
 *    for use in the OpenSSL Toolkit. (http://www.OpenSSL.org/)"
 *
 * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
 *    endorse or promote products derived from this software without
 *    prior written permission. For written permission, please contact
 *    licensing@OpenSSL.org.
 *
 * 5. Products derived from this software may not be called "OpenSSL"
 *    nor may "OpenSSL" appear in their names without prior written
 *    permission of the OpenSSL Project.
 *
 * 6. Redistributions of any form whatsoever must retain the following
 *    acknowledgment:
 *    "This product includes software developed by the OpenSSL Project
 *    for use in the OpenSSL Toolkit (http://www.OpenSSL.org/)"
 *
 * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
 * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE OpenSSL PROJECT OR
 * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
 * OF THE POSSIBILITY OF SUCH DAMAGE.
 * ====================================================================
 *
 * This product includes cryptographic software written by Eric Young
 * (eay@cryptsoft.com).  This product includes software written by Tim
 * Hudson (tjh@cryptsoft.com).
 *
 */

/* Macros to code block cipher wrappers */

/* Wrapper functions for each cipher mode */

#define BLOCK_CIPHER_ecb_loop() \
	size_t i, bl; \
	bl = ctx->cipher->block_size;\
	if(inl < bl) return 1;\
	inl -= bl; \
	for(i=0; i <= inl; i+=bl) 

#define BLOCK_CIPHER_func_ecb(cname, cprefix, kstruct, ksched) \
static int cname##_ecb_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out, const unsigned char *in, size_t inl) \
{\
	BLOCK_CIPHER_ecb_loop() \
		cprefix##_ecb_encrypt(in + i, out + i, &((kstruct *)ctx->cipher_data)->ksched, ctx->encrypt);\
	return 1;\
}

#define EVP_MAXCHUNK ((size_t)1<<(sizeof(long)*8-2))

#define BLOCK_CIPHER_func_ofb(cname, cprefix, cbits, kstruct, ksched) \
static int cname##_ofb_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out, const unsigned char *in, size_t inl) \
{\
	while(inl>=EVP_MAXCHUNK)\
	    {\
	    cprefix##_ofb##cbits##_encrypt(in, out, (long)EVP_MAXCHUNK, &((kstruct *)ctx->cipher_data)->ksched, ctx->iv, &ctx->num);\
	    inl-=EVP_MAXCHUNK;\
	    in +=EVP_MAXCHUNK;\
	    out+=EVP_MAXCHUNK;\
	    }\
	if (inl)\
	    cprefix##_ofb##cbits##_encrypt(in, out, (long)inl, &((kstruct *)ctx->cipher_data)->ksched, ctx->iv, &ctx->num);\
	return 1;\
}

#define BLOCK_CIPHER_func_cbc(cname, cprefix, kstruct, ksched) \
static int cname##_cbc_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out, const unsigned char *in, size_t inl) \
{\
	while(inl>=EVP_MAXCHUNK) \
	    {\
	    cprefix##_cbc_encrypt(in, out, (long)EVP_MAXCHUNK, &((kstruct *)ctx->cipher_data)->ksched, ctx->iv, ctx->encrypt);\
	    inl-=EVP_MAXCHUNK;\
	    in +=EVP_MAXCHUNK;\
	    out+=EVP_MAXCHUNK;\
	    }\
	if (inl)\
	    cprefix##_cbc_encrypt(in, out, (long)inl, &((kstruct *)ctx->cipher_data)->ksched, ctx->iv, ctx->encrypt);\
	return 1;\
}

#define BLOCK_CIPHER_func_cfb(cname, cprefix, cbits, kstruct, ksched) \
static int cname##_cfb##cbits##_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out, const unsigned char *in, size_t inl) \
{\
	size_t chunk=EVP_MAXCHUNK;\
	if (cbits==1)  chunk>>=3;\
	if (inl<chunk) chunk=inl;\
	while(inl && inl>=chunk)\
	    {\
            cprefix##_cfb##cbits##_encrypt(in, out, (long)((cbits==1) && !(ctx->flags & EVP_CIPH_FLAG_LENGTH_BITS) ?inl*8:inl), &((kstruct *)ctx->cipher_data)->ksched, ctx->iv, &ctx->num, ctx->encrypt);\
	    inl-=chunk;\
	    in +=chunk;\
	    out+=chunk;\
	    if(inl<chunk) chunk=inl;\
	    }\
	return 1;\
}

#define BLOCK_CIPHER_all_funcs(cname, cprefix, cbits, kstruct, ksched) \
	BLOCK_CIPHER_func_cbc(cname, cprefix, kstruct, ksched) \
	BLOCK_CIPHER_func_cfb(cname, cprefix, cbits, kstruct, ksched) \
	BLOCK_CIPHER_func_ecb(cname, cprefix, kstruct, ksched) \
	BLOCK_CIPHER_func_ofb(cname, cprefix, cbits, kstruct, ksched)

#define BLOCK_CIPHER_def1(cname, nmode, mode, MODE, kstruct, nid, block_size, \
			  key_len, iv_len, flags, init_key, cleanup, \
			  set_asn1, get_asn1, ctrl) \
static const EVP_CIPHER cname##_##mode = { \
	nid##_##nmode, block_size, key_len, iv_len, \
	flags | EVP_CIPH_##MODE##_MODE, \
	init_key, \
	cname##_##mode##_cipher, \
	cleanup, \
	sizeof(kstruct), \
	set_asn1, get_asn1,\
	ctrl, \
	NULL \
}; \
const EVP_CIPHER *EVP_##cname##_##mode(void) { return &cname##_##mode; }

#define BLOCK_CIPHER_def_cbc(cname, kstruct, nid, block_size, key_len, \
			     iv_len, flags, init_key, cleanup, set_asn1, \
			     get_asn1, ctrl) \
BLOCK_CIPHER_def1(cname, cbc, cbc, CBC, kstruct, nid, block_size, key_len, \
		  iv_len, flags, init_key, cleanup, set_asn1, get_asn1, ctrl)

#define BLOCK_CIPHER_def_cfb(cname, kstruct, nid, key_len, \
			     iv_len, cbits, flags, init_key, cleanup, \
			     set_asn1, get_asn1, ctrl) \
BLOCK_CIPHER_def1(cname, cfb##cbits, cfb##cbits, CFB, kstruct, nid, 1, \
		  key_len, iv_len, flags, init_key, cleanup, set_asn1, \
		  get_asn1, ctrl)

#define BLOCK_CIPHER_def_ofb(cname, kstruct, nid, key_len, \
			     iv_len, cbits, flags, init_key, cleanup, \
			     set_asn1, get_asn1, ctrl) \
BLOCK_CIPHER_def1(cname, ofb##cbits, ofb, OFB, kstruct, nid, 1, \
		  key_len, iv_len, flags, init_key, cleanup, set_asn1, \
		  get_asn1, ctrl)

#define BLOCK_CIPHER_def_ecb(cname, kstruct, nid, block_size, key_len, \
			     flags, init_key, cleanup, set_asn1, \
			     get_asn1, ctrl) \
BLOCK_CIPHER_def1(cname, ecb, ecb, ECB, kstruct, nid, block_size, key_len, \
		  0, flags, init_key, cleanup, set_asn1, get_asn1, ctrl)

#define BLOCK_CIPHER_defs(cname, kstruct, \
			  nid, block_size, key_len, iv_len, cbits, flags, \
			  init_key, cleanup, set_asn1, get_asn1, ctrl) \
BLOCK_CIPHER_def_cbc(cname, kstruct, nid, block_size, key_len, iv_len, flags, \
		     init_key, cleanup, set_asn1, get_asn1, ctrl) \
BLOCK_CIPHER_def_cfb(cname, kstruct, nid, key_len, iv_len, cbits, \
		     flags, init_key, cleanup, set_asn1, get_asn1, ctrl) \
BLOCK_CIPHER_def_ofb(cname, kstruct, nid, key_len, iv_len, cbits, \
		     flags, init_key, cleanup, set_asn1, get_asn1, ctrl) \
BLOCK_CIPHER_def_ecb(cname, kstruct, nid, block_size, key_len, flags, \
		     init_key, cleanup, set_asn1, get_asn1, ctrl)


/*-
#define BLOCK_CIPHER_defs(cname, kstruct, \
				nid, block_size, key_len, iv_len, flags,\
				 init_key, cleanup, set_asn1, get_asn1, ctrl)\
static const EVP_CIPHER cname##_cbc = {\
	nid##_cbc, block_size, key_len, iv_len, \
	flags | EVP_CIPH_CBC_MODE,\
	init_key,\
	cname##_cbc_cipher,\
	cleanup,\
	sizeof(EVP_CIPHER_CTX)-sizeof((((EVP_CIPHER_CTX *)NULL)->c))+\
		sizeof((((EVP_CIPHER_CTX *)NULL)->c.kstruct)),\
	set_asn1, get_asn1,\
	ctrl, \
	NULL \
};\
const EVP_CIPHER *EVP_##cname##_cbc(void) { return &cname##_cbc; }\
static const EVP_CIPHER cname##_cfb = {\
	nid##_cfb64, 1, key_len, iv_len, \
	flags | EVP_CIPH_CFB_MODE,\
	init_key,\
	cname##_cfb_cipher,\
	cleanup,\
	sizeof(EVP_CIPHER_CTX)-sizeof((((EVP_CIPHER_CTX *)NULL)->c))+\
		sizeof((((EVP_CIPHER_CTX *)NULL)->c.kstruct)),\
	set_asn1, get_asn1,\
	ctrl,\
	NULL \
};\
const EVP_CIPHER *EVP_##cname##_cfb(void) { return &cname##_cfb; }\
static const EVP_CIPHER cname##_ofb = {\
	nid##_ofb64, 1, key_len, iv_len, \
	flags | EVP_CIPH_OFB_MODE,\
	init_key,\
	cname##_ofb_cipher,\
	cleanup,\
	sizeof(EVP_CIPHER_CTX)-sizeof((((EVP_CIPHER_CTX *)NULL)->c))+\
		sizeof((((EVP_CIPHER_CTX *)NULL)->c.kstruct)),\
	set_asn1, get_asn1,\
	ctrl,\
	NULL \
};\
const EVP_CIPHER *EVP_##cname##_ofb(void) { return &cname##_ofb; }\
static const EVP_CIPHER cname##_ecb = {\
	nid##_ecb, block_size, key_len, iv_len, \
	flags | EVP_CIPH_ECB_MODE,\
	init_key,\
	cname##_ecb_cipher,\
	cleanup,\
	sizeof(EVP_CIPHER_CTX)-sizeof((((EVP_CIPHER_CTX *)NULL)->c))+\
		sizeof((((EVP_CIPHER_CTX *)NULL)->c.kstruct)),\
	set_asn1, get_asn1,\
	ctrl,\
	NULL \
};\
const EVP_CIPHER *EVP_##cname##_ecb(void) { return &cname##_ecb; }
*/

#define IMPLEMENT_BLOCK_CIPHER(cname, ksched, cprefix, kstruct, nid, \
			       block_size, key_len, iv_len, cbits, \
			       flags, init_key, \
			       cleanup, set_asn1, get_asn1, ctrl) \
	BLOCK_CIPHER_all_funcs(cname, cprefix, cbits, kstruct, ksched) \
	BLOCK_CIPHER_defs(cname, kstruct, nid, block_size, key_len, iv_len, \
			  cbits, flags, init_key, cleanup, set_asn1, \
			  get_asn1, ctrl)

#define EVP_C_DATA(kstruct, ctx)	((kstruct *)(ctx)->cipher_data)

#define IMPLEMENT_CFBR(cipher,cprefix,kstruct,ksched,keysize,cbits,iv_len,fl) \
	BLOCK_CIPHER_func_cfb(cipher##_##keysize,cprefix,cbits,kstruct,ksched) \
	BLOCK_CIPHER_def_cfb(cipher##_##keysize,kstruct, \
			     NID_##cipher##_##keysize, keysize/8, iv_len, cbits, \
			     (fl)|EVP_CIPH_FLAG_DEFAULT_ASN1, \
			     cipher##_init_key, NULL, NULL, NULL, NULL)

struct evp_pkey_ctx_st
	{
	/* Method associated with this operation */
	const EVP_PKEY_METHOD *pmeth;
	/* Engine that implements this method or NULL if builtin */
	ENGINE *engine;
	/* Key: may be NULL */
	EVP_PKEY *pkey;
	/* Peer key for key agreement, may be NULL */
	EVP_PKEY *peerkey;
	/* Actual operation */
	int operation;
	/* Algorithm specific data */
	void *data;
	/* Application specific data */
	void *app_data;
	/* Keygen callback */
	EVP_PKEY_gen_cb *pkey_gencb;
	/* implementation specific keygen data */
	int *keygen_info;
	int keygen_info_count;
	} /* EVP_PKEY_CTX */;

#define EVP_PKEY_FLAG_DYNAMIC	1

struct evp_pkey_method_st
	{
	int pkey_id;
	int flags;

	int (*init)(EVP_PKEY_CTX *ctx);
	int (*copy)(EVP_PKEY_CTX *dst, EVP_PKEY_CTX *src);
	void (*cleanup)(EVP_PKEY_CTX *ctx);

	int (*paramgen_init)(EVP_PKEY_CTX *ctx);
	int (*paramgen)(EVP_PKEY_CTX *ctx, EVP_PKEY *pkey);

	int (*keygen_init)(EVP_PKEY_CTX *ctx);
	int (*keygen)(EVP_PKEY_CTX *ctx, EVP_PKEY *pkey);

	int (*sign_init)(EVP_PKEY_CTX *ctx);
	int (*sign)(EVP_PKEY_CTX *ctx, unsigned char *sig, size_t *siglen,
				const unsigned char *tbs, size_t tbslen);

	int (*verify_init)(EVP_PKEY_CTX *ctx);
	int (*verify)(EVP_PKEY_CTX *ctx,
				const unsigned char *sig, size_t siglen,
				const unsigned char *tbs, size_t tbslen);

	int (*verify_recover_init)(EVP_PKEY_CTX *ctx);
	int (*verify_recover)(EVP_PKEY_CTX *ctx,
				unsigned char *rout, size_t *routlen,
				const unsigned char *sig, size_t siglen);

	int (*signctx_init)(EVP_PKEY_CTX *ctx, EVP_MD_CTX *mctx);
	int (*signctx)(EVP_PKEY_CTX *ctx, unsigned char *sig, size_t *siglen,
					EVP_MD_CTX *mctx);

	int (*verifyctx_init)(EVP_PKEY_CTX *ctx, EVP_MD_CTX *mctx);
	int (*verifyctx)(EVP_PKEY_CTX *ctx, const unsigned char *sig,int siglen,
					EVP_MD_CTX *mctx);

	int (*encrypt_init)(EVP_PKEY_CTX *ctx);
	int (*encrypt)(EVP_PKEY_CTX *ctx, unsigned char *out, size_t *outlen,
					const unsigned char *in, size_t inlen);

	int (*decrypt_init)(EVP_PKEY_CTX *ctx);
	int (*decrypt)(EVP_PKEY_CTX *ctx, unsigned char *out, size_t *outlen,
					const unsigned char *in, size_t inlen);

	int (*derive_init)(EVP_PKEY_CTX *ctx);
	int (*derive)(EVP_PKEY_CTX *ctx, unsigned char *key, size_t *keylen);

	int (*ctrl)(EVP_PKEY_CTX *ctx, int type, int p1, void *p2);
	int (*ctrl_str)(EVP_PKEY_CTX *ctx, const char *type, const char *value);


	} /* EVP_PKEY_METHOD */;

void evp_pkey_set_cb_translate(BN_GENCB *cb, EVP_PKEY_CTX *ctx);

int PKCS5_v2_PBKDF2_keyivgen(EVP_CIPHER_CTX *ctx, const char *pass, int passlen,
                         ASN1_TYPE *param,
			 const EVP_CIPHER *c, const EVP_MD *md, int en_de);
Commit	Line	Data
5da2f69f	1	/* evp_locl.h */
2e597528	2	/* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
5da2f69f DSH	3	* project 2000.
	4	*/
	5	/* ====================================================================
	6	* Copyright (c) 1999 The OpenSSL Project. All rights reserved.
	7	*
	8	* Redistribution and use in source and binary forms, with or without
	9	* modification, are permitted provided that the following conditions
	10	* are met:
	11	*
	12	* 1. Redistributions of source code must retain the above copyright
	13	* notice, this list of conditions and the following disclaimer.
	14	*
	15	* 2. Redistributions in binary form must reproduce the above copyright
	16	* notice, this list of conditions and the following disclaimer in
	17	* the documentation and/or other materials provided with the
	18	* distribution.
	19	*
	20	* 3. All advertising materials mentioning features or use of this
	21	* software must display the following acknowledgment:
	22	* "This product includes software developed by the OpenSSL Project
	23	* for use in the OpenSSL Toolkit. (http://www.OpenSSL.org/)"
	24	*
	25	* 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
	26	* endorse or promote products derived from this software without
	27	* prior written permission. For written permission, please contact
	28	* licensing@OpenSSL.org.
	29	*
	30	* 5. Products derived from this software may not be called "OpenSSL"
	31	* nor may "OpenSSL" appear in their names without prior written
	32	* permission of the OpenSSL Project.
	33	*
	34	* 6. Redistributions of any form whatsoever must retain the following
	35	* acknowledgment:
	36	* "This product includes software developed by the OpenSSL Project
	37	* for use in the OpenSSL Toolkit (http://www.OpenSSL.org/)"
	38	*
	39	* THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
	40	* EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
	41	* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
	42	* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE OpenSSL PROJECT OR
	43	* ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
	44	* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
	45	* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
	46	* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
	47	* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
	48	* STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
	49	* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
	50	* OF THE POSSIBILITY OF SUCH DAMAGE.
	51	* ====================================================================
	52	*
	53	* This product includes cryptographic software written by Eric Young
	54	* (eay@cryptsoft.com). This product includes software written by Tim
	55	* Hudson (tjh@cryptsoft.com).
	56	*
	57	*/
	58
	59	/* Macros to code block cipher wrappers */
	60
	61	/* Wrapper functions for each cipher mode */
	62
	63	#define BLOCK_CIPHER_ecb_loop() \
b444ac3e	64	size_t i, bl; \
c938563a RL	65	bl = ctx->cipher->block_size;\
	66	if(inl < bl) return 1;\
	67	inl -= bl; \
34f0a193	68	for(i=0; i <= inl; i+=bl)
5da2f69f	69
dbad1690	70	#define BLOCK_CIPHER_func_ecb(cname, cprefix, kstruct, ksched) \
b444ac3e	71	static int cname##_ecb_cipher(EVP_CIPHER_CTX ctx, unsigned char out, const unsigned char *in, size_t inl) \
5da2f69f DSH	72	{\
5da2f69f DSH	73	BLOCK_CIPHER_ecb_loop() \
dbad1690	74	cprefix##_ecb_encrypt(in + i, out + i, &((kstruct *)ctx->cipher_data)->ksched, ctx->encrypt);\
5da2f69f DSH	75	return 1;\
	76	}
	77
b444ac3e AP	78	#define EVP_MAXCHUNK ((size_t)1<<(sizeof(long)*8-2))
b444ac3e AP	79
a6cd8707	80	#define BLOCK_CIPHER_func_ofb(cname, cprefix, cbits, kstruct, ksched) \
b444ac3e	81	static int cname##_ofb_cipher(EVP_CIPHER_CTX ctx, unsigned char out, const unsigned char *in, size_t inl) \
5da2f69f	82	{\
b444ac3e AP	83	while(inl>=EVP_MAXCHUNK)\
	84	{\
	85	cprefix##_ofb##cbits##_encrypt(in, out, (long)EVP_MAXCHUNK, &((kstruct *)ctx->cipher_data)->ksched, ctx->iv, &ctx->num);\
	86	inl-=EVP_MAXCHUNK;\
	87	in +=EVP_MAXCHUNK;\
	88	out+=EVP_MAXCHUNK;\
	89	}\
	90	if (inl)\
	91	cprefix##_ofb##cbits##_encrypt(in, out, (long)inl, &((kstruct *)ctx->cipher_data)->ksched, ctx->iv, &ctx->num);\
5da2f69f DSH	92	return 1;\
	93	}
	94
dbad1690	95	#define BLOCK_CIPHER_func_cbc(cname, cprefix, kstruct, ksched) \
b444ac3e	96	static int cname##_cbc_cipher(EVP_CIPHER_CTX ctx, unsigned char out, const unsigned char *in, size_t inl) \
5da2f69f	97	{\
b444ac3e AP	98	while(inl>=EVP_MAXCHUNK) \
	99	{\
	100	cprefix##_cbc_encrypt(in, out, (long)EVP_MAXCHUNK, &((kstruct *)ctx->cipher_data)->ksched, ctx->iv, ctx->encrypt);\
	101	inl-=EVP_MAXCHUNK;\
	102	in +=EVP_MAXCHUNK;\
	103	out+=EVP_MAXCHUNK;\
	104	}\
	105	if (inl)\
	106	cprefix##_cbc_encrypt(in, out, (long)inl, &((kstruct *)ctx->cipher_data)->ksched, ctx->iv, ctx->encrypt);\
5da2f69f DSH	107	return 1;\
	108	}
	109
a6cd8707	110	#define BLOCK_CIPHER_func_cfb(cname, cprefix, cbits, kstruct, ksched) \
b444ac3e	111	static int cname##_cfb##cbits##_cipher(EVP_CIPHER_CTX ctx, unsigned char out, const unsigned char *in, size_t inl) \
5da2f69f	112	{\
b444ac3e AP	113	size_t chunk=EVP_MAXCHUNK;\
	114	if (cbits==1) chunk>>=3;\
	115	if (inl<chunk) chunk=inl;\
	116	while(inl && inl>=chunk)\
	117	{\
79cfc3ac	118	cprefix##_cfb##cbits##_encrypt(in, out, (long)((cbits==1) && !(ctx->flags & EVP_CIPH_FLAG_LENGTH_BITS) ?inl8:inl), &((kstruct )ctx->cipher_data)->ksched, ctx->iv, &ctx->num, ctx->encrypt);\
b444ac3e AP	119	inl-=chunk;\
	120	in +=chunk;\
	121	out+=chunk;\
	122	if(inl<chunk) chunk=inl;\
	123	}\
5da2f69f DSH	124	return 1;\
	125	}
	126
a6cd8707	127	#define BLOCK_CIPHER_all_funcs(cname, cprefix, cbits, kstruct, ksched) \
dbad1690	128	BLOCK_CIPHER_func_cbc(cname, cprefix, kstruct, ksched) \
a6cd8707	129	BLOCK_CIPHER_func_cfb(cname, cprefix, cbits, kstruct, ksched) \
dbad1690	130	BLOCK_CIPHER_func_ecb(cname, cprefix, kstruct, ksched) \
a6cd8707	131	BLOCK_CIPHER_func_ofb(cname, cprefix, cbits, kstruct, ksched)
5da2f69f	132
c518ade1 BL	133	#define BLOCK_CIPHER_def1(cname, nmode, mode, MODE, kstruct, nid, block_size, \
	134	key_len, iv_len, flags, init_key, cleanup, \
	135	set_asn1, get_asn1, ctrl) \
	136	static const EVP_CIPHER cname##_##mode = { \
	137	nid##_##nmode, block_size, key_len, iv_len, \
	138	flags \| EVP_CIPH_##MODE##_MODE, \
	139	init_key, \
	140	cname##_##mode##_cipher, \
	141	cleanup, \
dbad1690	142	sizeof(kstruct), \
c518ade1 BL	143	set_asn1, get_asn1,\
	144	ctrl, \
	145	NULL \
	146	}; \
	147	const EVP_CIPHER *EVP_##cname##_##mode(void) { return &cname##_##mode; }
	148
	149	#define BLOCK_CIPHER_def_cbc(cname, kstruct, nid, block_size, key_len, \
	150	iv_len, flags, init_key, cleanup, set_asn1, \
	151	get_asn1, ctrl) \
	152	BLOCK_CIPHER_def1(cname, cbc, cbc, CBC, kstruct, nid, block_size, key_len, \
	153	iv_len, flags, init_key, cleanup, set_asn1, get_asn1, ctrl)
	154
3f6db7f5	155	#define BLOCK_CIPHER_def_cfb(cname, kstruct, nid, key_len, \
a6cd8707 RL	156	iv_len, cbits, flags, init_key, cleanup, \
a6cd8707 RL	157	set_asn1, get_asn1, ctrl) \
37c541fa DSH	158	BLOCK_CIPHER_def1(cname, cfb##cbits, cfb##cbits, CFB, kstruct, nid, 1, \
	159	key_len, iv_len, flags, init_key, cleanup, set_asn1, \
	160	get_asn1, ctrl)
c518ade1	161
3f6db7f5	162	#define BLOCK_CIPHER_def_ofb(cname, kstruct, nid, key_len, \
a6cd8707 RL	163	iv_len, cbits, flags, init_key, cleanup, \
a6cd8707 RL	164	set_asn1, get_asn1, ctrl) \
3f6db7f5	165	BLOCK_CIPHER_def1(cname, ofb##cbits, ofb, OFB, kstruct, nid, 1, \
a6cd8707 RL	166	key_len, iv_len, flags, init_key, cleanup, set_asn1, \
a6cd8707 RL	167	get_asn1, ctrl)
c518ade1 BL	168
c518ade1 BL	169	#define BLOCK_CIPHER_def_ecb(cname, kstruct, nid, block_size, key_len, \
20eb7238	170	flags, init_key, cleanup, set_asn1, \
c518ade1 BL	171	get_asn1, ctrl) \
c518ade1 BL	172	BLOCK_CIPHER_def1(cname, ecb, ecb, ECB, kstruct, nid, block_size, key_len, \
20eb7238	173	0, flags, init_key, cleanup, set_asn1, get_asn1, ctrl)
c518ade1 BL	174
c518ade1 BL	175	#define BLOCK_CIPHER_defs(cname, kstruct, \
a6cd8707	176	nid, block_size, key_len, iv_len, cbits, flags, \
c518ade1 BL	177	init_key, cleanup, set_asn1, get_asn1, ctrl) \
	178	BLOCK_CIPHER_def_cbc(cname, kstruct, nid, block_size, key_len, iv_len, flags, \
	179	init_key, cleanup, set_asn1, get_asn1, ctrl) \
3f6db7f5	180	BLOCK_CIPHER_def_cfb(cname, kstruct, nid, key_len, iv_len, cbits, \
a6cd8707	181	flags, init_key, cleanup, set_asn1, get_asn1, ctrl) \
3f6db7f5	182	BLOCK_CIPHER_def_ofb(cname, kstruct, nid, key_len, iv_len, cbits, \
a6cd8707	183	flags, init_key, cleanup, set_asn1, get_asn1, ctrl) \
20eb7238	184	BLOCK_CIPHER_def_ecb(cname, kstruct, nid, block_size, key_len, flags, \
c518ade1 BL	185	init_key, cleanup, set_asn1, get_asn1, ctrl)
	186
	187
1d97c843	188	/*-
5da2f69f DSH	189	#define BLOCK_CIPHER_defs(cname, kstruct, \
	190	nid, block_size, key_len, iv_len, flags,\
	191	init_key, cleanup, set_asn1, get_asn1, ctrl)\
13588350	192	static const EVP_CIPHER cname##_cbc = {\
5da2f69f DSH	193	nid##_cbc, block_size, key_len, iv_len, \
	194	flags \| EVP_CIPH_CBC_MODE,\
	195	init_key,\
	196	cname##_cbc_cipher,\
	197	cleanup,\
	198	sizeof(EVP_CIPHER_CTX)-sizeof((((EVP_CIPHER_CTX *)NULL)->c))+\
e366f2b8	199	sizeof((((EVP_CIPHER_CTX *)NULL)->c.kstruct)),\
5da2f69f DSH	200	set_asn1, get_asn1,\
	201	ctrl, \
	202	NULL \
	203	};\
13588350 DSH	204	const EVP_CIPHER *EVP_##cname##_cbc(void) { return &cname##_cbc; }\
13588350 DSH	205	static const EVP_CIPHER cname##_cfb = {\
5da2f69f DSH	206	nid##_cfb64, 1, key_len, iv_len, \
	207	flags \| EVP_CIPH_CFB_MODE,\
	208	init_key,\
	209	cname##_cfb_cipher,\
	210	cleanup,\
	211	sizeof(EVP_CIPHER_CTX)-sizeof((((EVP_CIPHER_CTX *)NULL)->c))+\
e366f2b8	212	sizeof((((EVP_CIPHER_CTX *)NULL)->c.kstruct)),\
5da2f69f DSH	213	set_asn1, get_asn1,\
	214	ctrl,\
	215	NULL \
	216	};\
13588350 DSH	217	const EVP_CIPHER *EVP_##cname##_cfb(void) { return &cname##_cfb; }\
13588350 DSH	218	static const EVP_CIPHER cname##_ofb = {\
5da2f69f DSH	219	nid##_ofb64, 1, key_len, iv_len, \
	220	flags \| EVP_CIPH_OFB_MODE,\
	221	init_key,\
	222	cname##_ofb_cipher,\
	223	cleanup,\
	224	sizeof(EVP_CIPHER_CTX)-sizeof((((EVP_CIPHER_CTX *)NULL)->c))+\
e366f2b8	225	sizeof((((EVP_CIPHER_CTX *)NULL)->c.kstruct)),\
5da2f69f DSH	226	set_asn1, get_asn1,\
	227	ctrl,\
	228	NULL \
	229	};\
13588350 DSH	230	const EVP_CIPHER *EVP_##cname##_ofb(void) { return &cname##_ofb; }\
13588350 DSH	231	static const EVP_CIPHER cname##_ecb = {\
5da2f69f DSH	232	nid##_ecb, block_size, key_len, iv_len, \
	233	flags \| EVP_CIPH_ECB_MODE,\
	234	init_key,\
	235	cname##_ecb_cipher,\
	236	cleanup,\
	237	sizeof(EVP_CIPHER_CTX)-sizeof((((EVP_CIPHER_CTX *)NULL)->c))+\
e366f2b8	238	sizeof((((EVP_CIPHER_CTX *)NULL)->c.kstruct)),\
5da2f69f DSH	239	set_asn1, get_asn1,\
	240	ctrl,\
	241	NULL \
	242	};\
13588350	243	const EVP_CIPHER *EVP_##cname##_ecb(void) { return &cname##_ecb; }
c518ade1	244	*/
5da2f69f	245
dbad1690	246	#define IMPLEMENT_BLOCK_CIPHER(cname, ksched, cprefix, kstruct, nid, \
a6cd8707 RL	247	block_size, key_len, iv_len, cbits, \
a6cd8707 RL	248	flags, init_key, \
dbad1690	249	cleanup, set_asn1, get_asn1, ctrl) \
a6cd8707	250	BLOCK_CIPHER_all_funcs(cname, cprefix, cbits, kstruct, ksched) \
dbad1690	251	BLOCK_CIPHER_defs(cname, kstruct, nid, block_size, key_len, iv_len, \
a6cd8707 RL	252	cbits, flags, init_key, cleanup, set_asn1, \
a6cd8707 RL	253	get_asn1, ctrl)
5da2f69f	254
dbad1690	255	#define EVP_C_DATA(kstruct, ctx) ((kstruct *)(ctx)->cipher_data)
8d1ebe0b	256
7a4bd34a	257	#define IMPLEMENT_CFBR(cipher,cprefix,kstruct,ksched,keysize,cbits,iv_len,fl) \
8d1ebe0b RL	258	BLOCK_CIPHER_func_cfb(cipher##_##keysize,cprefix,cbits,kstruct,ksched) \
	259	BLOCK_CIPHER_def_cfb(cipher##_##keysize,kstruct, \
	260	NID_##cipher##_##keysize, keysize/8, iv_len, cbits, \
7a4bd34a DSH	261	(fl)\|EVP_CIPH_FLAG_DEFAULT_ASN1, \
7a4bd34a DSH	262	cipher##_init_key, NULL, NULL, NULL, NULL)
0b6f3c66	263
0b6f3c66 DSH	264	struct evp_pkey_ctx_st
	265	{
	266	/* Method associated with this operation */
	267	const EVP_PKEY_METHOD *pmeth;
c9777d26 DSH	268	/* Engine that implements this method or NULL if builtin */
c9777d26 DSH	269	ENGINE *engine;
0b6f3c66 DSH	270	/* Key: may be NULL */
0b6f3c66 DSH	271	EVP_PKEY *pkey;
d87e6152 DSH	272	/* Peer key for key agreement, may be NULL */
d87e6152 DSH	273	EVP_PKEY *peerkey;
0b6f3c66 DSH	274	/* Actual operation */
	275	int operation;
	276	/* Algorithm specific data */
	277	void *data;
f5cda4cb DSH	278	/* Application specific data */
	279	void *app_data;
	280	/* Keygen callback */
	281	EVP_PKEY_gen_cb *pkey_gencb;
	282	/* implementation specific keygen data */
	283	int *keygen_info;
	284	int keygen_info_count;
0b6f3c66 DSH	285	} /* EVP_PKEY_CTX */;
0b6f3c66 DSH	286
b010b7c4	287	#define EVP_PKEY_FLAG_DYNAMIC 1
ba30bad5	288
0b6f3c66 DSH	289	struct evp_pkey_method_st
	290	{
	291	int pkey_id;
5da98aa6	292	int flags;
07e970c7	293
5da98aa6	294	int (init)(EVP_PKEY_CTX ctx);
8bdcef40	295	int (copy)(EVP_PKEY_CTX dst, EVP_PKEY_CTX *src);
07e970c7	296	void (cleanup)(EVP_PKEY_CTX ctx);
f733a5ef	297
0b6f3c66	298	int (paramgen_init)(EVP_PKEY_CTX ctx);
f5cda4cb	299	int (paramgen)(EVP_PKEY_CTX ctx, EVP_PKEY *pkey);
0b6f3c66 DSH	300
0b6f3c66 DSH	301	int (keygen_init)(EVP_PKEY_CTX ctx);
f5cda4cb	302	int (keygen)(EVP_PKEY_CTX ctx, EVP_PKEY *pkey);
0b6f3c66	303
cd763898	304	int (sign_init)(EVP_PKEY_CTX ctx);
eaff5a14 DSH	305	int (sign)(EVP_PKEY_CTX ctx, unsigned char sig, size_t siglen,
eaff5a14 DSH	306	const unsigned char *tbs, size_t tbslen);
0b6f3c66	307
cd763898	308	int (verify_init)(EVP_PKEY_CTX ctx);
eaff5a14 DSH	309	int (verify)(EVP_PKEY_CTX ctx,
	310	const unsigned char *sig, size_t siglen,
	311	const unsigned char *tbs, size_t tbslen);
0b6f3c66	312
cd763898	313	int (verify_recover_init)(EVP_PKEY_CTX ctx);
0b6f3c66	314	int (verify_recover)(EVP_PKEY_CTX ctx,
eaff5a14 DSH	315	unsigned char rout, size_t routlen,
eaff5a14 DSH	316	const unsigned char *sig, size_t siglen);
0b6f3c66	317
cd763898	318	int (signctx_init)(EVP_PKEY_CTX ctx, EVP_MD_CTX *mctx);
eaff5a14	319	int (signctx)(EVP_PKEY_CTX ctx, unsigned char sig, size_t siglen,
0b6f3c66 DSH	320	EVP_MD_CTX *mctx);
0b6f3c66 DSH	321
cd763898	322	int (verifyctx_init)(EVP_PKEY_CTX ctx, EVP_MD_CTX *mctx);
a58a6368	323	int (verifyctx)(EVP_PKEY_CTX ctx, const unsigned char *sig,int siglen,
0b6f3c66 DSH	324	EVP_MD_CTX *mctx);
0b6f3c66 DSH	325
cd763898	326	int (encrypt_init)(EVP_PKEY_CTX ctx);
eaff5a14 DSH	327	int (encrypt)(EVP_PKEY_CTX ctx, unsigned char out, size_t outlen,
eaff5a14 DSH	328	const unsigned char *in, size_t inlen);
0b6f3c66	329
cd763898	330	int (decrypt_init)(EVP_PKEY_CTX ctx);
eaff5a14 DSH	331	int (decrypt)(EVP_PKEY_CTX ctx, unsigned char out, size_t outlen,
eaff5a14 DSH	332	const unsigned char *in, size_t inlen);
0b6f3c66	333
d87e6152	334	int (derive_init)(EVP_PKEY_CTX ctx);
eaff5a14	335	int (derive)(EVP_PKEY_CTX ctx, unsigned char key, size_t keylen);
d87e6152	336
0b6f3c66 DSH	337	int (ctrl)(EVP_PKEY_CTX ctx, int type, int p1, void *p2);
	338	int (ctrl_str)(EVP_PKEY_CTX ctx, const char type, const char value);
	339
0b6f3c66 DSH	340
0b6f3c66 DSH	341	} /* EVP_PKEY_METHOD */;
f5cda4cb DSH	342
f5cda4cb DSH	343	void evp_pkey_set_cb_translate(BN_GENCB cb, EVP_PKEY_CTX ctx);
3d63b396 DSH	344
	345	int PKCS5_v2_PBKDF2_keyivgen(EVP_CIPHER_CTX ctx, const char pass, int passlen,
	346	ASN1_TYPE *param,
	347	const EVP_CIPHER c, const EVP_MD md, int en_de);