/src/openssl111/crypto/evp/evp_lib.c

Source (jump to first uncovered line)
/*
 * Copyright 1995-2019 The OpenSSL Project Authors. All Rights Reserved.
 *
 * Licensed under the OpenSSL license (the "License").  You may not use
 * this file except in compliance with the License.  You can obtain a copy
 * in the file LICENSE in the source distribution or at
 * https://www.openssl.org/source/license.html
 */

#include <stdio.h>
#include "internal/cryptlib.h"
#include <openssl/evp.h>
#include <openssl/objects.h>
#include "crypto/evp.h"
#include "evp_local.h"

int EVP_CIPHER_param_to_asn1(EVP_CIPHER_CTX *c, ASN1_TYPE *type)
{
    int ret;

    if (c->cipher->set_asn1_parameters != NULL)
        ret = c->cipher->set_asn1_parameters(c, type);
    else if (c->cipher->flags & EVP_CIPH_FLAG_DEFAULT_ASN1) {
        switch (EVP_CIPHER_CTX_mode(c)) {
        case EVP_CIPH_WRAP_MODE:
            if (EVP_CIPHER_CTX_nid(c) == NID_id_smime_alg_CMS3DESwrap)
                ASN1_TYPE_set(type, V_ASN1_NULL, NULL);
            ret = 1;
            break;

        case EVP_CIPH_GCM_MODE:
        case EVP_CIPH_CCM_MODE:
        case EVP_CIPH_XTS_MODE:
        case EVP_CIPH_OCB_MODE:
            ret = -2;
            break;

        default:
            ret = EVP_CIPHER_set_asn1_iv(c, type);
        }
    } else
        ret = -1;
    if (ret <= 0)
        EVPerr(EVP_F_EVP_CIPHER_PARAM_TO_ASN1, ret == -2 ?
               ASN1_R_UNSUPPORTED_CIPHER :
               EVP_R_CIPHER_PARAMETER_ERROR);
    if (ret < -1)
        ret = -1;
    return ret;
}

int EVP_CIPHER_asn1_to_param(EVP_CIPHER_CTX *c, ASN1_TYPE *type)
{
    int ret;

    if (c->cipher->get_asn1_parameters != NULL)
        ret = c->cipher->get_asn1_parameters(c, type);
    else if (c->cipher->flags & EVP_CIPH_FLAG_DEFAULT_ASN1) {
        switch (EVP_CIPHER_CTX_mode(c)) {

        case EVP_CIPH_WRAP_MODE:
            ret = 1;
            break;

        case EVP_CIPH_GCM_MODE:
        case EVP_CIPH_CCM_MODE:
        case EVP_CIPH_XTS_MODE:
        case EVP_CIPH_OCB_MODE:
            ret = -2;
            break;

        default:
            ret = EVP_CIPHER_get_asn1_iv(c, type);
            break;
        }
    } else
        ret = -1;
    if (ret <= 0)
        EVPerr(EVP_F_EVP_CIPHER_ASN1_TO_PARAM, ret == -2 ?
               EVP_R_UNSUPPORTED_CIPHER :
               EVP_R_CIPHER_PARAMETER_ERROR);
    if (ret < -1)
        ret = -1;
    return ret;
}

int EVP_CIPHER_get_asn1_iv(EVP_CIPHER_CTX *c, ASN1_TYPE *type)
{
    int i = 0;
    unsigned int l;

    if (type != NULL) {
        l = EVP_CIPHER_CTX_iv_length(c);
        OPENSSL_assert(l <= sizeof(c->iv));
        i = ASN1_TYPE_get_octetstring(type, c->oiv, l);
        if (i != (int)l)
            return -1;
        else if (i > 0)
            memcpy(c->iv, c->oiv, l);
    }
    return i;
}

int EVP_CIPHER_set_asn1_iv(EVP_CIPHER_CTX *c, ASN1_TYPE *type)
{
    int i = 0;
    unsigned int j;

    if (type != NULL) {
        j = EVP_CIPHER_CTX_iv_length(c);
        OPENSSL_assert(j <= sizeof(c->iv));
        i = ASN1_TYPE_set_octetstring(type, c->oiv, j);
    }
    return i;
}

