自学教程：C++ EVP_MD_CTX_size函数代码示例

static CK_RV sc_pkcs11_openssl_md_final(sc_pkcs11_operation_t *op,				CK_BYTE_PTR pDigest, CK_ULONG_PTR pulDigestLen){	EVP_MD_CTX	*md_ctx = DIGEST_CTX(op);	unsigned int len = *pulDigestLen;	if (len < EVP_MD_CTX_size(md_ctx)) {		*pulDigestLen = EVP_MD_CTX_size(md_ctx);		return CKR_BUFFER_TOO_SMALL;	}	EVP_DigestFinal(md_ctx, pDigest, &len);	*pulDigestLen = len;	return CKR_OK;}

static CK_RV sc_pkcs11_openssl_md_final(sc_pkcs11_operation_t *op,				CK_BYTE_PTR pDigest, CK_ULONG_PTR pulDigestLen){	EVP_MD_CTX *md_ctx = DIGEST_CTX(op);	if (*pulDigestLen < (unsigned) EVP_MD_CTX_size(md_ctx)) {		sc_log(context, "Provided buffer too small: %ul < %d",			*pulDigestLen, EVP_MD_CTX_size(md_ctx));		*pulDigestLen = EVP_MD_CTX_size(md_ctx);		return CKR_BUFFER_TOO_SMALL;	}	EVP_DigestFinal(md_ctx, pDigest, (unsigned *) pulDigestLen);	return CKR_OK;}

static unsigneddigest_result_size(PX_MD *h){	OSSLDigest *digest = (OSSLDigest *) h->p.ptr;	return EVP_MD_CTX_size(&digest->ctx);}

int ssl3_final_finish_mac(SSL *s, const char *sender, int len, unsigned char *p){    int ret;    EVP_MD_CTX ctx;    if (!ssl3_digest_cached_records(s, 0))        return 0;    if (EVP_MD_CTX_type(s->s3->handshake_dgst) != NID_md5_sha1) {        SSLerr(SSL_F_SSL3_HANDSHAKE_MAC, SSL_R_NO_REQUIRED_DIGEST);        return 0;    }    EVP_MD_CTX_init(&ctx);    EVP_MD_CTX_copy_ex(&ctx, s->s3->handshake_dgst);    ret = EVP_MD_CTX_size(&ctx);    if (ret < 0) {        EVP_MD_CTX_cleanup(&ctx);        return 0;    }    if ((sender != NULL && EVP_DigestUpdate(&ctx, sender, len) <= 0)            || EVP_MD_CTX_ctrl(&ctx, EVP_CTRL_SSL3_MASTER_SECRET,                               s->session->master_key_length,                               s->session->master_key) <= 0            || EVP_DigestFinal_ex(&ctx, p, NULL) <= 0) {        SSLerr(SSL_F_SSL3_HANDSHAKE_MAC, ERR_R_INTERNAL_ERROR);        ret = 0;    }    EVP_MD_CTX_cleanup(&ctx);    return ret;}

static int ssl3_handshake_mac(SSL *s, EVP_MD_CTX *in_ctx,	     const char *sender, int len, unsigned char *p)	{	unsigned int ret;	int npad,n;	unsigned int i;	unsigned char md_buf[EVP_MAX_MD_SIZE];	EVP_MD_CTX ctx;	EVP_MD_CTX_copy(&ctx,in_ctx);	n=EVP_MD_CTX_size(&ctx);	npad=(48/n)*n;	if (sender != NULL)		EVP_DigestUpdate(&ctx,sender,len);	EVP_DigestUpdate(&ctx,s->session->master_key,		s->session->master_key_length);	EVP_DigestUpdate(&ctx,ssl3_pad_1,npad);	EVP_DigestFinal(&ctx,md_buf,&i);	EVP_DigestInit(&ctx,EVP_MD_CTX_md(&ctx));	EVP_DigestUpdate(&ctx,s->session->master_key,		s->session->master_key_length);	EVP_DigestUpdate(&ctx,ssl3_pad_2,npad);	EVP_DigestUpdate(&ctx,md_buf,i);	EVP_DigestFinal(&ctx,p,&ret);	memset(&ctx,0,sizeof(EVP_MD_CTX));	return((int)ret);	}

