void sha512(char *string, int length, char *result) { int msg_length = length; int hash_length = gcry_md_get_algo_dlen(GCRY_MD_SHA512); unsigned char hash[hash_length]; gcry_md_hash_buffer(GCRY_MD_SHA512, hash, string, msg_length); int i; for (i = 0; i < hash_length; i++, result += 2) { snprintf(result, 3, "%02x", hash[i]); } return; }
GWEN_MDIGEST *GWEN_MDigest_Rmd160_new(void) { GWEN_MDIGEST *md; GWEN_MDIGEST_GC *xmd; md=GWEN_MDigest_Gc_new(GWEN_Crypt_HashAlgoId_Rmd160); assert(md); xmd=GWEN_INHERIT_GETDATA(GWEN_MDIGEST, GWEN_MDIGEST_GC, md); assert(xmd); xmd->algo=GCRY_MD_RMD160; GWEN_MDigest_SetDigestLen(md, gcry_md_get_algo_dlen(xmd->algo)); return md; }
int my_hash(const char alg[], const unsigned char input[], const unsigned int input_len, unsigned char output[]) { int md = gcry_md_map_name(alg); unsigned int mdlen = gcry_md_get_algo_dlen(md); gchar *keybuf = g_new0(gchar, mdlen); memset(keybuf, 0, mdlen); gcry_md_hash_buffer(md, keybuf, input, input_len); //copy size_t i = 0; for(i = 0; i<mdlen; ++i) { output[i] = keybuf[ i%mdlen ]; } return 0; }
z_int_t z_digest_hash_read(void *hdl, void *hash) /* z_proto, z_func z_digest_hash_read */ { #ifdef HAVE_GCRYPT_H gcry_md_hd_t *gcry_hdl = hdl; z_int_t dlen = gcry_md_get_algo_dlen(z_digest_hash_gcrypt_algo); if (!hdl || !hash) return dlen; memcpy(hash, gcry_md_read(*gcry_hdl, 0), dlen); #endif return 0; }
/**************** * This filter is used to en/de-cipher data with a conventional algorithm */ int cipher_filter( void *opaque, int control, IOBUF a, byte *buf, size_t *ret_len) { size_t size = *ret_len; cipher_filter_context_t *cfx = opaque; int rc=0; if( control == IOBUFCTRL_UNDERFLOW ) { /* decrypt */ rc = -1; /* not yet used */ } else if( control == IOBUFCTRL_FLUSH ) { /* encrypt */ assert(a); if( !cfx->header ) { write_header( cfx, a ); } if (cfx->mdc_hash) gcry_md_write (cfx->mdc_hash, buf, size); gcry_cipher_encrypt (cfx->cipher_hd, buf, size, NULL, 0); rc = iobuf_write( a, buf, size ); } else if( control == IOBUFCTRL_FREE ) { if( cfx->mdc_hash ) { byte *hash; int hashlen = gcry_md_get_algo_dlen (gcry_md_get_algo (cfx->mdc_hash)); byte temp[22]; assert( hashlen == 20 ); /* We must hash the prefix of the MDC packet here. */ temp[0] = 0xd3; temp[1] = 0x14; gcry_md_putc (cfx->mdc_hash, temp[0]); gcry_md_putc (cfx->mdc_hash, temp[1]); gcry_md_final (cfx->mdc_hash); hash = gcry_md_read (cfx->mdc_hash, 0); memcpy(temp+2, hash, 20); gcry_cipher_encrypt (cfx->cipher_hd, temp, 22, NULL, 0); gcry_md_close (cfx->mdc_hash); cfx->mdc_hash = NULL; if( iobuf_write( a, temp, 22 ) ) log_error("writing MDC packet failed\n" ); } gcry_cipher_close (cfx->cipher_hd); } else if( control == IOBUFCTRL_DESC ) { *(char**)buf = "cipher_filter"; } return rc; }
int soft_sign (const uint8_t *to_sign, size_t len, jwa_t alg, void *cookie, uint8_t **out, size_t *out_len) { int rc = -1; uint8_t *hash; gcry_sexp_t sig, digest; const unsigned int DLEN = gcry_md_get_algo_dlen (GCRY_MD_SHA256); hash = malloc (DLEN); assert (NULL != hash); gcry_md_hash_buffer (GCRY_MD_SHA256, hash, to_sign, len); rc = gcry_sexp_build (&digest, NULL, "(data (flags raw)\n" " (value %b))", DLEN, hash); if (rc) goto OUT; if (rc = gcry_pk_sign (&sig, digest, signing_key)) goto DIG; lca_print_sexp (sig); struct lca_octet_buffer signature = lca_sig2buf (&sig); if (NULL != signature.ptr) { *out = signature.ptr; *out_len = signature.len; rc = 0; } gcry_free (sig); DIG: gcry_free (digest); OUT: free (hash); assert (0 == rc); return rc; }
extern void io_encryption_checksum(IO_HANDLE ptr, uint8_t **b, size_t *l) { io_private_t *io_ptr = ptr; if (!io_ptr || io_ptr->fd < 0) return errno = EBADF , (void)NULL; if (!io_ptr->hash_init) return *l = 0 , (void)NULL; *l = gcry_md_get_algo_dlen(gcry_md_get_algo(io_ptr->hash_handle)); uint8_t *x = gcry_realloc(*b, *l); if (!x) die(_("Out of memory @ %s:%d:%s [%zu]"), __FILE__, __LINE__, __func__, *l); *b = x; memcpy(*b, gcry_md_read(io_ptr->hash_handle, gcry_md_get_algo(io_ptr->hash_handle)), *l); return; }
QString PasswordHasher::computeHash(const QString &password, const QString &salt) { const int algo = GCRY_MD_SHA512; const int rounds = 1000; QByteArray passwordBuffer = (salt + password).toUtf8(); int hashLen = gcry_md_get_algo_dlen(algo); char hash[hashLen], tmp[hashLen]; gcry_md_hash_buffer(algo, hash, passwordBuffer.data(), passwordBuffer.size()); for (int i = 1; i < rounds; ++i) { memcpy(tmp, hash, hashLen); gcry_md_hash_buffer(algo, hash, tmp, hashLen); } return salt + QString(QByteArray(hash, hashLen).toBase64()); }
static SLVAL sl_gcrypt_algorithm_hex_digest(sl_vm_t* vm, SLVAL self, SLVAL strv) { size_t i; sl_string_t* str = sl_get_string(vm, strv); gcrypt_algorithm_t* algo = get_algo_check(vm, self); size_t digest_len = gcry_md_get_algo_dlen(algo->algo); char* digest = alloca(digest_len); char* hex_digest = alloca(digest_len * 2); gcry_md_hash_buffer(algo->algo, digest, str->buff, str->buff_len); for(i = 0; i < digest_len; i++) { sprintf(hex_digest + 2 * i, "%02x", (uint8_t)digest[i]); } return sl_make_string(vm, (uint8_t*)hex_digest, digest_len * 2); }
GWEN_MDIGEST *GWEN_MDigest_Sha256_new(void) { GWEN_MDIGEST *md; GWEN_MDIGEST_GC *xmd; md=GWEN_MDigest_Gc_new(GWEN_Crypt_HashAlgoId_Sha256); assert(md); xmd=GWEN_INHERIT_GETDATA(GWEN_MDIGEST, GWEN_MDIGEST_GC, md); assert(xmd); xmd->algo=GCRY_MD_SHA256; xmd->flags=GCRY_MD_FLAG_SECURE; GWEN_MDigest_SetDigestLen(md, gcry_md_get_algo_dlen(xmd->algo)); return md; }
/* Creates an md5 signature of the concatenated parameters and adds it to keyval */ static int param_sign(struct keyval *kv) { struct onekeyval *okv; char hash[33]; char ebuf[64]; uint8_t *hash_bytes; size_t hash_len; gcry_md_hd_t md_hdl; gpg_error_t gc_err; int ret; int i; gc_err = gcry_md_open(&md_hdl, GCRY_MD_MD5, 0); if (gc_err != GPG_ERR_NO_ERROR) { gpg_strerror_r(gc_err, ebuf, sizeof(ebuf)); DPRINTF(E_LOG, L_LASTFM, "Could not open MD5: %s\n", ebuf); return -1; } for (okv = kv->head; okv; okv = okv->next) { gcry_md_write(md_hdl, okv->name, strlen(okv->name)); gcry_md_write(md_hdl, okv->value, strlen(okv->value)); } gcry_md_write(md_hdl, lastfm_secret, strlen(lastfm_secret)); hash_bytes = gcry_md_read(md_hdl, GCRY_MD_MD5); if (!hash_bytes) { DPRINTF(E_LOG, L_LASTFM, "Could not read MD5 hash\n"); return -1; } hash_len = gcry_md_get_algo_dlen(GCRY_MD_MD5); for (i = 0; i < hash_len; i++) sprintf(hash + (2 * i), "%02x", hash_bytes[i]); ret = keyval_add(kv, "api_sig", hash); gcry_md_close(md_hdl); return ret; }
static int evp_digest(lua_State *L) { HANDLER_EVP *c = evp_pget(L, 1); #if CRYPTO_OPENSSL HANDLER_EVP *d = NULL; unsigned char digest[EVP_MAX_MD_SIZE]; #elif CRYPTO_GCRYPT HANDLER_EVP d = NULL; unsigned char *digest; int algo; #endif size_t written = 0; if (lua_isstring(L, 2)) { size_t s_len; const char *s = luaL_checklstring(L, 2, &s_len); EVP_UPDATE(c, s, s_len); } #if CRYPTO_OPENSSL d = EVP_MD_CTX_create(); EVP_MD_CTX_copy_ex(d, c); EVP_DigestFinal_ex(d, digest, &written); EVP_MD_CTX_destroy(d); #elif CRYPTO_GCRYPT algo = gcry_md_get_algo(*c); gcry_md_copy(&d, *c); gcry_md_final(d); digest = gcry_md_read(d, algo); written = gcry_md_get_algo_dlen(algo); #endif if (lua_toboolean(L, 3)) lua_pushlstring(L, (char *)digest, written); else { char *hex = bin2hex(digest, written); lua_pushlstring(L, hex, written*2); free(hex); } #if CRYPTO_GCRYPT gcry_md_close(d); #endif return 1; }
/* * Create a new hash context */ ni_hashctx_t * __ni_hashctx_new(int algo) { ni_hashctx_t *ctx; gcry_error_t err; ctx = calloc(1, sizeof(*ctx)); err = gcry_md_open(&ctx->handle, algo, 0); if (err) { ni_error("%s: gcry_md_open failed", __func__); ni_hashctx_free(ctx); return NULL; } ctx->md_length = gcry_md_get_algo_dlen(algo); return ctx; }
guchar* gkm_certificate_hash (GkmCertificate *self, int hash_algo, gsize *n_hash) { guchar *hash; g_return_val_if_fail (GKM_IS_CERTIFICATE (self), NULL); g_return_val_if_fail (self->pv->data, NULL); g_return_val_if_fail (n_hash, NULL); *n_hash = gcry_md_get_algo_dlen (hash_algo); g_return_val_if_fail (*n_hash > 0, NULL); hash = g_malloc0 (*n_hash); gcry_md_hash_buffer (hash_algo, hash, self->pv->data, self->pv->n_data); return hash; }
static int _md_init (md_ctx *x, munge_mac_t md) { gcry_error_t e; int algo; if (_md_map_enum (md, &algo) < 0) { return (-1); } if ((e = gcry_md_open (&(x->ctx), algo, 0)) != 0) { log_msg (LOG_DEBUG, "gcry_md_open failed for MAC=%d: %s", md, gcry_strerror (e)); return (-1); } x->diglen = gcry_md_get_algo_dlen (algo); return (0); }
/* Return an allocated buffer with the formatted fingerprint as one large hexnumber */ char * gpgsm_get_fingerprint_hexstring (ksba_cert_t cert, int algo) { unsigned char digest[MAX_DIGEST_LEN]; char *buf; int len; if (!algo) algo = GCRY_MD_SHA1; len = gcry_md_get_algo_dlen (algo); assert (len <= MAX_DIGEST_LEN ); gpgsm_get_fingerprint (cert, algo, digest, NULL); buf = xmalloc (len*2+1); bin2hex (digest, len, buf); return buf; }
static int wrap_gcry_mac_output (void *src_ctx, void *digest, size_t digestsize) { opaque *_digest = gcry_md_read (src_ctx, 0); if (_digest != NULL) { unsigned int len = gcry_md_get_algo_dlen (gcry_md_get_algo (src_ctx)); if (len <= digestsize && digest != NULL) memcpy (digest, _digest, len); return 0; } gnutls_assert (); return GNUTLS_E_HASH_FAILED; }
/* Third loop, matches attachment by payload. Attachments that only match by * payload are considered to have an invalid name. */ static void sig_check_attachments_payload(struct kmocrypt_signature2 * self, size_t spkt_cnt, karray * attch_array, int * sig_seen, int * kmo_seen, struct kmocrypt_attachment_hash * attch_cache) { int i; size_t n, j; struct kmocrypt_subpacket_list2 * sp; uint8_t * att_hash; struct kmod_attachment * att; n = gcry_md_get_algo_dlen(self->hash_algo); for (i = 0; i < attch_array->size; i++) { att = (struct kmod_attachment *) attch_array->data[i]; /* If the attachment has already been seen above, move to next. */ if (kmo_seen[i] == 1) continue; /* Hash the KMO name and payloads. */ sp = self->subpacket_array[KMO_SP_TYPE_ATTACHMENT]; for (j = 0; j < spkt_cnt; j++) { att_hash = sp->data + n; /* If the signature attachment has already been seen above, move to the next element in the signature. */ if (sig_seen[j] == 0) { /* If the payload hash matches... */ if (memcmp(att_hash, attch_cache[i].payload_hash, n) == 0) { att->status = KMO_EVAL_ATTACHMENT_MODIFIED; kmo_seen[i] = 1; sig_seen[j] = 1; break; } } sp = sp->next; } } }
int secure_derive_key (const char *salt, const char *passphrase, unsigned char *key, int length_key) { unsigned char *buffer, *ptr_hash; int length, length_hash; gcry_md_hd_t hd_md; memset (key, 0, length_key); length = SALT_SIZE + strlen (passphrase); buffer = malloc (length); if (!buffer) return 0; /* build a buffer with salt + passphrase */ memcpy (buffer, salt, SALT_SIZE); memcpy (buffer + SALT_SIZE, passphrase, strlen (passphrase)); /* compute hash of buffer */ if (gcry_md_open (&hd_md, GCRY_MD_SHA512, 0) != 0) { free (buffer); return 0; } length_hash = gcry_md_get_algo_dlen (GCRY_MD_SHA512); gcry_md_write (hd_md, buffer, length); ptr_hash = gcry_md_read (hd_md, GCRY_MD_SHA512); if (!ptr_hash) { gcry_md_close (hd_md); free (buffer); return 0; } /* copy beginning of hash (or full hash) in the key */ memcpy (key, ptr_hash, (length_hash > length_key) ? length_key : length_hash); gcry_md_close (hd_md); free (buffer); return 1; }
static int hmac_digest(lua_State *L) { HANDLER_HMAC *c = hmac_pget(L, 1); size_t written = 0; #if CRYPTO_OPENSSL unsigned char digest[EVP_MAX_MD_SIZE]; #elif CRYPTO_GCRYPT HANDLER_HMAC d; unsigned char *digest; int algo; #endif if (lua_isstring(L, 2)) { size_t s_len; const char *s = luaL_checklstring(L, 2, &s_len); HMAC_UPDATE(c, s, s_len); } #if CRYPTO_OPENSSL HMAC_Final(c, digest, &written); #elif CRYPTO_GCRYPT algo = gcry_md_get_algo(*c); gcry_md_copy(&d, *c); gcry_md_final(d); digest = gcry_md_read(d, algo); written = gcry_md_get_algo_dlen(algo); #endif if (lua_toboolean(L, 3)) lua_pushlstring(L, (char *)digest, written); else { char *hex = bin2hex(digest, written); lua_pushlstring(L, hex, written*2); free(hex); } #if CRYPTO_GCRYPT gcry_md_close(d); #endif return 1; }
/*-------------------[ Std. HASH ]-------------------------------------*/ static tree_cell * nasl_gcrypt_hash (lex_ctxt * lexic, int algorithm, void *data, size_t datalen, void *key, size_t keylen) { gcry_md_hd_t hd; gcry_error_t err; tree_cell *retc; int dlen = gcry_md_get_algo_dlen (algorithm); if (data == NULL) return NULL; err = gcry_md_open (&hd, algorithm, key ? GCRY_MD_FLAG_HMAC : 0); if (err) { nasl_perror (lexic, "nasl_gcrypt_hash(): gcry_md_open failed: %s/%s\n", gcry_strsource (err), gcry_strerror (err)); return NULL; } if (key) { err = gcry_md_setkey (hd, key, keylen); if (err) { nasl_perror (lexic, "nasl_gcrypt_hash():" " gcry_md_setkey failed: %s/%s\n", gcry_strsource (err), gcry_strerror (err)); return NULL; } } gcry_md_write (hd, data, datalen); retc = alloc_tree_cell (0, NULL); retc->type = CONST_DATA; retc->x.str_val = g_memdup (gcry_md_read (hd, algorithm), dlen + 1); retc->size = dlen; gcry_md_close (hd); return retc; }
int P_hash(const char *digest, unsigned char *dest, int dlen, unsigned char *secret, int sslen, unsigned char *seed, int slen) { unsigned char hmac[48]; uint32_t hlen; gcry_md_hd_t md; uint32_t tmpslen; unsigned char tmpseed[slen]; unsigned char *out = dest; int pending = dlen; int algo = gcry_md_map_name(digest); int algolen = gcry_md_get_algo_dlen(algo); // Copy initial seed memcpy(tmpseed, seed, slen); tmpslen = slen; // Calculate enough data to fill destination while (pending > 0) { gcry_md_open(&md, algo, GCRY_MD_FLAG_HMAC); gcry_md_setkey(md, secret, sslen); gcry_md_write(md, tmpseed, tmpslen); memcpy(tmpseed, gcry_md_read(md, algo), algolen); tmpslen = algolen; gcry_md_close(md); gcry_md_open(&md, algo, GCRY_MD_FLAG_HMAC); gcry_md_setkey(md, secret, sslen); gcry_md_write(md, tmpseed, tmpslen); gcry_md_write(md, seed, slen); memcpy(hmac, gcry_md_read(md, algo), algolen); hlen = algolen; hlen = (hlen > pending) ? pending : hlen; memcpy(out, hmac, hlen); out += hlen; pending -= hlen; } return hlen; }
z_int_t z_digest_sum_buffer(const void *buffer, z_int_t length, void *sum) /* z_proto, z_func z_digest_sum_buffer */ { #if defined(HAVE_GCRYPT_H) if (!buffer || !sum) return gcry_md_get_algo_dlen(GCRY_MD_CRC32); gcry_md_hash_buffer(GCRY_MD_CRC32, sum, buffer, length); #elif defined (Z_PACK_CRC32) if (!buffer || !sum) return sizeof(z_crc32_t); *((z_crc32_t *) sum) = z_crc32_buffer(buffer, length); #endif /* printf("z: %.8X\n", *((z_crc32_t *) sum));*/ return 0; }
gchar * __pkey_manage_aes_encrypt (const gchar *in, const gchar *password) { gchar * result = NULL; gint i; guint in_length = strlen (in); guchar * random_data = NULL; guchar * sha256 = NULL; gchar * sha256_hex = NULL; gchar * cyphered = NULL; random_data = g_new0 (guchar, in_length); // Fill random_data with random data gcry_create_nonce (random_data, in_length); // XOR random_data with in => random_data for (i=0; i<in_length; i++) { random_data[i] = random_data[i] ^ in[i]; } // SHA-2 256 random_data sha256 = g_new0 (guchar, gcry_md_get_algo_dlen(GCRY_MD_SHA256)); gcry_md_hash_buffer (GCRY_MD_SHA256, sha256, random_data, in_length); sha256_hex = __pkey_manage_to_hex (sha256, 32); cyphered = __pkey_manage_aes_encrypt_aux (in, password, &sha256[0], &sha256[16]); result = g_strdup_printf ("gCP%s%s", sha256_hex, cyphered); g_free (sha256_hex); g_free (cyphered); g_free (sha256); g_free (random_data); return result; }
/** * Proceed to a hash on a kbuffer, putting the result in the * hash kbuffer. */ void kmocrypt_hash(kbuffer * input, kbuffer * hash, int algo) { int digest_len; uint32_t input_size; /* Simple hashing, result is put directly in the buffer, no copy needed, no payment until 2099. */ assert(gcry_md_test_algo(algo) == 0); digest_len = gcry_md_get_algo_dlen(algo); /* Get the length and addresse of unread data from input, and read it to * the end */ input_size = input->len - input->pos; /* Hash the buffer. */ gcry_md_hash_buffer(algo, kbuffer_append_nbytes(hash, digest_len), kbuffer_read_nbytes(input, input_size), (size_t)input_size); }
void FileSystemSensorModule::getFileSHA1Sum(const std::string &fileName, std::string &sha1Sum){ this->clearFSCache(); std::ifstream fileHandle; fileHandle.open(std::string().insert(0, this->fileSystemPath).append("/").append(fileName).c_str(), std::ifstream::in); long begin,end; begin = fileHandle.tellg(); fileHandle.seekg (0, std::ios::end); end = fileHandle.tellg(); fileHandle.seekg (0, std::ios::beg); char * fileContent = (char *) malloc(end-begin); int count = 0; while (fileHandle.good()) fileContent[count++] = fileHandle.get(); fileHandle.close(); int hash_len = gcry_md_get_algo_dlen( GCRY_MD_SHA1 ); unsigned char hash[ hash_len ]; char *out = (char *) malloc( sizeof(char) * ((hash_len*2)+1) ); char *p = out; gcry_md_hash_buffer( GCRY_MD_SHA1, hash, fileContent, count - 1 ); for ( int i = 0; i < hash_len; i++, p += 2 ) snprintf ( p, 3, "%02x", hash[i] ); sha1Sum.append(out, sizeof(char) * ((hash_len*2))); free(fileContent); free( out ); }
int rasqal_digest_buffer(rasqal_digest_type type, const unsigned char *output, const unsigned char * const input, size_t len) { enum gcry_md_algos algo; unsigned int output_len; if(type > RASQAL_DIGEST_LAST) return -1; algo = rasqal_digest_to_gcry_md_algos[type]; if(algo == GCRY_MD_NONE) return -1; output_len = gcry_md_get_algo_dlen(algo); if(!input) return output_len; gcry_md_hash_buffer(algo, (void*)output, (const void*)input, len); return output_len; }
static libspectrum_error get_hash( gcry_sexp_t *hash, const libspectrum_byte *data, size_t data_length ) { gcry_error_t error; unsigned char *digest; size_t digest_length; gcry_mpi_t hash_mpi; digest_length = gcry_md_get_algo_dlen( HASH_ALGORITHM ); digest = libspectrum_malloc( digest_length ); gcry_md_hash_buffer( HASH_ALGORITHM, digest, data, data_length ); error = gcry_mpi_scan( &hash_mpi, GCRYMPI_FMT_USG, digest, digest_length, NULL ); if( error ) { libspectrum_print_error( LIBSPECTRUM_ERROR_LOGIC, "get_hash: error creating hash MPI: %s", gcry_strerror( error ) ); libspectrum_free( digest ); return LIBSPECTRUM_ERROR_LOGIC; } libspectrum_free( digest ); error = gcry_sexp_build( hash, NULL, hash_format, hash_mpi ); if( error ) { libspectrum_print_error( LIBSPECTRUM_ERROR_LOGIC, "get_hash: error creating hash sexp: %s", gcry_strerror( error ) ); gcry_mpi_release( hash_mpi ); return LIBSPECTRUM_ERROR_LOGIC; } gcry_mpi_release( hash_mpi ); return LIBSPECTRUM_ERROR_NONE; }
int gpgsm_create_cms_signature (ctrl_t ctrl, ksba_cert_t cert, gcry_md_hd_t md, int mdalgo, unsigned char **r_sigval) { int rc; char *grip, *desc; size_t siglen; grip = gpgsm_get_keygrip_hexstring (cert); if (!grip) return gpg_error (GPG_ERR_BAD_CERT); desc = gpgsm_format_keydesc (cert); rc = gpgsm_agent_pksign (ctrl, grip, desc, gcry_md_read(md, mdalgo), gcry_md_get_algo_dlen (mdalgo), mdalgo, r_sigval, &siglen); xfree (desc); xfree (grip); return rc; }
int crypt_hmac_init(crypt_hmac **ctx, const char *name, bool isHmac) { unsigned int flags = isHmac ? GCRY_MD_FLAG_HMAC : 0; crypt_hmac *h = reinterpret_cast<crypt_hmac*>(malloc(sizeof(*h))); if (!h) return -ENOMEM; h->hash_id = gcry_md_map_name(name); if (!h->hash_id) { free(h); return -EINVAL; } if (gcry_md_open(&h->hd, h->hash_id, flags)) { free(h); return -EINVAL; } h->hash_len = gcry_md_get_algo_dlen(h->hash_id); *ctx = h; return 0; }