/* Convert the various cipher NIDs and dummies to a proper OID NID */
int EVP_CIPHER_type(const EVP_CIPHER *ctx)
{
    int nid;
    ASN1_OBJECT *otmp;
    nid = EVP_CIPHER_nid(ctx);

    switch (nid) {

    case NID_rc2_cbc:
    case NID_rc2_64_cbc:
    case NID_rc2_40_cbc:

        return NID_rc2_cbc;

    case NID_rc4:
    case NID_rc4_40:

        return NID_rc4;

    case NID_aes_128_cfb128:
    case NID_aes_128_cfb8:
    case NID_aes_128_cfb1:

        return NID_aes_128_cfb128;

    case NID_aes_192_cfb128:
    case NID_aes_192_cfb8:
    case NID_aes_192_cfb1:

        return NID_aes_192_cfb128;

    case NID_aes_256_cfb128:
    case NID_aes_256_cfb8:
    case NID_aes_256_cfb1:

        return NID_aes_256_cfb128;

    case NID_des_cfb64:
    case NID_des_cfb8:
    case NID_des_cfb1:

        return NID_des_cfb64;

    case NID_des_ede3_cfb64:
    case NID_des_ede3_cfb8:
    case NID_des_ede3_cfb1:

        return NID_des_cfb64;

    default:
        /* Check it has an OID and it is valid */
        otmp = OBJ_nid2obj(nid);
        if (OBJ_get0_data(otmp) == NULL)
            nid = NID_undef;
        ASN1_OBJECT_free(otmp);
        return nid;
    }
}

int EVP_CIPHER_block_size(const EVP_CIPHER *e)
{
    return e->block_size;
}

int EVP_CIPHER_CTX_block_size(const EVP_CIPHER_CTX *ctx)
{
    return ctx->cipher->block_size;
}

int EVP_CIPHER_impl_ctx_size(const EVP_CIPHER *e)
{
    return e->ctx_size;
}

int EVP_Cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
               const unsigned char *in, unsigned int inl)
{
    return ctx->cipher->do_cipher(ctx, out, in, inl);
}

const EVP_CIPHER *EVP_CIPHER_CTX_cipher(const EVP_CIPHER_CTX *ctx)
{
    return ctx->cipher;
}

int EVP_CIPHER_CTX_encrypting(const EVP_CIPHER_CTX *ctx)
{
    return ctx->encrypt;
}

unsigned long EVP_CIPHER_flags(const EVP_CIPHER *cipher)
{
    return cipher->flags;
}

void *EVP_CIPHER_CTX_get_app_data(const EVP_CIPHER_CTX *ctx)
{
    return ctx->app_data;
}

void EVP_CIPHER_CTX_set_app_data(EVP_CIPHER_CTX *ctx, void *data)
{
    ctx->app_data = data;
}

void *EVP_CIPHER_CTX_get_cipher_data(const EVP_CIPHER_CTX *ctx)
{
    return ctx->cipher_data;
}

void *EVP_CIPHER_CTX_set_cipher_data(EVP_CIPHER_CTX *ctx, void *cipher_data)
{
    void *old_cipher_data;

    old_cipher_data = ctx->cipher_data;
    ctx->cipher_data = cipher_data;

    return old_cipher_data;
}

int EVP_CIPHER_iv_length(const EVP_CIPHER *cipher)
{
    return cipher->iv_len;
}

int EVP_CIPHER_CTX_iv_length(const EVP_CIPHER_CTX *ctx)
{
    int i, rv;

    if ((EVP_CIPHER_flags(ctx->cipher) & EVP_CIPH_CUSTOM_IV_LENGTH) != 0) {
        rv = EVP_CIPHER_CTX_ctrl((EVP_CIPHER_CTX *)ctx, EVP_CTRL_GET_IVLEN,
                                 0, &i);
        return (rv == 1) ? i : -1;
    }
    return ctx->cipher->iv_len;
}

const unsigned char *EVP_CIPHER_CTX_original_iv(const EVP_CIPHER_CTX *ctx)
{
    return ctx->oiv;
}

const unsigned char *EVP_CIPHER_CTX_iv(const EVP_CIPHER_CTX *ctx)
{
    return ctx->iv;
}

unsigned char *EVP_CIPHER_CTX_iv_noconst(EVP_CIPHER_CTX *ctx)
{
    return ctx->iv;
}

unsigned char *EVP_CIPHER_CTX_buf_noconst(EVP_CIPHER_CTX *ctx)
{
    return ctx->buf;
}

int EVP_CIPHER_CTX_num(const EVP_CIPHER_CTX *ctx)
{
    return ctx->num;
}

void EVP_CIPHER_CTX_set_num(EVP_CIPHER_CTX *ctx, int num)
{
    ctx->num = num;
}

int EVP_CIPHER_key_length(const EVP_CIPHER *cipher)
{
    return cipher->key_len;
}

int EVP_CIPHER_CTX_key_length(const EVP_CIPHER_CTX *ctx)
{
    return ctx->key_len;
}