static int ssl3_handshake_mac(SSL *s, EVP_MD_CTX *in_ctx,	     const char *sender, int len, unsigned char *p)	{	unsigned int ret;	int npad,n;	unsigned int i;	unsigned char md_buf[EVP_MAX_MD_SIZE];	EVP_MD_CTX ctx;	EVP_MD_CTX_init(&ctx);	EVP_MD_CTX_set_flags(&ctx, EVP_MD_CTX_FLAG_NON_FIPS_ALLOW);	EVP_MD_CTX_copy_ex(&ctx,in_ctx);	n=EVP_MD_CTX_size(&ctx);	npad=(48/n)*n;	if (sender != NULL)		EVP_DigestUpdate(&ctx,sender,len);	EVP_DigestUpdate(&ctx,s->session->master_key,		s->session->master_key_length);	EVP_DigestUpdate(&ctx,ssl3_pad_1,npad);	EVP_DigestFinal_ex(&ctx,md_buf,&i);	EVP_DigestInit_ex(&ctx,EVP_MD_CTX_md(&ctx), NULL);	EVP_DigestUpdate(&ctx,s->session->master_key,		s->session->master_key_length);	EVP_DigestUpdate(&ctx,ssl3_pad_2,npad);	EVP_DigestUpdate(&ctx,md_buf,i);	EVP_DigestFinal_ex(&ctx,p,&ret);	EVP_MD_CTX_cleanup(&ctx);	return((int)ret);	}

static PyObject *EVP_hexdigest(EVPobject *self, PyObject *unused){    unsigned char digest[EVP_MAX_MD_SIZE];    EVP_MD_CTX *temp_ctx;    unsigned int digest_size;    temp_ctx = EVP_MD_CTX_new();    if (temp_ctx == NULL) {        PyErr_NoMemory();        return NULL;    }    /* Get the raw (binary) digest value */    if (!locked_EVP_MD_CTX_copy(temp_ctx, self)) {        return _setException(PyExc_ValueError);    }    digest_size = EVP_MD_CTX_size(temp_ctx);    if (!EVP_DigestFinal(temp_ctx, digest, NULL)) {        _setException(PyExc_ValueError);        return NULL;    }    EVP_MD_CTX_free(temp_ctx);    return _Py_strhex((const char *)digest, digest_size);}

soter_status_t soter_hash_final(soter_hash_ctx_t *hash_ctx, uint8_t* hash_value, size_t* hash_length){	size_t md_length;	if (!hash_ctx || !hash_length)	{		return SOTER_INVALID_PARAMETER;	}	md_length = (size_t)EVP_MD_CTX_size(&(hash_ctx->evp_md_ctx));	if (!hash_value || (md_length > *hash_length))	{		*hash_length = md_length;		return SOTER_BUFFER_TOO_SMALL;	}	if (EVP_DigestFinal(&(hash_ctx->evp_md_ctx), hash_value, (unsigned int *)&md_length))	{		*hash_length = md_length;		return SOTER_SUCCESS;	}	else	{		return SOTER_FAIL;	}}

static PyObject *EVP_digest(EVPobject *self, PyObject *unused){    unsigned char digest[EVP_MAX_MD_SIZE];    EVP_MD_CTX *temp_ctx;    PyObject *retval;    unsigned int digest_size;    temp_ctx = EVP_MD_CTX_new();    if (temp_ctx == NULL) {        PyErr_NoMemory();        return NULL;    }    if (!locked_EVP_MD_CTX_copy(temp_ctx, self)) {        return _setException(PyExc_ValueError);    }    digest_size = EVP_MD_CTX_size(temp_ctx);    if (!EVP_DigestFinal(temp_ctx, digest, NULL)) {        _setException(PyExc_ValueError);        return NULL;    }    retval = PyBytes_FromStringAndSize((const char *)digest, digest_size);    EVP_MD_CTX_free(temp_ctx);    return retval;}

