/src/openssl/crypto/evp/evp_lib.c

Source (jump to first uncovered line)
/*
 * Copyright 1995-2018 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 "internal/evp_int.h"
#include "evp_locl.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)
{
    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_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: 2018-08-29 13:53

Line	Count	Source (jump to first uncovered line)
1		/*
2		* Copyright 1995-2018 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 "internal/evp_int.h"
15		#include "evp_locl.h"
16
17		int EVP_CIPHER_param_to_asn1(EVP_CIPHER_CTX c, ASN1_TYPE type)
18	0	{
19	0	int ret;
20	0
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	0
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	0
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	0
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	0
61	0	case EVP_CIPH_WRAP_MODE:
62	0	ret = 1;
63	0	break;
64	0
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	0
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	0
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	0
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	0
124	0	switch (nid) {
125	0
126	0	case NID_rc2_cbc:
127	0	case NID_rc2_64_cbc:
128	0	case NID_rc2_40_cbc:
129	0
130	0	return NID_rc2_cbc;
131	0
132	0	case NID_rc4:
133	0	case NID_rc4_40:
134	0
135	0	return NID_rc4;
136	0
137	0	case NID_aes_128_cfb128:
138	0	case NID_aes_128_cfb8:
139	0	case NID_aes_128_cfb1:
140	0
141	0	return NID_aes_128_cfb128;
142	0
143	0	case NID_aes_192_cfb128:
144	0	case NID_aes_192_cfb8:
145	0	case NID_aes_192_cfb1:
146	0
147	0	return NID_aes_192_cfb128;
148	0
149	0	case NID_aes_256_cfb128:
150	0	case NID_aes_256_cfb8:
151	0	case NID_aes_256_cfb1:
152	0
153	0	return NID_aes_256_cfb128;
154	0
155	0	case NID_des_cfb64:
156	0	case NID_des_cfb8:
157	0	case NID_des_cfb1:
158	0
159	0	return NID_des_cfb64;
160	0
161	0	case NID_des_ede3_cfb64:
162	0	case NID_des_ede3_cfb8:
163	0	case NID_des_ede3_cfb1:
164	0
165	0	return NID_des_cfb64;
166	0
167	0	default:
168	0	/* 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	0
232	0	old_cipher_data = ctx->cipher_data;
233	0	ctx->cipher_data = cipher_data;
234	0
235	0	return old_cipher_data;
236	0	}
237
238		int EVP_CIPHER_iv_length(const EVP_CIPHER *cipher)
239	4.26k	{
240	4.26k	return cipher->iv_len;
241	4.26k	}
242
243		int EVP_CIPHER_CTX_iv_length(const EVP_CIPHER_CTX *ctx)
244	0	{
245	0	return ctx->cipher->iv_len;
246	0	}
247
248		const unsigned char EVP_CIPHER_CTX_original_iv(const EVP_CIPHER_CTX ctx)
249	0	{
250	0	return ctx->oiv;
251	0	}
252
253		const unsigned char EVP_CIPHER_CTX_iv(const EVP_CIPHER_CTX ctx)
254	0	{
255	0	return ctx->iv;
256	0	}
257
258		unsigned char EVP_CIPHER_CTX_iv_noconst(EVP_CIPHER_CTX ctx)
259	0	{
260	0	return ctx->iv;
261	0	}
262
263		unsigned char EVP_CIPHER_CTX_buf_noconst(EVP_CIPHER_CTX ctx)
264	0	{
265	0	return ctx->buf;
266	0	}
267
268		int EVP_CIPHER_CTX_num(const EVP_CIPHER_CTX *ctx)
269	0	{
270	0	return ctx->num;
271	0	}
272
273		void EVP_CIPHER_CTX_set_num(EVP_CIPHER_CTX *ctx, int num)
274	0	{
275	0	ctx->num = num;
276	0	}
277
278		int EVP_CIPHER_key_length(const EVP_CIPHER *cipher)
279	0	{
280	0	return cipher->key_len;
281	0	}
282
283		int EVP_CIPHER_CTX_key_length(const EVP_CIPHER_CTX *ctx)
284	0	{
285	0	return ctx->key_len;
286	0	}
287
288		int EVP_CIPHER_nid(const EVP_CIPHER *cipher)
289	0	{
290	0	return cipher->nid;
291	0	}
292
293		int EVP_CIPHER_CTX_nid(const EVP_CIPHER_CTX *ctx)
294	0	{
295	0	return ctx->cipher->nid;
296	0	}
297
298		int EVP_MD_block_size(const EVP_MD *md)
299	0	{
300	0	return md->block_size;
301	0	}
302
303		int EVP_MD_type(const EVP_MD *md)
304	0	{
305	0	return md->type;
306	0	}
307
308		int EVP_MD_pkey_type(const EVP_MD *md)
309	0	{
310	0	return md->pkey_type;
311	0	}
312
313		int EVP_MD_size(const EVP_MD *md)
314	0	{
315	0	if (!md) {
316	0	EVPerr(EVP_F_EVP_MD_SIZE, EVP_R_MESSAGE_DIGEST_IS_NULL);
317	0	return -1;
318	0	}
319	0	return md->md_size;
320	0	}
321
322		unsigned long EVP_MD_flags(const EVP_MD *md)
323	0	{
324	0	return md->flags;
325	0	}
326
327		EVP_MD *EVP_MD_meth_new(int md_type, int pkey_type)
328	0	{
329	0	EVP_MD md = OPENSSL_zalloc(sizeof(md));
330	0
331	0	if (md != NULL) {
332	0	md->type = md_type;
333	0	md->pkey_type = pkey_type;
334	0	}
335	0	return md;
336	0	}
337		EVP_MD EVP_MD_meth_dup(const EVP_MD md)
338	0	{
339	0	EVP_MD *to = EVP_MD_meth_new(md->type, md->pkey_type);
340	0
341	0	if (to != NULL)
342	0	memcpy(to, md, sizeof(*to));
343	0	return to;
344	0	}
345		void EVP_MD_meth_free(EVP_MD *md)
346	0	{
347	0	OPENSSL_free(md);
348	0	}
349		int EVP_MD_meth_set_input_blocksize(EVP_MD *md, int blocksize)
350	0	{
351	0	md->block_size = blocksize;
352	0	return 1;
353	0	}
354		int EVP_MD_meth_set_result_size(EVP_MD *md, int resultsize)
355	0	{
356	0	md->md_size = resultsize;
357	0	return 1;
358	0	}
359		int EVP_MD_meth_set_app_datasize(EVP_MD *md, int datasize)
360	0	{
361	0	md->ctx_size = datasize;
362	0	return 1;
363	0	}
364		int EVP_MD_meth_set_flags(EVP_MD *md, unsigned long flags)
365	0	{
366	0	md->flags = flags;
367	0	return 1;
368	0	}
369		int EVP_MD_meth_set_init(EVP_MD md, int (init)(EVP_MD_CTX *ctx))
370	0	{
371	0	md->init = init;
372	0	return 1;
373	0	}
374		int EVP_MD_meth_set_update(EVP_MD md, int (update)(EVP_MD_CTX *ctx,
375		const void *data,
376		size_t count))
377	0	{
378	0	md->update = update;
379	0	return 1;
380	0	}
381		int EVP_MD_meth_set_final(EVP_MD md, int (final)(EVP_MD_CTX *ctx,
382		unsigned char *md))
383	0	{
384	0	md->final = final;
385	0	return 1;
386	0	}
387		int EVP_MD_meth_set_copy(EVP_MD md, int (copy)(EVP_MD_CTX *to,
388		const EVP_MD_CTX *from))
389	0	{
390	0	md->copy = copy;
391	0	return 1;
392	0	}
393		int EVP_MD_meth_set_cleanup(EVP_MD md, int (cleanup)(EVP_MD_CTX *ctx))
394	0	{
395	0	md->cleanup = cleanup;
396	0	return 1;
397	0	}
398		int EVP_MD_meth_set_ctrl(EVP_MD md, int (ctrl)(EVP_MD_CTX *ctx, int cmd,
399		int p1, void *p2))
400	0	{
401	0	md->md_ctrl = ctrl;
402	0	return 1;
403	0	}
404
405		int EVP_MD_meth_get_input_blocksize(const EVP_MD *md)
406	0	{
407	0	return md->block_size;
408	0	}
409		int EVP_MD_meth_get_result_size(const EVP_MD *md)
410	0	{
411	0	return md->md_size;
412	0	}
413		int EVP_MD_meth_get_app_datasize(const EVP_MD *md)
414	0	{
415	0	return md->ctx_size;
416	0	}
417		unsigned long EVP_MD_meth_get_flags(const EVP_MD *md)
418	0	{
419	0	return md->flags;
420	0	}
421		int (EVP_MD_meth_get_init(const EVP_MD md))(EVP_MD_CTX *ctx)
422	0	{
423	0	return md->init;
424	0	}
425		int (EVP_MD_meth_get_update(const EVP_MD md))(EVP_MD_CTX *ctx,
426		const void *data,
427		size_t count)
428	0	{
429	0	return md->update;
430	0	}
431		int (EVP_MD_meth_get_final(const EVP_MD md))(EVP_MD_CTX *ctx,
432		unsigned char *md)
433	0	{
434	0	return md->final;
435	0	}
436		int (EVP_MD_meth_get_copy(const EVP_MD md))(EVP_MD_CTX *to,
437		const EVP_MD_CTX *from)
438	0	{
439	0	return md->copy;
440	0	}
441		int (EVP_MD_meth_get_cleanup(const EVP_MD md))(EVP_MD_CTX *ctx)
442	0	{
443	0	return md->cleanup;
444	0	}
445		int (EVP_MD_meth_get_ctrl(const EVP_MD md))(EVP_MD_CTX *ctx, int cmd,
446		int p1, void *p2)
447	0	{
448	0	return md->md_ctrl;
449	0	}
450
451		const EVP_MD EVP_MD_CTX_md(const EVP_MD_CTX ctx)
452	0	{
453	0	if (!ctx)
454	0	return NULL;
455	0	return ctx->digest;
456	0	}
457
458		EVP_PKEY_CTX EVP_MD_CTX_pkey_ctx(const EVP_MD_CTX ctx)
459	0	{
460	0	return ctx->pctx;
461	0	}
462
463		void EVP_MD_CTX_md_data(const EVP_MD_CTX ctx)
464	0	{
465	0	return ctx->md_data;
466	0	}
467
468		int (EVP_MD_CTX_update_fn(EVP_MD_CTX ctx))(EVP_MD_CTX *ctx,
469		const void *data, size_t count)
470	0	{
471	0	return ctx->update;
472	0	}
473
474		void EVP_MD_CTX_set_update_fn(EVP_MD_CTX *ctx,
475		int (update) (EVP_MD_CTX ctx,
476		const void *data, size_t count))
477	0	{
478	0	ctx->update = update;
479	0	}
480
481		void EVP_MD_CTX_set_flags(EVP_MD_CTX *ctx, int flags)
482	0	{
483	0	ctx->flags \|= flags;
484	0	}
485
486		void EVP_MD_CTX_clear_flags(EVP_MD_CTX *ctx, int flags)
487	0	{
488	0	ctx->flags &= ~flags;
489	0	}
490
491		int EVP_MD_CTX_test_flags(const EVP_MD_CTX *ctx, int flags)
492	0	{
493	0	return (ctx->flags & flags);
494	0	}
495
496		void EVP_CIPHER_CTX_set_flags(EVP_CIPHER_CTX *ctx, int flags)
497	0	{
498	0	ctx->flags \|= flags;
499	0	}
500
501		void EVP_CIPHER_CTX_clear_flags(EVP_CIPHER_CTX *ctx, int flags)
502	0	{
503	0	ctx->flags &= ~flags;
504	0	}
505
506		int EVP_CIPHER_CTX_test_flags(const EVP_CIPHER_CTX *ctx, int flags)
507	0	{
508	0	return (ctx->flags & flags);
509	0	}