int EVP_CIPHER_nid(const EVP_CIPHER *cipher)
{
    return cipher->nid;
}

int EVP_CIPHER_CTX_nid(const EVP_CIPHER_CTX *ctx)
{
    return ctx->cipher->nid;
}

int EVP_MD_block_size(const EVP_MD *md)
{
    return md->block_size;
}

int EVP_MD_type(const EVP_MD *md)
{
    return md->type;
}

int EVP_MD_pkey_type(const EVP_MD *md)
{
    return md->pkey_type;
}

int EVP_MD_size(const EVP_MD *md)
{
    if (!md) {
        EVPerr(EVP_F_EVP_MD_SIZE, EVP_R_MESSAGE_DIGEST_IS_NULL);
        return -1;
    }
    return md->md_size;
}

unsigned long EVP_MD_flags(const EVP_MD *md)
{
    return md->flags;
}

EVP_MD *EVP_MD_meth_new(int md_type, int pkey_type)
{
    EVP_MD *md = OPENSSL_zalloc(sizeof(*md));

    if (md != NULL) {
        md->type = md_type;
        md->pkey_type = pkey_type;
    }
    return md;
}
EVP_MD *EVP_MD_meth_dup(const EVP_MD *md)
{
    EVP_MD *to = EVP_MD_meth_new(md->type, md->pkey_type);

    if (to != NULL)
        memcpy(to, md, sizeof(*to));
    return to;
}
void EVP_MD_meth_free(EVP_MD *md)
{
    OPENSSL_free(md);
}
int EVP_MD_meth_set_input_blocksize(EVP_MD *md, int blocksize)
{
    md->block_size = blocksize;
    return 1;
}
int EVP_MD_meth_set_result_size(EVP_MD *md, int resultsize)
{
    md->md_size = resultsize;
    return 1;
}
int EVP_MD_meth_set_app_datasize(EVP_MD *md, int datasize)
{
    md->ctx_size = datasize;
    return 1;
}
int EVP_MD_meth_set_flags(EVP_MD *md, unsigned long flags)
{
    md->flags = flags;
    return 1;
}
int EVP_MD_meth_set_init(EVP_MD *md, int (*init)(EVP_MD_CTX *ctx))
{
    md->init = init;
    return 1;
}
int EVP_MD_meth_set_update(EVP_MD *md, int (*update)(EVP_MD_CTX *ctx,
                                                     const void *data,
                                                     size_t count))
{
    md->update = update;
    return 1;
}
int EVP_MD_meth_set_final(EVP_MD *md, int (*final)(EVP_MD_CTX *ctx,
                                                   unsigned char *md))
{
    md->final = final;
    return 1;
}
int EVP_MD_meth_set_copy(EVP_MD *md, int (*copy)(EVP_MD_CTX *to,
                                                 const EVP_MD_CTX *from))
{
    md->copy = copy;
    return 1;
}
int EVP_MD_meth_set_cleanup(EVP_MD *md, int (*cleanup)(EVP_MD_CTX *ctx))
{
    md->cleanup = cleanup;
    return 1;
}
int EVP_MD_meth_set_ctrl(EVP_MD *md, int (*ctrl)(EVP_MD_CTX *ctx, int cmd,
                                                 int p1, void *p2))
{
    md->md_ctrl = ctrl;
    return 1;
}

int EVP_MD_meth_get_input_blocksize(const EVP_MD *md)
{
    return md->block_size;
}
int EVP_MD_meth_get_result_size(const EVP_MD *md)
{
    return md->md_size;
}
int EVP_MD_meth_get_app_datasize(const EVP_MD *md)
{
    return md->ctx_size;
}
unsigned long EVP_MD_meth_get_flags(const EVP_MD *md)
{
    return md->flags;
}
int (*EVP_MD_meth_get_init(const EVP_MD *md))(EVP_MD_CTX *ctx)
{
    return md->init;
}
int (*EVP_MD_meth_get_update(const EVP_MD *md))(EVP_MD_CTX *ctx,
                                                const void *data,
                                                size_t count)
{
    return md->update;
}
int (*EVP_MD_meth_get_final(const EVP_MD *md))(EVP_MD_CTX *ctx,
                                               unsigned char *md)
{
    return md->final;
}
int (*EVP_MD_meth_get_copy(const EVP_MD *md))(EVP_MD_CTX *to,
                                              const EVP_MD_CTX *from)
{
    return md->copy;
}
int (*EVP_MD_meth_get_cleanup(const EVP_MD *md))(EVP_MD_CTX *ctx)
{
    return md->cleanup;
}
int (*EVP_MD_meth_get_ctrl(const EVP_MD *md))(EVP_MD_CTX *ctx, int cmd,
                                              int p1, void *p2)
{
    return md->md_ctrl;
}