int n_ssl3_mac(SSL *ssl, unsigned char *md, int send)	{	SSL3_RECORD *rec;	unsigned char *mac_sec,*seq;	EVP_MD_CTX md_ctx;	const EVP_MD_CTX *hash;	unsigned char *p,rec_char;	unsigned int md_size;	int npad;	int t;	if (send)		{		rec= &(ssl->s3->wrec);		mac_sec= &(ssl->s3->write_mac_secret[0]);		seq= &(ssl->s3->write_sequence[0]);		hash=ssl->write_hash;		}	else		{		rec= &(ssl->s3->rrec);		mac_sec= &(ssl->s3->read_mac_secret[0]);		seq= &(ssl->s3->read_sequence[0]);		hash=ssl->read_hash;		}	t=EVP_MD_CTX_size(hash);	if (t < 0)		return -1;	md_size=t;	npad=(48/md_size)*md_size;	/* Chop the digest off the end :-) */	EVP_MD_CTX_init(&md_ctx);	EVP_MD_CTX_copy_ex( &md_ctx,hash);	EVP_DigestUpdate(&md_ctx,mac_sec,md_size);	EVP_DigestUpdate(&md_ctx,ssl3_pad_1,npad);	EVP_DigestUpdate(&md_ctx,seq,8);	rec_char=rec->type;	EVP_DigestUpdate(&md_ctx,&rec_char,1);	p=md;	s2n(rec->length,p);	EVP_DigestUpdate(&md_ctx,md,2);	EVP_DigestUpdate(&md_ctx,rec->input,rec->length);	EVP_DigestFinal_ex( &md_ctx,md,NULL);	EVP_MD_CTX_copy_ex( &md_ctx,hash);	EVP_DigestUpdate(&md_ctx,mac_sec,md_size);	EVP_DigestUpdate(&md_ctx,ssl3_pad_2,npad);	EVP_DigestUpdate(&md_ctx,md,md_size);	EVP_DigestFinal_ex( &md_ctx,md,&md_size);	EVP_MD_CTX_cleanup(&md_ctx);	ssl3_record_sequence_update(seq);	return(md_size);	}

const Poco::DigestEngine::Digest& DigestEngine::digest(){	_digest.clear();	unsigned len = EVP_MD_CTX_size(_pContext);	_digest.resize(len);	EVP_DigestFinal_ex(_pContext, &_digest[0], &len);	reset();	return _digest;}

/* *  call-seq: *      digest.digest_length -> integer * * Returns the output size of the digest, i.e. the length in bytes of the * final message digest result. * * === Example *   digest = OpenSSL::Digest::SHA1.new *   puts digest.digest_length # => 20 * */static VALUEossl_digest_size(VALUE self){    EVP_MD_CTX *ctx;    GetDigest(self, ctx);    return INT2NUM(EVP_MD_CTX_size(ctx));}

static LUA_FUNCTION(openssl_digest_ctx_info){  EVP_MD_CTX *ctx = CHECK_OBJECT(1, EVP_MD_CTX, "openssl.evp_digest_ctx");  lua_newtable(L);  AUXILIAR_SET(L, -1, "block_size", EVP_MD_CTX_block_size(ctx), integer);  AUXILIAR_SET(L, -1, "size", EVP_MD_CTX_size(ctx), integer);  AUXILIAR_SET(L, -1, "type", EVP_MD_CTX_type(ctx), integer);  AUXILIAR_SETOBJECT(L, EVP_MD_CTX_md(ctx), "openssl.evp_digest", -1, "digest");  return 1;}

static int ssl3_handshake_mac(SSL *s, int md_nid,                              const char *sender, int len, unsigned char *p){    unsigned int ret;    int npad, n;    unsigned int i;    unsigned char md_buf[EVP_MAX_MD_SIZE];    EVP_MD_CTX ctx, *d = NULL;    if (!ssl3_digest_cached_records(s, 0))        return 0;    /*     * Search for digest of specified type in the handshake_dgst array     */    for (i = 0; i < SSL_MAX_DIGEST; i++) {        if (s->s3->handshake_dgst[i]            && EVP_MD_CTX_type(s->s3->handshake_dgst[i]) == md_nid) {            d = s->s3->handshake_dgst[i];            break;        }    }    if (!d) {        SSLerr(SSL_F_SSL3_HANDSHAKE_MAC, SSL_R_NO_REQUIRED_DIGEST);        return 0;    }    EVP_MD_CTX_init(&ctx);    EVP_MD_CTX_set_flags(&ctx, EVP_MD_CTX_FLAG_NON_FIPS_ALLOW);    EVP_MD_CTX_copy_ex(&ctx, d);    n = EVP_MD_CTX_size(&ctx);    if (n < 0)        return 0;    npad = (48 / n) * n;    if ((sender != NULL && EVP_DigestUpdate(&ctx, sender, len) <= 0)            || EVP_DigestUpdate(&ctx, s->session->master_key,                                s->session->master_key_length) <= 0            || EVP_DigestUpdate(&ctx, ssl3_pad_1, npad) <= 0            || EVP_DigestFinal_ex(&ctx, md_buf, &i) <= 0            || EVP_DigestInit_ex(&ctx, EVP_MD_CTX_md(&ctx), NULL) <= 0            || EVP_DigestUpdate(&ctx, s->session->master_key,                                s->session->master_key_length) <= 0            || EVP_DigestUpdate(&ctx, ssl3_pad_2, npad) <= 0            || EVP_DigestUpdate(&ctx, md_buf, i) <= 0            || EVP_DigestFinal_ex(&ctx, p, &ret) <= 0) {        SSLerr(SSL_F_SSL3_HANDSHAKE_MAC, ERR_R_INTERNAL_ERROR);        ret = 0;    }    EVP_MD_CTX_cleanup(&ctx);    return ((int)ret);}

