[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).
 *
 */

/* EVP_MD_CTX related stuff */

struct evp_md_ctx_st {
    const EVP_MD *digest;
    ENGINE *engine;             /* functional reference if 'digest' is
                                 * ENGINE-provided */
    unsigned long flags;
    void *md_data;
    /* Public key context for sign/verify */
    EVP_PKEY_CTX *pctx;
    /* Update function: usually copied from EVP_MD */
    int (*update) (EVP_MD_CTX *ctx, const void *data, size_t count);
} /* EVP_MD_CTX */ ;

/* 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)

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 */
0f113f3e MC	2	/*
	3	* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL project
	4	* 2000.
5da2f69f DSH	5	*/
	6	/* ====================================================================
	7	* Copyright (c) 1999 The OpenSSL Project. All rights reserved.
	8	*
	9	* Redistribution and use in source and binary forms, with or without
	10	* modification, are permitted provided that the following conditions
	11	* are met:
	12	*
	13	* 1. Redistributions of source code must retain the above copyright
0f113f3e	14	* notice, this list of conditions and the following disclaimer.
5da2f69f DSH	15	*
	16	* 2. Redistributions in binary form must reproduce the above copyright
	17	* notice, this list of conditions and the following disclaimer in
	18	* the documentation and/or other materials provided with the
	19	* distribution.
	20	*
	21	* 3. All advertising materials mentioning features or use of this
	22	* software must display the following acknowledgment:
	23	* "This product includes software developed by the OpenSSL Project
	24	* for use in the OpenSSL Toolkit. (http://www.OpenSSL.org/)"
	25	*
	26	* 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
	27	* endorse or promote products derived from this software without
	28	* prior written permission. For written permission, please contact
	29	* licensing@OpenSSL.org.
	30	*
	31	* 5. Products derived from this software may not be called "OpenSSL"
	32	* nor may "OpenSSL" appear in their names without prior written
	33	* permission of the OpenSSL Project.
	34	*
	35	* 6. Redistributions of any form whatsoever must retain the following
	36	* acknowledgment:
	37	* "This product includes software developed by the OpenSSL Project
	38	* for use in the OpenSSL Toolkit (http://www.OpenSSL.org/)"
	39	*
	40	* THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
	41	* EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
	42	* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
	43	* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE OpenSSL PROJECT OR
	44	* ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
	45	* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
	46	* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
	47	* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
	48	* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
	49	* STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
	50	* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
	51	* OF THE POSSIBILITY OF SUCH DAMAGE.
	52	* ====================================================================
	53	*
	54	* This product includes cryptographic software written by Eric Young
	55	* (eay@cryptsoft.com). This product includes software written by Tim
	56	* Hudson (tjh@cryptsoft.com).
	57	*
	58	*/
	59
7638370c RL	60	/* EVP_MD_CTX related stuff */
	61
	62	struct evp_md_ctx_st {
	63	const EVP_MD *digest;
	64	ENGINE engine; / functional reference if 'digest' is
	65	* ENGINE-provided */
	66	unsigned long flags;
	67	void *md_data;
	68	/* Public key context for sign/verify */
	69	EVP_PKEY_CTX *pctx;
	70	/* Update function: usually copied from EVP_MD */
	71	int (update) (EVP_MD_CTX ctx, const void *data, size_t count);
	72	} /* EVP_MD_CTX */ ;
	73
5da2f69f DSH	74	/* Macros to code block cipher wrappers */
	75
	76	/* Wrapper functions for each cipher mode */
	77
	78	#define BLOCK_CIPHER_ecb_loop() \
0f113f3e MC	79	size_t i, bl; \
	80	bl = ctx->cipher->block_size;\
	81	if(inl < bl) return 1;\
	82	inl -= bl; \
	83	for(i=0; i <= inl; i+=bl)