const EVP_MD *EVP_MD_CTX_md(const EVP_MD_CTX *ctx)
{
    if (!ctx)
        return NULL;
    return ctx->digest;
}

EVP_PKEY_CTX *EVP_MD_CTX_pkey_ctx(const EVP_MD_CTX *ctx)
{
    return ctx->pctx;
}

void EVP_MD_CTX_set_pkey_ctx(EVP_MD_CTX *ctx, EVP_PKEY_CTX *pctx)
{
    /*
     * it's reasonable to set NULL pctx (a.k.a clear the ctx->pctx), so
     * we have to deal with the cleanup job here.
     */
    if (!EVP_MD_CTX_test_flags(ctx, EVP_MD_CTX_FLAG_KEEP_PKEY_CTX))
        EVP_PKEY_CTX_free(ctx->pctx);

    ctx->pctx = pctx;

    if (pctx != NULL) {
        /* make sure pctx is not freed when destroying EVP_MD_CTX */
        EVP_MD_CTX_set_flags(ctx, EVP_MD_CTX_FLAG_KEEP_PKEY_CTX);
    } else {
        EVP_MD_CTX_clear_flags(ctx, EVP_MD_CTX_FLAG_KEEP_PKEY_CTX);
    }
}

void *EVP_MD_CTX_md_data(const EVP_MD_CTX *ctx)
{
    return ctx->md_data;
}

int (*EVP_MD_CTX_update_fn(EVP_MD_CTX *ctx))(EVP_MD_CTX *ctx,
                                             const void *data, size_t count)
{
    return ctx->update;
}

void EVP_MD_CTX_set_update_fn(EVP_MD_CTX *ctx,
                              int (*update) (EVP_MD_CTX *ctx,
                                             const void *data, size_t count))
{
    ctx->update = update;
}

void EVP_MD_CTX_set_flags(EVP_MD_CTX *ctx, int flags)
{
    ctx->flags |= flags;
}

void EVP_MD_CTX_clear_flags(EVP_MD_CTX *ctx, int flags)
{
    ctx->flags &= ~flags;
}

int EVP_MD_CTX_test_flags(const EVP_MD_CTX *ctx, int flags)
{
    return (ctx->flags & flags);
}

void EVP_CIPHER_CTX_set_flags(EVP_CIPHER_CTX *ctx, int flags)
{
    ctx->flags |= flags;
}

void EVP_CIPHER_CTX_clear_flags(EVP_CIPHER_CTX *ctx, int flags)
{
    ctx->flags &= ~flags;
}

int EVP_CIPHER_CTX_test_flags(const EVP_CIPHER_CTX *ctx, int flags)
{
    return (ctx->flags & flags);
}

Coverage Report

Created: 2023-06-08 06:40