/* *  call-seq: *      digest.finish -> aString * */static VALUEossl_digest_finish(int argc, VALUE *argv, VALUE self){    EVP_MD_CTX *ctx;    VALUE str;    rb_scan_args(argc, argv, "01", &str);    GetDigest(self, ctx);    if (NIL_P(str)) {        str = rb_str_new(NULL, EVP_MD_CTX_size(ctx));    } else {        StringValue(str);        rb_str_resize(str, EVP_MD_CTX_size(ctx));    }    EVP_DigestFinal_ex(ctx, (unsigned char *)RSTRING_PTR(str), NULL);    return str;}

ikptrikrt_openssl_evp_md_ctx_size (ikptr s_ctx, ikpcb * pcb){#if ((defined HAVE_DECL_EVP_MD_CTX_SIZE) && HAVE_DECL_EVP_MD_CTX_SIZE)  const EVP_MD_CTX *	ctx = IK_EVP_MD_CTX(s_ctx);  int			rv;  rv = EVP_MD_CTX_size(ctx);  return ika_integer_from_int(pcb, rv);#else  feature_failure(__func__);#endif}

size_t ssl3_final_finish_mac(SSL *s, const char *sender, size_t len,                             unsigned char *p){    int ret;    EVP_MD_CTX *ctx = NULL;    if (!ssl3_digest_cached_records(s, 0)) {        /* SSLfatal() already called */        return 0;    }    if (EVP_MD_CTX_type(s->s3->handshake_dgst) != NID_md5_sha1) {        SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_SSL3_FINAL_FINISH_MAC,                 SSL_R_NO_REQUIRED_DIGEST);        return 0;    }    ctx = EVP_MD_CTX_new();    if (ctx == NULL) {        SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_SSL3_FINAL_FINISH_MAC,                 ERR_R_MALLOC_FAILURE);        return 0;    }    if (!EVP_MD_CTX_copy_ex(ctx, s->s3->handshake_dgst)) {        SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_SSL3_FINAL_FINISH_MAC,                 ERR_R_INTERNAL_ERROR);        return 0;    }    ret = EVP_MD_CTX_size(ctx);    if (ret < 0) {        SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_SSL3_FINAL_FINISH_MAC,                 ERR_R_INTERNAL_ERROR);        EVP_MD_CTX_reset(ctx);        return 0;    }    if ((sender != NULL && EVP_DigestUpdate(ctx, sender, len) <= 0)        || EVP_MD_CTX_ctrl(ctx, EVP_CTRL_SSL3_MASTER_SECRET,                           (int)s->session->master_key_length,                           s->session->master_key) <= 0        || EVP_DigestFinal_ex(ctx, p, NULL) <= 0) {        SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_SSL3_FINAL_FINISH_MAC,                 ERR_R_INTERNAL_ERROR);        ret = 0;    }    EVP_MD_CTX_free(ctx);    return ret;}

char* MessageDigest::spc_digest_message ( const EVP_MD* type, const char* in, unsigned long n, unsigned int* outlen ){    EVP_MD_CTX    ctx;    char* ret;    EVP_DigestInit ( &ctx, type );    EVP_DigestUpdate ( &ctx, in, n );    if ( ! ( ret = ( char* ) malloc ( EVP_MD_CTX_size ( &ctx ) ) ) )    {        return 0;    }    EVP_DigestFinal ( &ctx, reinterpret_cast<unsigned char*> ( ret ), outlen );    return ret;}

