2016-05-18 02:24:46 +08:00
|
|
|
/*
|
2018-06-20 22:25:43 +08:00
|
|
|
* Copyright 1995-2018 The OpenSSL Project Authors. All Rights Reserved.
|
1998-12-21 18:56:39 +08:00
|
|
|
*
|
2016-05-18 02:24:46 +08:00
|
|
|
* 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
|
1998-12-21 18:56:39 +08:00
|
|
|
*/
|
|
|
|
|
|
|
|
#include <stdio.h>
|
2015-05-14 22:56:48 +08:00
|
|
|
#include "internal/cryptlib.h"
|
1999-04-24 06:13:45 +08:00
|
|
|
#include <openssl/evp.h>
|
|
|
|
#include <openssl/objects.h>
|
2015-11-30 03:09:34 +08:00
|
|
|
#include "internal/evp_int.h"
|
2015-11-27 20:35:02 +08:00
|
|
|
#include "evp_locl.h"
|
1998-12-21 18:56:39 +08:00
|
|
|
|
1999-04-20 05:31:43 +08:00
|
|
|
int EVP_CIPHER_param_to_asn1(EVP_CIPHER_CTX *c, ASN1_TYPE *type)
|
2015-01-22 11:40:55 +08:00
|
|
|
{
|
|
|
|
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) {
|
2015-08-01 22:38:11 +08:00
|
|
|
switch (EVP_CIPHER_CTX_mode(c)) {
|
|
|
|
case EVP_CIPH_WRAP_MODE:
|
2015-10-13 04:14:04 +08:00
|
|
|
if (EVP_CIPHER_CTX_nid(c) == NID_id_smime_alg_CMS3DESwrap)
|
|
|
|
ASN1_TYPE_set(type, V_ASN1_NULL, NULL);
|
2015-01-22 11:40:55 +08:00
|
|
|
ret = 1;
|
2015-08-01 22:38:11 +08:00
|
|
|
break;
|
|
|
|
|
|
|
|
case EVP_CIPH_GCM_MODE:
|
|
|
|
case EVP_CIPH_CCM_MODE:
|
|
|
|
case EVP_CIPH_XTS_MODE:
|
|
|
|
case EVP_CIPH_OCB_MODE:
|
2018-05-11 03:14:12 +08:00
|
|
|
ret = -2;
|
2015-08-01 22:38:11 +08:00
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
2015-01-22 11:40:55 +08:00
|
|
|
ret = EVP_CIPHER_set_asn1_iv(c, type);
|
2015-08-01 22:38:11 +08:00
|
|
|
}
|
2015-01-22 11:40:55 +08:00
|
|
|
} else
|
|
|
|
ret = -1;
|
2018-05-11 03:14:12 +08:00
|
|
|
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;
|
2017-10-17 22:04:09 +08:00
|
|
|
return ret;
|
2015-01-22 11:40:55 +08:00
|
|
|
}
|
1998-12-21 18:56:39 +08:00
|
|
|
|
1999-04-20 05:31:43 +08:00
|
|
|
int EVP_CIPHER_asn1_to_param(EVP_CIPHER_CTX *c, ASN1_TYPE *type)
|
2015-01-22 11:40:55 +08:00
|
|
|
{
|
|
|
|
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) {
|
2015-08-01 22:38:11 +08:00
|
|
|
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:
|
2018-05-11 03:14:12 +08:00
|
|
|
ret = -2;
|
2015-08-01 22:38:11 +08:00
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
|
|
|
ret = EVP_CIPHER_get_asn1_iv(c, type);
|
|
|
|
break;
|
|
|
|
}
|
2015-01-22 11:40:55 +08:00
|
|
|
} else
|
|
|
|
ret = -1;
|
2018-05-11 03:14:12 +08:00
|
|
|
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;
|
2017-10-17 22:04:09 +08:00
|
|
|
return ret;
|
2015-01-22 11:40:55 +08:00
|
|
|
}
|
1998-12-21 18:56:39 +08:00
|
|
|
|
1999-04-20 05:31:43 +08:00
|
|
|
int EVP_CIPHER_get_asn1_iv(EVP_CIPHER_CTX *c, ASN1_TYPE *type)
|
2015-01-22 11:40:55 +08:00
|
|
|
{
|
|
|
|
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)
|
2017-10-17 22:04:09 +08:00
|
|
|
return -1;
|
2015-01-22 11:40:55 +08:00
|
|
|
else if (i > 0)
|
|
|
|
memcpy(c->iv, c->oiv, l);
|
|
|
|
}
|
2017-10-17 22:04:09 +08:00
|
|
|
return i;
|
2015-01-22 11:40:55 +08:00
|
|
|
}
|
1998-12-21 18:56:39 +08:00
|
|
|
|
1999-04-20 05:31:43 +08:00
|
|
|
int EVP_CIPHER_set_asn1_iv(EVP_CIPHER_CTX *c, ASN1_TYPE *type)
|
2015-01-22 11:40:55 +08:00
|
|
|
{
|
|
|
|
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);
|
|
|
|
}
|
2017-10-17 22:04:09 +08:00
|
|
|
return i;
|
2015-01-22 11:40:55 +08:00
|
|
|
}
|
1999-05-10 08:47:42 +08:00
|
|
|
|
|
|
|
/* Convert the various cipher NIDs and dummies to a proper OID NID */
|
1999-05-16 08:25:36 +08:00
|
|
|
int EVP_CIPHER_type(const EVP_CIPHER *ctx)
|
1999-05-10 08:47:42 +08:00
|
|
|
{
|
2015-01-22 11:40:55 +08:00
|
|
|
int nid;
|
|
|
|
ASN1_OBJECT *otmp;
|
|
|
|
nid = EVP_CIPHER_nid(ctx);
|
1999-05-10 08:47:42 +08:00
|
|
|
|
2015-01-22 11:40:55 +08:00
|
|
|
switch (nid) {
|
1999-05-10 08:47:42 +08:00
|
|
|
|
2015-01-22 11:40:55 +08:00
|
|
|
case NID_rc2_cbc:
|
|
|
|
case NID_rc2_64_cbc:
|
|
|
|
case NID_rc2_40_cbc:
|
1999-05-10 08:47:42 +08:00
|
|
|
|
2015-01-22 11:40:55 +08:00
|
|
|
return NID_rc2_cbc;
|
1999-05-10 08:47:42 +08:00
|
|
|
|
2015-01-22 11:40:55 +08:00
|
|
|
case NID_rc4:
|
|
|
|
case NID_rc4_40:
|
1999-05-10 08:47:42 +08:00
|
|
|
|
2015-01-22 11:40:55 +08:00
|
|
|
return NID_rc4;
|
1999-05-10 08:47:42 +08:00
|
|
|
|
2015-01-22 11:40:55 +08:00
|
|
|
case NID_aes_128_cfb128:
|
|
|
|
case NID_aes_128_cfb8:
|
|
|
|
case NID_aes_128_cfb1:
|
2004-01-29 03:05:35 +08:00
|
|
|
|
2015-01-22 11:40:55 +08:00
|
|
|
return NID_aes_128_cfb128;
|
2004-01-29 03:05:35 +08:00
|
|
|
|
2015-01-22 11:40:55 +08:00
|
|
|
case NID_aes_192_cfb128:
|
|
|
|
case NID_aes_192_cfb8:
|
|
|
|
case NID_aes_192_cfb1:
|
2004-01-29 03:05:35 +08:00
|
|
|
|
2015-01-22 11:40:55 +08:00
|
|
|
return NID_aes_192_cfb128;
|
2004-01-29 03:05:35 +08:00
|
|
|
|
2015-01-22 11:40:55 +08:00
|
|
|
case NID_aes_256_cfb128:
|
|
|
|
case NID_aes_256_cfb8:
|
|
|
|
case NID_aes_256_cfb1:
|
2004-01-29 03:05:35 +08:00
|
|
|
|
2015-01-22 11:40:55 +08:00
|
|
|
return NID_aes_256_cfb128;
|
2004-01-29 03:05:35 +08:00
|
|
|
|
2015-01-22 11:40:55 +08:00
|
|
|
case NID_des_cfb64:
|
|
|
|
case NID_des_cfb8:
|
|
|
|
case NID_des_cfb1:
|
2004-01-29 03:05:35 +08:00
|
|
|
|
2015-01-22 11:40:55 +08:00
|
|
|
return NID_des_cfb64;
|
2004-01-29 03:05:35 +08:00
|
|
|
|
2015-01-22 11:40:55 +08:00
|
|
|
case NID_des_ede3_cfb64:
|
|
|
|
case NID_des_ede3_cfb8:
|
|
|
|
case NID_des_ede3_cfb1:
|
2009-12-25 22:13:11 +08:00
|
|
|
|
2015-01-22 11:40:55 +08:00
|
|
|
return NID_des_cfb64;
|
2009-12-25 22:13:11 +08:00
|
|
|
|
2015-01-22 11:40:55 +08:00
|
|
|
default:
|
|
|
|
/* Check it has an OID and it is valid */
|
|
|
|
otmp = OBJ_nid2obj(nid);
|
2015-03-16 00:26:04 +08:00
|
|
|
if (OBJ_get0_data(otmp) == NULL)
|
2015-01-22 11:40:55 +08:00
|
|
|
nid = NID_undef;
|
|
|
|
ASN1_OBJECT_free(otmp);
|
|
|
|
return nid;
|
|
|
|
}
|
1999-05-10 08:47:42 +08:00
|
|
|
}
|
|
|
|
|
2008-11-12 11:58:08 +08:00
|
|
|
int EVP_CIPHER_block_size(const EVP_CIPHER *e)
|
2015-01-22 11:40:55 +08:00
|
|
|
{
|
|
|
|
return e->block_size;
|
|
|
|
}
|
2006-11-30 04:54:57 +08:00
|
|
|
|
2008-11-12 11:58:08 +08:00
|
|
|
int EVP_CIPHER_CTX_block_size(const EVP_CIPHER_CTX *ctx)
|
2015-01-22 11:40:55 +08:00
|
|
|
{
|
|
|
|
return ctx->cipher->block_size;
|
|
|
|
}
|
2006-11-30 04:54:57 +08:00
|
|
|
|
2015-12-18 23:37:02 +08:00
|
|
|
int EVP_CIPHER_impl_ctx_size(const EVP_CIPHER *e)
|
|
|
|
{
|
|
|
|
return e->ctx_size;
|
|
|
|
}
|
|
|
|
|
2015-01-22 11:40:55 +08:00
|
|
|
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);
|
|
|
|
}
|
2006-11-30 04:54:57 +08:00
|
|
|
|
|
|
|
const EVP_CIPHER *EVP_CIPHER_CTX_cipher(const EVP_CIPHER_CTX *ctx)
|
2015-01-22 11:40:55 +08:00
|
|
|
{
|
|
|
|
return ctx->cipher;
|
|
|
|
}
|
2006-11-30 04:54:57 +08:00
|
|
|
|
2015-12-14 04:25:42 +08:00
|
|
|
int EVP_CIPHER_CTX_encrypting(const EVP_CIPHER_CTX *ctx)
|
|
|
|
{
|
|
|
|
return ctx->encrypt;
|
|
|
|
}
|
|
|
|
|
2006-11-30 04:54:57 +08:00
|
|
|
unsigned long EVP_CIPHER_flags(const EVP_CIPHER *cipher)
|
2015-01-22 11:40:55 +08:00
|
|
|
{
|
|
|
|
return cipher->flags;
|
|
|
|
}
|
2006-11-30 04:54:57 +08:00
|
|
|
|
|
|
|
void *EVP_CIPHER_CTX_get_app_data(const EVP_CIPHER_CTX *ctx)
|
2015-01-22 11:40:55 +08:00
|
|
|
{
|
|
|
|
return ctx->app_data;
|
|
|
|
}
|
2006-11-30 04:54:57 +08:00
|
|
|
|
|
|
|
void EVP_CIPHER_CTX_set_app_data(EVP_CIPHER_CTX *ctx, void *data)
|
2015-01-22 11:40:55 +08:00
|
|
|
{
|
|
|
|
ctx->app_data = data;
|
|
|
|
}
|
2006-11-30 04:54:57 +08:00
|
|
|
|
2016-03-07 18:17:27 +08:00
|
|
|
void *EVP_CIPHER_CTX_get_cipher_data(const EVP_CIPHER_CTX *ctx)
|
2015-12-14 04:25:42 +08:00
|
|
|
{
|
|
|
|
return ctx->cipher_data;
|
|
|
|
}
|
|
|
|
|
2015-09-22 18:11:24 +08:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2008-11-12 11:58:08 +08:00
|
|
|
int EVP_CIPHER_iv_length(const EVP_CIPHER *cipher)
|
2015-01-22 11:40:55 +08:00
|
|
|
{
|
|
|
|
return cipher->iv_len;
|
|
|
|
}
|
2006-11-30 04:54:57 +08:00
|
|
|
|
2008-11-12 11:58:08 +08:00
|
|
|
int EVP_CIPHER_CTX_iv_length(const EVP_CIPHER_CTX *ctx)
|
2015-01-22 11:40:55 +08:00
|
|
|
{
|
|
|
|
return ctx->cipher->iv_len;
|
|
|
|
}
|
2006-11-30 04:54:57 +08:00
|
|
|
|
2015-12-14 04:25:42 +08:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2008-11-12 11:58:08 +08:00
|
|
|
int EVP_CIPHER_key_length(const EVP_CIPHER *cipher)
|
2015-01-22 11:40:55 +08:00
|
|
|
{
|
|
|
|
return cipher->key_len;
|
|
|
|
}
|
2006-11-30 04:54:57 +08:00
|
|
|
|
2008-11-12 11:58:08 +08:00
|
|
|
int EVP_CIPHER_CTX_key_length(const EVP_CIPHER_CTX *ctx)
|
2015-01-22 11:40:55 +08:00
|
|
|
{
|
|
|
|
return ctx->key_len;
|
|
|
|
}
|
2006-11-30 04:54:57 +08:00
|
|
|
|
|
|
|
int EVP_CIPHER_nid(const EVP_CIPHER *cipher)
|
2015-01-22 11:40:55 +08:00
|
|
|
{
|
|
|
|
return cipher->nid;
|
|
|
|
}
|
2006-11-30 04:54:57 +08:00
|
|
|
|
|
|
|
int EVP_CIPHER_CTX_nid(const EVP_CIPHER_CTX *ctx)
|
2015-01-22 11:40:55 +08:00
|
|
|
{
|
|
|
|
return ctx->cipher->nid;
|
|
|
|
}
|
2006-11-30 04:54:57 +08:00
|
|
|
|
2015-01-22 11:40:55 +08:00
|
|
|
int EVP_MD_block_size(const EVP_MD *md)
|
|
|
|
{
|
|
|
|
return md->block_size;
|
|
|
|
}
|
2006-11-30 04:54:57 +08:00
|
|
|
|
|
|
|
int EVP_MD_type(const EVP_MD *md)
|
2015-01-22 11:40:55 +08:00
|
|
|
{
|
|
|
|
return md->type;
|
|
|
|
}
|
2006-11-30 04:54:57 +08:00
|
|
|
|
|
|
|
int EVP_MD_pkey_type(const EVP_MD *md)
|
2015-01-22 11:40:55 +08:00
|
|
|
{
|
|
|
|
return md->pkey_type;
|
|
|
|
}
|
2006-11-30 04:54:57 +08:00
|
|
|
|
2008-11-12 11:58:08 +08:00
|
|
|
int EVP_MD_size(const EVP_MD *md)
|
2015-01-22 11:40:55 +08:00
|
|
|
{
|
|
|
|
if (!md) {
|
|
|
|
EVPerr(EVP_F_EVP_MD_SIZE, EVP_R_MESSAGE_DIGEST_IS_NULL);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
return md->md_size;
|
|
|
|
}
|
2006-11-30 04:54:57 +08:00
|
|
|
|
2009-04-15 23:27:03 +08:00
|
|
|
unsigned long EVP_MD_flags(const EVP_MD *md)
|
2015-01-22 11:40:55 +08:00
|
|
|
{
|
|
|
|
return md->flags;
|
|
|
|
}
|
2009-04-15 23:27:03 +08:00
|
|
|
|
2015-11-30 03:09:34 +08:00
|
|
|
EVP_MD *EVP_MD_meth_new(int md_type, int pkey_type)
|
|
|
|
{
|
2016-02-08 23:11:56 +08:00
|
|
|
EVP_MD *md = OPENSSL_zalloc(sizeof(*md));
|
|
|
|
|
2015-11-30 03:09:34 +08:00
|
|
|
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);
|
2016-02-08 23:11:56 +08:00
|
|
|
|
|
|
|
if (to != NULL)
|
2015-11-30 03:09:34 +08:00
|
|
|
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)
|
|
|
|
{
|
2016-12-22 22:06:59 +08:00
|
|
|
return md->flags;
|
2015-11-30 03:09:34 +08:00
|
|
|
}
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2006-11-30 04:54:57 +08:00
|
|
|
const EVP_MD *EVP_MD_CTX_md(const EVP_MD_CTX *ctx)
|
2015-01-22 11:40:55 +08:00
|
|
|
{
|
|
|
|
if (!ctx)
|
|
|
|
return NULL;
|
|
|
|
return ctx->digest;
|
|
|
|
}
|
2006-11-30 04:54:57 +08:00
|
|
|
|
2015-11-27 20:35:02 +08:00
|
|
|
EVP_PKEY_CTX *EVP_MD_CTX_pkey_ctx(const EVP_MD_CTX *ctx)
|
|
|
|
{
|
|
|
|
return ctx->pctx;
|
|
|
|
}
|
|
|
|
|
2018-09-03 23:56:41 +08:00
|
|
|
void EVP_MD_CTX_set_pkey_ctx(EVP_MD_CTX *ctx, EVP_PKEY_CTX *pctx)
|
|
|
|
{
|
2018-09-05 22:01:33 +08:00
|
|
|
/*
|
|
|
|
* 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);
|
|
|
|
|
2018-09-03 23:56:41 +08:00
|
|
|
ctx->pctx = pctx;
|
2018-09-05 22:01:33 +08:00
|
|
|
|
|
|
|
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);
|
|
|
|
}
|
2018-09-03 23:56:41 +08:00
|
|
|
}
|
|
|
|
|
2015-11-27 20:35:02 +08:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2006-11-30 04:54:57 +08:00
|
|
|
void EVP_MD_CTX_set_flags(EVP_MD_CTX *ctx, int flags)
|
2015-01-22 11:40:55 +08:00
|
|
|
{
|
|
|
|
ctx->flags |= flags;
|
|
|
|
}
|
2006-11-30 04:54:57 +08:00
|
|
|
|
|
|
|
void EVP_MD_CTX_clear_flags(EVP_MD_CTX *ctx, int flags)
|
2015-01-22 11:40:55 +08:00
|
|
|
{
|
|
|
|
ctx->flags &= ~flags;
|
|
|
|
}
|
2006-11-30 04:54:57 +08:00
|
|
|
|
|
|
|
int EVP_MD_CTX_test_flags(const EVP_MD_CTX *ctx, int flags)
|
2015-01-22 11:40:55 +08:00
|
|
|
{
|
|
|
|
return (ctx->flags & flags);
|
|
|
|
}
|
2010-01-26 22:29:06 +08:00
|
|
|
|
|
|
|
void EVP_CIPHER_CTX_set_flags(EVP_CIPHER_CTX *ctx, int flags)
|
2015-01-22 11:40:55 +08:00
|
|
|
{
|
|
|
|
ctx->flags |= flags;
|
|
|
|
}
|
2010-01-26 22:29:06 +08:00
|
|
|
|
|
|
|
void EVP_CIPHER_CTX_clear_flags(EVP_CIPHER_CTX *ctx, int flags)
|
2015-01-22 11:40:55 +08:00
|
|
|
{
|
|
|
|
ctx->flags &= ~flags;
|
|
|
|
}
|
2010-01-26 22:29:06 +08:00
|
|
|
|
|
|
|
int EVP_CIPHER_CTX_test_flags(const EVP_CIPHER_CTX *ctx, int flags)
|
2015-01-22 11:40:55 +08:00
|
|
|
{
|
|
|
|
return (ctx->flags & flags);
|
|
|
|
}
|