5da2f69f	84
dbad1690	85	#define BLOCK_CIPHER_func_ecb(cname, cprefix, kstruct, ksched) \
b444ac3e	86	static int cname##_ecb_cipher(EVP_CIPHER_CTX ctx, unsigned char out, const unsigned char *in, size_t inl) \
5da2f69f	87	{\
0f113f3e MC	88	BLOCK_CIPHER_ecb_loop() \
	89	cprefix##_ecb_encrypt(in + i, out + i, &((kstruct *)ctx->cipher_data)->ksched, ctx->encrypt);\
	90	return 1;\
5da2f69f DSH	91	}
5da2f69f DSH	92
b444ac3e AP	93	#define EVP_MAXCHUNK ((size_t)1<<(sizeof(long)*8-2))
b444ac3e AP	94
a6cd8707	95	#define BLOCK_CIPHER_func_ofb(cname, cprefix, cbits, kstruct, ksched) \
b444ac3e	96	static int cname##_ofb_cipher(EVP_CIPHER_CTX ctx, unsigned char out, const unsigned char *in, size_t inl) \
5da2f69f	97	{\
0f113f3e MC	98	while(inl>=EVP_MAXCHUNK)\
	99	{\
	100	cprefix##_ofb##cbits##_encrypt(in, out, (long)EVP_MAXCHUNK, &((kstruct *)ctx->cipher_data)->ksched, ctx->iv, &ctx->num);\
	101	inl-=EVP_MAXCHUNK;\
	102	in +=EVP_MAXCHUNK;\
	103	out+=EVP_MAXCHUNK;\
	104	}\
	105	if (inl)\
	106	cprefix##_ofb##cbits##_encrypt(in, out, (long)inl, &((kstruct *)ctx->cipher_data)->ksched, ctx->iv, &ctx->num);\
	107	return 1;\
5da2f69f DSH	108	}
5da2f69f DSH	109
dbad1690	110	#define BLOCK_CIPHER_func_cbc(cname, cprefix, kstruct, ksched) \
b444ac3e	111	static int cname##_cbc_cipher(EVP_CIPHER_CTX ctx, unsigned char out, const unsigned char *in, size_t inl) \
5da2f69f	112	{\
0f113f3e MC	113	while(inl>=EVP_MAXCHUNK) \
	114	{\
	115	cprefix##_cbc_encrypt(in, out, (long)EVP_MAXCHUNK, &((kstruct *)ctx->cipher_data)->ksched, ctx->iv, ctx->encrypt);\
	116	inl-=EVP_MAXCHUNK;\
	117	in +=EVP_MAXCHUNK;\
	118	out+=EVP_MAXCHUNK;\
	119	}\
	120	if (inl)\
	121	cprefix##_cbc_encrypt(in, out, (long)inl, &((kstruct *)ctx->cipher_data)->ksched, ctx->iv, ctx->encrypt);\
	122	return 1;\
5da2f69f DSH	123	}
5da2f69f DSH	124
a6cd8707	125	#define BLOCK_CIPHER_func_cfb(cname, cprefix, cbits, kstruct, ksched) \
b444ac3e	126	static int cname##_cfb##cbits##_cipher(EVP_CIPHER_CTX ctx, unsigned char out, const unsigned char *in, size_t inl) \
5da2f69f	127	{\
0f113f3e MC	128	size_t chunk=EVP_MAXCHUNK;\
	129	if (cbits==1) chunk>>=3;\
	130	if (inl<chunk) chunk=inl;\
	131	while(inl && inl>=chunk)\
	132	{\
79cfc3ac	133	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);\
0f113f3e MC	134	inl-=chunk;\
	135	in +=chunk;\
	136	out+=chunk;\
	137	if(inl<chunk) chunk=inl;\
	138	}\
	139	return 1;\
5da2f69f DSH	140	}
5da2f69f DSH	141
a6cd8707	142	#define BLOCK_CIPHER_all_funcs(cname, cprefix, cbits, kstruct, ksched) \
0f113f3e MC	143	BLOCK_CIPHER_func_cbc(cname, cprefix, kstruct, ksched) \
	144	BLOCK_CIPHER_func_cfb(cname, cprefix, cbits, kstruct, ksched) \
	145	BLOCK_CIPHER_func_ecb(cname, cprefix, kstruct, ksched) \
	146	BLOCK_CIPHER_func_ofb(cname, cprefix, cbits, kstruct, ksched)
5da2f69f	147
c518ade1	148	#define BLOCK_CIPHER_def1(cname, nmode, mode, MODE, kstruct, nid, block_size, \
0f113f3e MC	149	key_len, iv_len, flags, init_key, cleanup, \
0f113f3e MC	150	set_asn1, get_asn1, ctrl) \
c518ade1	151	static const EVP_CIPHER cname##_##mode = { \
0f113f3e MC	152	nid##_##nmode, block_size, key_len, iv_len, \
	153	flags \| EVP_CIPH_##MODE##_MODE, \
	154	init_key, \
	155	cname##_##mode##_cipher, \
	156	cleanup, \
	157	sizeof(kstruct), \
	158	set_asn1, get_asn1,\
	159	ctrl, \
	160	NULL \