int rpmDigestFinal(DIGEST_CTX ctx, void ** datap, size_t *lenp, int asAscii){    int ret;    unsigned char *digest = NULL;    unsigned int digestlen;    if (ctx == NULL) return -1;    digestlen = EVP_MD_CTX_size(ctx->md_ctx);    digest = xcalloc(digestlen, sizeof(*digest));    ret = EVP_DigestFinal_ex(ctx->md_ctx, digest, &digestlen);    if (ret != 1) goto done;    if (!asAscii) {        /* Raw data requested */        if (lenp) *lenp = digestlen;        if (datap) {            *datap = digest;            digest = NULL;        }    }    else {        /* ASCII requested */        if (lenp) *lenp = (2*digestlen) + 1;        if (datap) {            const uint8_t * s = (const uint8_t *) digest;            *datap = pgpHexStr(s, digestlen);        }    }    ret = 1;done:    if (digest) {        /* Zero the digest, just in case it's sensitive */        memset(digest, 0, digestlen);        free(digest);    }    EVP_MD_CTX_free(ctx->md_ctx);    free(ctx);    if (ret != 1) {        return -1;    }    return 0;}

/* * public static native void EVP_DigestReset(int) */static jint NativeCrypto_EVP_DigestSize(JNIEnv* env, jclass clazz, EVP_MD_CTX* ctx) {    // LOGI("NativeCrypto_EVP_DigestSize");    if (ctx == NULL) {        throwNullPointerException(env);        return -1;    }    int result = EVP_MD_CTX_size(ctx);    throwExceptionIfNecessary(env);    return result;}

intcompute_hash(int  hash_type,	     int  buf_size,	     char *buf,	     char *digest){	EVP_MD_CTX md_ctx;	unsigned int result_size;	int rv;	switch (hash_type) {		case HASH_SHA1:			rv = EVP_DigestInit(&md_ctx, EVP_sha1());			break;		case HASH_MD5:			rv = EVP_DigestInit(&md_ctx, EVP_md5());			break;		default:			rv = 1;			goto out;			break;	}	if (rv != EVP_SUCCESS) {		rv = 2;		goto err;	}	rv = EVP_DigestUpdate(&md_ctx, buf, buf_size);	if (rv != EVP_SUCCESS) {		rv = 3;		goto err;	}	result_size = EVP_MD_CTX_size(&md_ctx);	rv = EVP_DigestFinal(&md_ctx, (unsigned char *)digest, &result_size);	if (rv != EVP_SUCCESS) {		rv = 4;		goto err;	} else		rv = 0;	goto out;err:	print_openssl_errors();out:	return rv;}

static boolhsh_done(jose_io_t *io){    io_t *i = containerof(io, io_t, io);    uint8_t hsh[EVP_MD_CTX_size(i->emc)];    unsigned int l = 0;    if (EVP_DigestFinal(i->emc, hsh, &l) <= 0)        return SIZE_MAX;    if (!i->next->feed(i->next, hsh, l) || !i->next->done(i->next))        return SIZE_MAX;    return l;}

static int append_digest(const EVP_MD_CTX *ctx, uint8_t *out, size_t *out_len,                         size_t max_out) {  int ret = 0;  EVP_MD_CTX ctx_copy;  EVP_MD_CTX_init(&ctx_copy);  if (EVP_MD_CTX_size(ctx) > max_out) {    OPENSSL_PUT_ERROR(SSL, SSL_R_BUFFER_TOO_SMALL);    goto err;  }  unsigned len;  if (!EVP_MD_CTX_copy_ex(&ctx_copy, ctx) ||      !EVP_DigestFinal_ex(&ctx_copy, out, &len)) {    goto err;  }  assert(len == EVP_MD_CTX_size(ctx));  *out_len = len;  ret = 1;err:  EVP_MD_CTX_cleanup(&ctx_copy);  return ret;}

static int hmac_signctx(EVP_PKEY_CTX *ctx, unsigned char *sig, size_t *siglen,					EVP_MD_CTX *mctx)	{	unsigned int hlen;	HMAC_PKEY_CTX *hctx = (HMAC_PKEY_CTX *)ctx->data;	int l = EVP_MD_CTX_size(mctx);	if (l < 0)		return 0;	*siglen = l;	if (!sig)		return 1;	HMAC_Final(&hctx->ctx, sig, &hlen);	*siglen = (size_t)hlen;	return 1;	}

static int digest_final(EVP_MD_CTX *ctx, unsigned char *md){    struct digest_ctx *digest_ctx =        (struct digest_ctx *)EVP_MD_CTX_md_data(ctx);    if (md == NULL || digest_ctx == NULL)        return 0;    if (EVP_MD_CTX_test_flags(ctx, EVP_MD_CTX_FLAG_ONESHOT)) {        memcpy(md, digest_ctx->digest_res, EVP_MD_CTX_size(ctx));    } else if (digest_op(digest_ctx, NULL, 0, md, COP_FLAG_FINAL) < 0) {        SYSerr(SYS_F_IOCTL, errno);        return 0;    }    return 1;}

static int ossl_hmac_signctx(EVP_PKEY_CTX *ctx, unsigned char *sig,                             size_t *siglen, EVP_MD_CTX *mctx){    unsigned int hlen;    OSSL_HMAC_PKEY_CTX *hctx = EVP_PKEY_CTX_get_data(ctx);    int l = EVP_MD_CTX_size(mctx);    if (l < 0)        return 0;    *siglen = l;    if (!sig)        return 1;    if (!HMAC_Final(hctx->ctx, sig, &hlen))        return 0;    *siglen = (size_t)hlen;    return 1;}

TSS_RESULTTrspi_HashFinal(Trspi_HashCtx *ctx, BYTE *digest){	int rv;	UINT32 result_size;	if (ctx == NULL || ctx->ctx == NULL)		return TSPERR(TSS_E_INTERNAL_ERROR);	result_size = EVP_MD_CTX_size((EVP_MD_CTX *)ctx->ctx);	rv = EVP_DigestFinal(ctx->ctx, digest, &result_size);	if (rv != EVP_SUCCESS)		return TSPERR(TSS_E_INTERNAL_ERROR);	free(ctx->ctx);	ctx->ctx = NULL;	return TSS_SUCCESS;}

TSS_RESULTTrspi_Hash(UINT32 HashType, UINT32 BufSize, BYTE* Buf, BYTE* Digest){	EVP_MD_CTX md_ctx;	unsigned int result_size;	int rv;	switch (HashType) {		case TSS_HASH_SHA1:			rv = EVP_DigestInit(&md_ctx, EVP_sha1());			break;		default:			rv = TSPERR(TSS_E_BAD_PARAMETER);			goto out;			break;	}	if (rv != EVP_SUCCESS) {		rv = TSPERR(TSS_E_INTERNAL_ERROR);		goto err;	}	rv = EVP_DigestUpdate(&md_ctx, Buf, BufSize);	if (rv != EVP_SUCCESS) {		rv = TSPERR(TSS_E_INTERNAL_ERROR);		goto err;	}	result_size = EVP_MD_CTX_size(&md_ctx);	rv = EVP_DigestFinal(&md_ctx, Digest, &result_size);	if (rv != EVP_SUCCESS) {		rv = TSPERR(TSS_E_INTERNAL_ERROR);		goto err;	} else		rv = TSS_SUCCESS;	goto out;err:	DEBUG_print_openssl_errors();out:        return rv;}

static int hmac_signctx(EVP_PKEY_CTX *ctx, unsigned char *sig, size_t *siglen,                        EVP_MD_CTX *mctx) {  unsigned int hlen;  HMAC_PKEY_CTX *hctx = ctx->data;  size_t md_size = EVP_MD_CTX_size(mctx);  if (!sig) {    *siglen = md_size;    return 1;  } else if (*siglen < md_size) {    OPENSSL_PUT_ERROR(EVP, hmac_signctx, EVP_R_BUFFER_TOO_SMALL);    return 0;  }  if (!HMAC_Final(&hctx->ctx, sig, &hlen)) {    return 0;  }  *siglen = (size_t)hlen;  return 1;}

TSS_RESULTHash(UINT32 HashType, UINT32 BufSize, BYTE* Buf, BYTE* Digest){	EVP_MD_CTX *md_ctx;	unsigned int result_size;	int rv;	md_ctx = EVP_MD_CTX_create();	switch (HashType) {		case TSS_HASH_SHA1:			rv = EVP_DigestInit(md_ctx, EVP_sha1());			break;		default:			rv = TCSERR(TSS_E_BAD_PARAMETER);			goto out;			break;	}	if (rv != EVP_SUCCESS) {		rv = TCSERR(TSS_E_INTERNAL_ERROR);		goto out;	}	rv = EVP_DigestUpdate(md_ctx, Buf, BufSize);	if (rv != EVP_SUCCESS) {		rv = TCSERR(TSS_E_INTERNAL_ERROR);		goto out;	}	result_size = EVP_MD_CTX_size(md_ctx);	rv = EVP_DigestFinal(md_ctx, Digest, &result_size);	if (rv != EVP_SUCCESS) {		rv = TCSERR(TSS_E_INTERNAL_ERROR);	} else		rv = TSS_SUCCESS;out:	EVP_MD_CTX_destroy(md_ctx);	return rv;}