Line	Count	Source (jump to first uncovered line)
1		/*
2		* Copyright 1995-2019 The OpenSSL Project Authors. All Rights Reserved.
3		*
4		* Licensed under the OpenSSL license (the "License"). You may not use
5		* this file except in compliance with the License. You can obtain a copy
6		* in the file LICENSE in the source distribution or at
7		* https://www.openssl.org/source/license.html
8		*/
9
10		#include <stdio.h>
11		#include "internal/cryptlib.h"
12		#include <openssl/evp.h>
13		#include <openssl/objects.h>
14		#include "crypto/evp.h"
15		#include "evp_local.h"
16
17		int EVP_CIPHER_param_to_asn1(EVP_CIPHER_CTX c, ASN1_TYPE type)
18	0	{
19	0	int ret;
20
21	0	if (c->cipher->set_asn1_parameters != NULL)
22	0	ret = c->cipher->set_asn1_parameters(c, type);
23	0	else if (c->cipher->flags & EVP_CIPH_FLAG_DEFAULT_ASN1) {
24	0	switch (EVP_CIPHER_CTX_mode(c)) {
25	0	case EVP_CIPH_WRAP_MODE:
26	0	if (EVP_CIPHER_CTX_nid(c) == NID_id_smime_alg_CMS3DESwrap)
27	0	ASN1_TYPE_set(type, V_ASN1_NULL, NULL);
28	0	ret = 1;
29	0	break;
30
31	0	case EVP_CIPH_GCM_MODE:
32	0	case EVP_CIPH_CCM_MODE:
33	0	case EVP_CIPH_XTS_MODE:
34	0	case EVP_CIPH_OCB_MODE:
35	0	ret = -2;
36	0	break;
37
38	0	default:
39	0	ret = EVP_CIPHER_set_asn1_iv(c, type);
40	0	}
41	0	} else
42	0	ret = -1;
43	0	if (ret <= 0)
44	0	EVPerr(EVP_F_EVP_CIPHER_PARAM_TO_ASN1, ret == -2 ?
45	0	ASN1_R_UNSUPPORTED_CIPHER :
46	0	EVP_R_CIPHER_PARAMETER_ERROR);
47	0	if (ret < -1)
48	0	ret = -1;
49	0	return ret;
50	0	}
51
52		int EVP_CIPHER_asn1_to_param(EVP_CIPHER_CTX c, ASN1_TYPE type)
53	0	{
54	0	int ret;
55
56	0	if (c->cipher->get_asn1_parameters != NULL)
57	0	ret = c->cipher->get_asn1_parameters(c, type);
58	0	else if (c->cipher->flags & EVP_CIPH_FLAG_DEFAULT_ASN1) {
59	0	switch (EVP_CIPHER_CTX_mode(c)) {
60
61	0	case EVP_CIPH_WRAP_MODE:
62	0	ret = 1;
63	0	break;
64
65	0	case EVP_CIPH_GCM_MODE:
66	0	case EVP_CIPH_CCM_MODE:
67	0	case EVP_CIPH_XTS_MODE:
68	0	case EVP_CIPH_OCB_MODE:
69	0	ret = -2;
70	0	break;
71
72	0	default:
73	0	ret = EVP_CIPHER_get_asn1_iv(c, type);
74	0	break;
75	0	}
76	0	} else
77	0	ret = -1;
78	0	if (ret <= 0)
79	0	EVPerr(EVP_F_EVP_CIPHER_ASN1_TO_PARAM, ret == -2 ?
80	0	EVP_R_UNSUPPORTED_CIPHER :
81	0	EVP_R_CIPHER_PARAMETER_ERROR);
82	0	if (ret < -1)
83	0	ret = -1;
84	0	return ret;
85	0	}
86
87		int EVP_CIPHER_get_asn1_iv(EVP_CIPHER_CTX c, ASN1_TYPE type)
88	0	{
89	0	int i = 0;
90	0	unsigned int l;
91
92	0	if (type != NULL) {
93	0	l = EVP_CIPHER_CTX_iv_length(c);
94	0	OPENSSL_assert(l <= sizeof(c->iv));
95	0	i = ASN1_TYPE_get_octetstring(type, c->oiv, l);
96	0	if (i != (int)l)
97	0	return -1;
98	0	else if (i > 0)
99	0	memcpy(c->iv, c->oiv, l);
100	0	}
101	0	return i;
102	0	}
103
104		int EVP_CIPHER_set_asn1_iv(EVP_CIPHER_CTX c, ASN1_TYPE type)
105	0	{
106	0	int i = 0;
107	0	unsigned int j;
108
109	0	if (type != NULL) {
110	0	j = EVP_CIPHER_CTX_iv_length(c);
111	0	OPENSSL_assert(j <= sizeof(c->iv));
112	0	i = ASN1_TYPE_set_octetstring(type, c->oiv, j);
113	0	}
114	0	return i;
115	0	}
116
117		/* Convert the various cipher NIDs and dummies to a proper OID NID */
118		int EVP_CIPHER_type(const EVP_CIPHER *ctx)
119	0	{
120	0	int nid;
121	0	ASN1_OBJECT *otmp;
122	0	nid = EVP_CIPHER_nid(ctx);
123
124	0	switch (nid) {
125
126	0	case NID_rc2_cbc:
127	0	case NID_rc2_64_cbc:
128	0	case NID_rc2_40_cbc:
129
130	0	return NID_rc2_cbc;
131
132	0	case NID_rc4:
133	0	case NID_rc4_40:
134
135	0	return NID_rc4;
136
137	0	case NID_aes_128_cfb128:
138	0	case NID_aes_128_cfb8:
139	0	case NID_aes_128_cfb1:
140
141	0	return NID_aes_128_cfb128;
142
143	0	case NID_aes_192_cfb128:
144	0	case NID_aes_192_cfb8:
145	0	case NID_aes_192_cfb1:
146
147	0	return NID_aes_192_cfb128;
148
149	0	case NID_aes_256_cfb128:
150	0	case NID_aes_256_cfb8:
151	0	case NID_aes_256_cfb1:
152
153	0	return NID_aes_256_cfb128;
154
155	0	case NID_des_cfb64:
156	0	case NID_des_cfb8:
157	0	case NID_des_cfb1:
158
159	0	return NID_des_cfb64;
160
161	0	case NID_des_ede3_cfb64:
162	0	case NID_des_ede3_cfb8:
163	0	case NID_des_ede3_cfb1:
164
165	0	return NID_des_cfb64;
166
167	0	default:
168		/* Check it has an OID and it is valid */
169	0	otmp = OBJ_nid2obj(nid);
170	0	if (OBJ_get0_data(otmp) == NULL)
171	0	nid = NID_undef;
172	0	ASN1_OBJECT_free(otmp);
173	0	return nid;
174	0	}
175	0	}
176
177		int EVP_CIPHER_block_size(const EVP_CIPHER *e)
178	0	{
179	0	return e->block_size;
180	0	}
181
182		int EVP_CIPHER_CTX_block_size(const EVP_CIPHER_CTX *ctx)
183	0	{
184	0	return ctx->cipher->block_size;
185	0	}
186
187		int EVP_CIPHER_impl_ctx_size(const EVP_CIPHER *e)
188	0	{
189	0	return e->ctx_size;
190	0	}
191
192		int EVP_Cipher(EVP_CIPHER_CTX ctx, unsigned char out,
193		const unsigned char *in, unsigned int inl)
194	0	{
195	0	return ctx->cipher->do_cipher(ctx, out, in, inl);
196	0	}
197
198		const EVP_CIPHER EVP_CIPHER_CTX_cipher(const EVP_CIPHER_CTX ctx)
199	0	{
200	0	return ctx->cipher;
201	0	}
202
203		int EVP_CIPHER_CTX_encrypting(const EVP_CIPHER_CTX *ctx)
204	0	{
205	0	return ctx->encrypt;
206	0	}
207
208		unsigned long EVP_CIPHER_flags(const EVP_CIPHER *cipher)
209	0	{
210	0	return cipher->flags;
211	0	}
212
213		void EVP_CIPHER_CTX_get_app_data(const EVP_CIPHER_CTX ctx)
214	0	{
215	0	return ctx->app_data;
216	0	}
217
218		void EVP_CIPHER_CTX_set_app_data(EVP_CIPHER_CTX ctx, void data)
219	0	{
220	0	ctx->app_data = data;
221	0	}
222
223		void EVP_CIPHER_CTX_get_cipher_data(const EVP_CIPHER_CTX ctx)
224	0	{
225	0	return ctx->cipher_data;
226	0	}
227
228		void EVP_CIPHER_CTX_set_cipher_data(EVP_CIPHER_CTX ctx, void *cipher_data)
229	0	{
230	0	void *old_cipher_data;
231
232	0	old_cipher_data = ctx->cipher_data;
233	0	ctx->cipher_data = cipher_data;
234
235	0	return old_cipher_data;
236	0	}
237
238		int EVP_CIPHER_iv_length(const EVP_CIPHER *cipher)
239	0	{
240	0	return cipher->iv_len;
241	0	}
242
243		int EVP_CIPHER_CTX_iv_length(const EVP_CIPHER_CTX *ctx)
244	0	{
245	0	int i, rv;
246
247	0	if ((EVP_CIPHER_flags(ctx->cipher) & EVP_CIPH_CUSTOM_IV_LENGTH) != 0) {
248	0	rv = EVP_CIPHER_CTX_ctrl((EVP_CIPHER_CTX *)ctx, EVP_CTRL_GET_IVLEN,
249	0	0, &i);
250	0	return (rv == 1) ? i : -1;
251	0	}
252	0	return ctx->cipher->iv_len;
253	0	}
254
255		const unsigned char EVP_CIPHER_CTX_original_iv(const EVP_CIPHER_CTX ctx)
256	0	{
257	0	return ctx->oiv;
258	0	}
259
260		const unsigned char EVP_CIPHER_CTX_iv(const EVP_CIPHER_CTX ctx)
261	0	{
262	0	return ctx->iv;
263	0	}
264
265		unsigned char EVP_CIPHER_CTX_iv_noconst(EVP_CIPHER_CTX ctx)
266	0	{
267	0	return ctx->iv;
268	0	}
269
270		unsigned char EVP_CIPHER_CTX_buf_noconst(EVP_CIPHER_CTX ctx)
271	0	{
272	0	return ctx->buf;
273	0	}
274
275		int EVP_CIPHER_CTX_num(const EVP_CIPHER_CTX *ctx)
276	0	{
277	0	return ctx->num;
278	0	}
279
280		void EVP_CIPHER_CTX_set_num(EVP_CIPHER_CTX *ctx, int num)
281	0	{
282	0	ctx->num = num;
283	0	}
284
285		int EVP_CIPHER_key_length(const EVP_CIPHER *cipher)
286	0	{
287	0	return cipher->key_len;
288	0	}
289
290		int EVP_CIPHER_CTX_key_length(const EVP_CIPHER_CTX *ctx)
291	0	{
292	0	return ctx->key_len;
293	0	}
294
295		int EVP_CIPHER_nid(const EVP_CIPHER *cipher)
296	0	{
297	0	return cipher->nid;
298	0	}
299
300		int EVP_CIPHER_CTX_nid(const EVP_CIPHER_CTX *ctx)
301	0	{
302	0	return ctx->cipher->nid;
303	0	}
304
305		int EVP_MD_block_size(const EVP_MD *md)
306	0	{
307	0	return md->block_size;
308	0	}
309
310		int EVP_MD_type(const EVP_MD *md)
311	0	{
312	0	return md->type;
313	0	}
314
315		int EVP_MD_pkey_type(const EVP_MD *md)
316	0	{
317	0	return md->pkey_type;
318	0	}
319
320		int EVP_MD_size(const EVP_MD *md)
321	0	{
322	0	if (!md) {
323	0	EVPerr(EVP_F_EVP_MD_SIZE, EVP_R_MESSAGE_DIGEST_IS_NULL);
324	0	return -1;
325	0	}
326	0	return md->md_size;
327	0	}
328
329		unsigned long EVP_MD_flags(const EVP_MD *md)
330	0	{
331	0	return md->flags;
332	0	}
333
334		EVP_MD *EVP_MD_meth_new(int md_type, int pkey_type)
335	0	{
336	0	EVP_MD md = OPENSSL_zalloc(sizeof(md));
337
338	0	if (md != NULL) {
339	0	md->type = md_type;
340	0	md->pkey_type = pkey_type;
341	0	}
342	0	return md;
343	0	}
344		EVP_MD EVP_MD_meth_dup(const EVP_MD md)
345	0	{
346	0	EVP_MD *to = EVP_MD_meth_new(md->type, md->pkey_type);
347
348	0	if (to != NULL)
349	0	memcpy(to, md, sizeof(*to));
350	0	return to;
351	0	}
352		void EVP_MD_meth_free(EVP_MD *md)
353	0	{
354	0	OPENSSL_free(md);
355	0	}
356		int EVP_MD_meth_set_input_blocksize(EVP_MD *md, int blocksize)
357	0	{
358	0	md->block_size = blocksize;
359	0	return 1;
360	0	}
361		int EVP_MD_meth_set_result_size(EVP_MD *md, int resultsize)
362	0	{
363	0	md->md_size = resultsize;
364	0	return 1;
365	0	}
366		int EVP_MD_meth_set_app_datasize(EVP_MD *md, int datasize)
367	0	{
368	0	md->ctx_size = datasize;
369	0	return 1;
370	0	}
371		int EVP_MD_meth_set_flags(EVP_MD *md, unsigned long flags)
372	0	{
373	0	md->flags = flags;
374	0	return 1;
375	0	}
376		int EVP_MD_meth_set_init(EVP_MD md, int (init)(EVP_MD_CTX *ctx))
377	0	{
378	0	md->init = init;
379	0	return 1;
380	0	}
381		int EVP_MD_meth_set_update(EVP_MD md, int (update)(EVP_MD_CTX *ctx,
382		const void *data,
383		size_t count))
384	0	{
385	0	md->update = update;
386	0	return 1;
387	0	}
388		int EVP_MD_meth_set_final(EVP_MD md, int (final)(EVP_MD_CTX *ctx,
389		unsigned char *md))
390	0	{
391	0	md->final = final;
392	0	return 1;
393	0	}
394		int EVP_MD_meth_set_copy(EVP_MD md, int (copy)(EVP_MD_CTX *to,
395		const EVP_MD_CTX *from))
396	0	{
397	0	md->copy = copy;
398	0	return 1;
399	0	}
400		int EVP_MD_meth_set_cleanup(EVP_MD md, int (cleanup)(EVP_MD_CTX *ctx))
401	0	{
402	0	md->cleanup = cleanup;
403	0	return 1;
404	0	}
405		int EVP_MD_meth_set_ctrl(EVP_MD md, int (ctrl)(EVP_MD_CTX *ctx, int cmd,
406		int p1, void *p2))
407	0	{
408	0	md->md_ctrl = ctrl;
409	0	return 1;
410	0	}
411
412		int EVP_MD_meth_get_input_blocksize(const EVP_MD *md)
413	0	{
414	0	return md->block_size;
415	0	}
416		int EVP_MD_meth_get_result_size(const EVP_MD *md)
417	0	{
418	0	return md->md_size;
419	0	}
420		int EVP_MD_meth_get_app_datasize(const EVP_MD *md)
421	0	{
422	0	return md->ctx_size;
423	0	}
424		unsigned long EVP_MD_meth_get_flags(const EVP_MD *md)
425	0	{
426	0	return md->flags;
427	0	}
428		int (EVP_MD_meth_get_init(const EVP_MD md))(EVP_MD_CTX *ctx)
429	0	{
430	0	return md->init;
431	0	}
432		int (EVP_MD_meth_get_update(const EVP_MD md))(EVP_MD_CTX *ctx,
433		const void *data,
434		size_t count)
435	0	{
436	0	return md->update;
437	0	}
438		int (EVP_MD_meth_get_final(const EVP_MD md))(EVP_MD_CTX *ctx,
439		unsigned char *md)
440	0	{
441	0	return md->final;
442	0	}
443		int (EVP_MD_meth_get_copy(const EVP_MD md))(EVP_MD_CTX *to,
444		const EVP_MD_CTX *from)
445	0	{
446	0	return md->copy;
447	0	}
448		int (EVP_MD_meth_get_cleanup(const EVP_MD md))(EVP_MD_CTX *ctx)
449	0	{
450	0	return md->cleanup;
451	0	}
452		int (EVP_MD_meth_get_ctrl(const EVP_MD md))(EVP_MD_CTX *ctx, int cmd,
453		int p1, void *p2)
454	0	{
455	0	return md->md_ctrl;
456	0	}
457
458		const EVP_MD EVP_MD_CTX_md(const EVP_MD_CTX ctx)
459	0	{
460	0	if (!ctx)
461	0	return NULL;
462	0	return ctx->digest;
463	0	}
464
465		EVP_PKEY_CTX EVP_MD_CTX_pkey_ctx(const EVP_MD_CTX ctx)
466	0	{
467	0	return ctx->pctx;
468	0	}
469
470		void EVP_MD_CTX_set_pkey_ctx(EVP_MD_CTX ctx, EVP_PKEY_CTX pctx)
471	0	{
472		/*
473		* it's reasonable to set NULL pctx (a.k.a clear the ctx->pctx), so
474		* we have to deal with the cleanup job here.
475		*/
476	0	if (!EVP_MD_CTX_test_flags(ctx, EVP_MD_CTX_FLAG_KEEP_PKEY_CTX))
477	0	EVP_PKEY_CTX_free(ctx->pctx);
478
479	0	ctx->pctx = pctx;
480
481	0	if (pctx != NULL) {
482		/* make sure pctx is not freed when destroying EVP_MD_CTX */
483	0	EVP_MD_CTX_set_flags(ctx, EVP_MD_CTX_FLAG_KEEP_PKEY_CTX);
484	0	} else {
485	0	EVP_MD_CTX_clear_flags(ctx, EVP_MD_CTX_FLAG_KEEP_PKEY_CTX);
486	0	}
487	0	}
488
489		void EVP_MD_CTX_md_data(const EVP_MD_CTX ctx)
490	0	{
491	0	return ctx->md_data;
492	0	}
493
494		int (EVP_MD_CTX_update_fn(EVP_MD_CTX ctx))(EVP_MD_CTX *ctx,
495		const void *data, size_t count)
496	0	{
497	0	return ctx->update;
498	0	}
499
500		void EVP_MD_CTX_set_update_fn(EVP_MD_CTX *ctx,
501		int (update) (EVP_MD_CTX ctx,
502		const void *data, size_t count))
503	0	{
504	0	ctx->update = update;
505	0	}
506
507		void EVP_MD_CTX_set_flags(EVP_MD_CTX *ctx, int flags)
508	0	{
509	0	ctx->flags \|= flags;
510	0	}
511
512		void EVP_MD_CTX_clear_flags(EVP_MD_CTX *ctx, int flags)
513	0	{
514	0	ctx->flags &= ~flags;
515	0	}
516
517		int EVP_MD_CTX_test_flags(const EVP_MD_CTX *ctx, int flags)
518	0	{
519	0	return (ctx->flags & flags);
520	0	}
521
522		void EVP_CIPHER_CTX_set_flags(EVP_CIPHER_CTX *ctx, int flags)
523	0	{
524	0	ctx->flags \|= flags;
525	0	}
526
527		void EVP_CIPHER_CTX_clear_flags(EVP_CIPHER_CTX *ctx, int flags)
528	0	{
529	0	ctx->flags &= ~flags;
530	0	}
531
532		int EVP_CIPHER_CTX_test_flags(const EVP_CIPHER_CTX *ctx, int flags)
533	0	{
534	0	return (ctx->flags & flags);
535	0	}