c518ade1 BL	161	}; \
	162	const EVP_CIPHER *EVP_##cname##_##mode(void) { return &cname##_##mode; }
	163
	164	#define BLOCK_CIPHER_def_cbc(cname, kstruct, nid, block_size, key_len, \
0f113f3e MC	165	iv_len, flags, init_key, cleanup, set_asn1, \
0f113f3e MC	166	get_asn1, ctrl) \
c518ade1	167	BLOCK_CIPHER_def1(cname, cbc, cbc, CBC, kstruct, nid, block_size, key_len, \
0f113f3e	168	iv_len, flags, init_key, cleanup, set_asn1, get_asn1, ctrl)
c518ade1	169
3f6db7f5	170	#define BLOCK_CIPHER_def_cfb(cname, kstruct, nid, key_len, \
0f113f3e MC	171	iv_len, cbits, flags, init_key, cleanup, \
0f113f3e MC	172	set_asn1, get_asn1, ctrl) \
37c541fa	173	BLOCK_CIPHER_def1(cname, cfb##cbits, cfb##cbits, CFB, kstruct, nid, 1, \
0f113f3e MC	174	key_len, iv_len, flags, init_key, cleanup, set_asn1, \
0f113f3e MC	175	get_asn1, ctrl)
c518ade1	176
3f6db7f5	177	#define BLOCK_CIPHER_def_ofb(cname, kstruct, nid, key_len, \
0f113f3e MC	178	iv_len, cbits, flags, init_key, cleanup, \
0f113f3e MC	179	set_asn1, get_asn1, ctrl) \
3f6db7f5	180	BLOCK_CIPHER_def1(cname, ofb##cbits, ofb, OFB, kstruct, nid, 1, \
0f113f3e MC	181	key_len, iv_len, flags, init_key, cleanup, set_asn1, \
0f113f3e MC	182	get_asn1, ctrl)
c518ade1 BL	183
c518ade1 BL	184	#define BLOCK_CIPHER_def_ecb(cname, kstruct, nid, block_size, key_len, \
0f113f3e MC	185	flags, init_key, cleanup, set_asn1, \
0f113f3e MC	186	get_asn1, ctrl) \
c518ade1	187	BLOCK_CIPHER_def1(cname, ecb, ecb, ECB, kstruct, nid, block_size, key_len, \
0f113f3e	188	0, flags, init_key, cleanup, set_asn1, get_asn1, ctrl)
c518ade1 BL	189
c518ade1 BL	190	#define BLOCK_CIPHER_defs(cname, kstruct, \
0f113f3e MC	191	nid, block_size, key_len, iv_len, cbits, flags, \
0f113f3e MC	192	init_key, cleanup, set_asn1, get_asn1, ctrl) \
c518ade1	193	BLOCK_CIPHER_def_cbc(cname, kstruct, nid, block_size, key_len, iv_len, flags, \
0f113f3e	194	init_key, cleanup, set_asn1, get_asn1, ctrl) \
3f6db7f5	195	BLOCK_CIPHER_def_cfb(cname, kstruct, nid, key_len, iv_len, cbits, \
0f113f3e	196	flags, init_key, cleanup, set_asn1, get_asn1, ctrl) \
3f6db7f5	197	BLOCK_CIPHER_def_ofb(cname, kstruct, nid, key_len, iv_len, cbits, \
0f113f3e	198	flags, init_key, cleanup, set_asn1, get_asn1, ctrl) \
20eb7238	199	BLOCK_CIPHER_def_ecb(cname, kstruct, nid, block_size, key_len, flags, \
0f113f3e	200	init_key, cleanup, set_asn1, get_asn1, ctrl)
c518ade1	201
1d97c843	202	/*-
5da2f69f	203	#define BLOCK_CIPHER_defs(cname, kstruct, \
0f113f3e MC	204	nid, block_size, key_len, iv_len, flags,\
0f113f3e MC	205	init_key, cleanup, set_asn1, get_asn1, ctrl)\
13588350	206	static const EVP_CIPHER cname##_cbc = {\
0f113f3e MC	207	nid##_cbc, block_size, key_len, iv_len, \
	208	flags \| EVP_CIPH_CBC_MODE,\
	209	init_key,\
	210	cname##_cbc_cipher,\
	211	cleanup,\
	212	sizeof(EVP_CIPHER_CTX)-sizeof((((EVP_CIPHER_CTX *)NULL)->c))+\
	213	sizeof((((EVP_CIPHER_CTX *)NULL)->c.kstruct)),\
	214	set_asn1, get_asn1,\
	215	ctrl, \
	216	NULL \
5da2f69f	217	};\
13588350 DSH	218	const EVP_CIPHER *EVP_##cname##_cbc(void) { return &cname##_cbc; }\
13588350 DSH	219	static const EVP_CIPHER cname##_cfb = {\
0f113f3e MC	220	nid##_cfb64, 1, key_len, iv_len, \
	221	flags \| EVP_CIPH_CFB_MODE,\
	222	init_key,\
	223	cname##_cfb_cipher,\
	224	cleanup,\
	225	sizeof(EVP_CIPHER_CTX)-sizeof((((EVP_CIPHER_CTX *)NULL)->c))+\
	226	sizeof((((EVP_CIPHER_CTX *)NULL)->c.kstruct)),\
	227	set_asn1, get_asn1,\
	228	ctrl,\
	229	NULL \
5da2f69f	230	};\
13588350 DSH	231	const EVP_CIPHER *EVP_##cname##_cfb(void) { return &cname##_cfb; }\
13588350 DSH	232	static const EVP_CIPHER cname##_ofb = {\
0f113f3e MC	233	nid##_ofb64, 1, key_len, iv_len, \
	234	flags \| EVP_CIPH_OFB_MODE,\
	235	init_key,\
	236	cname##_ofb_cipher,\
	237	cleanup,\
	238	sizeof(EVP_CIPHER_CTX)-sizeof((((EVP_CIPHER_CTX *)NULL)->c))+\
	239	sizeof((((EVP_CIPHER_CTX *)NULL)->c.kstruct)),\
	240	set_asn1, get_asn1,\
	241	ctrl,\
	242	NULL \
5da2f69f	243	};\
13588350 DSH	244	const EVP_CIPHER *EVP_##cname##_ofb(void) { return &cname##_ofb; }\
13588350 DSH	245	static const EVP_CIPHER cname##_ecb = {\
0f113f3e MC	246	nid##_ecb, block_size, key_len, iv_len, \
	247	flags \| EVP_CIPH_ECB_MODE,\
	248	init_key,\
	249	cname##_ecb_cipher,\
	250	cleanup,\
	251	sizeof(EVP_CIPHER_CTX)-sizeof((((EVP_CIPHER_CTX *)NULL)->c))+\
	252	sizeof((((EVP_CIPHER_CTX *)NULL)->c.kstruct)),\
	253	set_asn1, get_asn1,\
	254	ctrl,\
	255	NULL \
5da2f69f	256	};\
13588350	257	const EVP_CIPHER *EVP_##cname##_ecb(void) { return &cname##_ecb; }
c518ade1	258	*/
5da2f69f	259
dbad1690	260	#define IMPLEMENT_BLOCK_CIPHER(cname, ksched, cprefix, kstruct, nid, \
0f113f3e MC	261	block_size, key_len, iv_len, cbits, \
	262	flags, init_key, \
	263	cleanup, set_asn1, get_asn1, ctrl) \
	264	BLOCK_CIPHER_all_funcs(cname, cprefix, cbits, kstruct, ksched) \
	265	BLOCK_CIPHER_defs(cname, kstruct, nid, block_size, key_len, iv_len, \
	266	cbits, flags, init_key, cleanup, set_asn1, \
	267	get_asn1, ctrl)
5da2f69f	268
0f113f3e	269	#define EVP_C_DATA(kstruct, ctx) ((kstruct *)(ctx)->cipher_data)
8d1ebe0b	270
7a4bd34a	271	#define IMPLEMENT_CFBR(cipher,cprefix,kstruct,ksched,keysize,cbits,iv_len,fl) \
0f113f3e MC	272	BLOCK_CIPHER_func_cfb(cipher##_##keysize,cprefix,cbits,kstruct,ksched) \
	273	BLOCK_CIPHER_def_cfb(cipher##_##keysize,kstruct, \
	274	NID_##cipher##_##keysize, keysize/8, iv_len, cbits, \
	275	(fl)\|EVP_CIPH_FLAG_DEFAULT_ASN1, \
	276	cipher##_init_key, NULL, NULL, NULL, NULL)
	277
0f113f3e MC	278	int PKCS5_v2_PBKDF2_keyivgen(EVP_CIPHER_CTX ctx, const char pass,
	279	int passlen, ASN1_TYPE *param,
	280	const EVP_CIPHER c, const EVP_MD md,
	281	int en_de);