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;
}
