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 unsigned digest_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 VALUE ossl_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 VALUE ossl_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; }
ikptr ikrt_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; }
int compute_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 bool hsh_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_RESULT Trspi_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_RESULT Trspi_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_RESULT Hash(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; }