hash.c File Reference

#include "config.h"
#include <rz_hash.h>
#include <rz_util.h>
#include <xxhash.h>

Go to the source code of this file.

Classes
struct	hash_cfg_config_t

Macros
#define	hash_cfg_can_hmac(c)   ((c)->status == RZ_MSG_DIGEST_STATUS_ALLOC)
#define	hash_cfg_can_init(c)   ((c)->status == RZ_MSG_DIGEST_STATUS_FINAL || (c)->status == RZ_MSG_DIGEST_STATUS_ALLOC)
#define	hash_cfg_can_update(c)   ((c)->status == RZ_MSG_DIGEST_STATUS_INIT || (c)->status == RZ_MSG_DIGEST_STATUS_UPDATE)
#define	hash_cfg_can_final(c)   ((c)->status == RZ_MSG_DIGEST_STATUS_ALLOC || (c)->status == RZ_MSG_DIGEST_STATUS_INIT || (c)->status == RZ_MSG_DIGEST_STATUS_UPDATE)
#define	hash_cfg_has_finshed(c)   ((c)->status == RZ_MSG_DIGEST_STATUS_FINAL)

Typedefs
typedef struct hash_cfg_config_t	HashCfgConfig

Functions
	RZ_LIB_VERSION (rz_hash)
RZ_API ut32	rz_hash_xxhash (RZ_NONNULL RzHash *rh, RZ_NONNULL const ut8 *input, size_t size)
RZ_API double	rz_hash_entropy (RZ_NONNULL RzHash *rh, RZ_NONNULL const ut8 *data, ut64 len)
RZ_API double	rz_hash_entropy_fraction (RZ_NONNULL RzHash *rh, RZ_NONNULL const ut8 *data, ut64 len)
static int	hash_cfg_config_compare (const void *value, const void *data)
static void	hash_cfg_config_free (HashCfgConfig *mdc)
static HashCfgConfig *	hash_cfg_config_new (const RzHashPlugin *plugin)
RZ_API RZ_BORROW const RzHashPlugin *	rz_hash_plugin_by_index (RZ_NONNULL RzHash *rh, size_t index)
RZ_API RZ_BORROW const RzHashPlugin *	rz_hash_plugin_by_name (RZ_NONNULL RzHash *rh, RZ_NONNULL const char *name)
RZ_API RZ_OWN RzHashCfg *	rz_hash_cfg_new (RZ_NONNULL RzHash *rh)
RZ_API RZ_OWN RzHashCfg *	rz_hash_cfg_new_with_algo (RZ_NONNULL RzHash *rh, RZ_NONNULL const char *name, RZ_NULLABLE const ut8 *key, ut64 key_size)
	Returns a message digest context with the give algo already configured. More...
RZ_API void	rz_hash_cfg_free (RZ_NONNULL RzHashCfg *md)
RZ_API bool	rz_hash_cfg_configure (RZ_NONNULL RzHashCfg *md, RZ_NONNULL const char *name)
	Allocates and configures the plugin message digest context. More...
RZ_API bool	rz_hash_cfg_hmac (RZ_NONNULL RzHashCfg *md, RZ_NONNULL const ut8 *key, ut64 key_size)
	Sets the key for the hmac algorithm. More...
RZ_API bool	rz_hash_cfg_init (RZ_NONNULL RzHashCfg *md)
	Resets/initialize the message digest contextes. More...
RZ_API bool	rz_hash_cfg_update (RZ_NONNULL RzHashCfg *md, RZ_NONNULL const ut8 *data, ut64 size)
	Inserts data into each the message digest contextes. More...
RZ_API bool	rz_hash_cfg_final (RZ_NONNULL RzHashCfg *md)
	Generates the final value of the message digest contextes. More...
RZ_API bool	rz_hash_cfg_iterate (RZ_NONNULL RzHashCfg *md, size_t iterate)
	Calculate the final hash by iterating its result N times. More...
RZ_API RZ_BORROW const ut8 *	rz_hash_cfg_get_result (RZ_NONNULL RzHashCfg *md, RZ_NONNULL const char *name, RZ_NONNULL ut32 *size)
	Returns the digest value of the requested algorithm name. More...
RZ_API RZ_OWN char *	rz_hash_cfg_get_result_string (RZ_NONNULL RzHashCfg *md, RZ_NONNULL const char *name, RZ_NULLABLE ut32 *size, bool invert)
	Returns the digest value of the requested algorithm name. More...
RZ_API RzHashSize	rz_hash_cfg_size (RZ_NONNULL RzHashCfg *md, RZ_NONNULL const char *name)
	Returns the digest size of the requested algorithm name. More...
RZ_API RZ_OWN ut8 *	rz_hash_cfg_calculate_small_block (RZ_NONNULL RzHash *rh, RZ_NONNULL const char *name, RZ_NONNULL const ut8 *buffer, ut64 bsize, RZ_NONNULL RzHashSize *osize)
	Returns the digest size of the requested algorithm name. More...
RZ_API RZ_OWN char *	rz_hash_cfg_calculate_small_block_string (RZ_NONNULL RzHash *rh, RZ_NONNULL const char *name, RZ_NONNULL const ut8 *buffer, ut64 bsize, RZ_NULLABLE ut32 *size, bool invert)
RZ_API RzHash *	rz_hash_new (void)
RZ_API void	rz_hash_free (RzHash *rh)
RZ_API bool	rz_hash_plugin_add (RZ_NONNULL RzHash *rh, RZ_NONNULL RZ_OWN const RzHashPlugin *plugin)
	Add a new plugin to rh so that RzHashCfg can be created using specific algorithms. More...

Variables
static const RzHashPlugin *	hash_static_plugins [] = { RZ_HASH_STATIC_PLUGINS }

Macro Definition Documentation

hash_cfg_can_final

#define hash_cfg_can_final

(

c

)

((c)->status == RZ_MSG_DIGEST_STATUS_ALLOC || (c)->status == RZ_MSG_DIGEST_STATUS_INIT || (c)->status == RZ_MSG_DIGEST_STATUS_UPDATE)

Definition at line 14 of file hash.c.

hash_cfg_can_hmac

#define hash_cfg_can_hmac

(

c

)

((c)->status == RZ_MSG_DIGEST_STATUS_ALLOC)

Definition at line 11 of file hash.c.

hash_cfg_can_init

#define hash_cfg_can_init

(

c

)

((c)->status == RZ_MSG_DIGEST_STATUS_FINAL || (c)->status == RZ_MSG_DIGEST_STATUS_ALLOC)

Definition at line 12 of file hash.c.

hash_cfg_can_update

#define hash_cfg_can_update

(

c

)

((c)->status == RZ_MSG_DIGEST_STATUS_INIT || (c)->status == RZ_MSG_DIGEST_STATUS_UPDATE)

Definition at line 13 of file hash.c.

hash_cfg_has_finshed

#define hash_cfg_has_finshed

(

c

)

((c)->status == RZ_MSG_DIGEST_STATUS_FINAL)

Definition at line 15 of file hash.c.

Typedef Documentation

HashCfgConfig

typedef struct hash_cfg_config_t HashCfgConfig

Function Documentation

hash_cfg_config_compare()

static int hash_cfg_config_compare ( const void *  value, const void *  data  )

static

Definition at line 58 of file hash.c.

                                                                        {
    const HashCfgConfig *mdc = (const HashCfgConfig *)data;
    const char *name = (const char *)value;
    return strcmp(name, mdc->plugin->name);
}

References rz_hash_plugin_t::name, hash_cfg_config_t::plugin, and value.

Referenced by rz_hash_cfg_configure(), rz_hash_cfg_get_result(), rz_hash_cfg_get_result_string(), and rz_hash_cfg_size().

hash_cfg_config_free()

static void hash_cfg_config_free ( HashCfgConfig *  mdc )

static

Definition at line 64 of file hash.c.

                                                     {
    rz_return_if_fail(mdc && mdc->plugin);
 
    mdc->plugin->context_free(mdc->context);
    free(mdc->hmac_key);
    free(mdc->digest);
    free(mdc);
}

References hash_cfg_config_t::context, rz_hash_plugin_t::context_free, hash_cfg_config_t::digest, free(), hash_cfg_config_t::hmac_key, hash_cfg_config_t::plugin, and rz_return_if_fail.

Referenced by rz_hash_cfg_configure(), and rz_hash_cfg_new().

hash_cfg_config_new()

static HashCfgConfig* hash_cfg_config_new ( const RzHashPlugin *  plugin )

static

Definition at line 73 of file hash.c.

                                                                      {
    rz_return_val_if_fail(plugin, NULL);
 
    HashCfgConfig *mdc = RZ_NEW0(HashCfgConfig);
    if (!mdc) {
        RZ_LOG_ERROR("msg digest: cannot allocate memory for config.\n");
        return NULL;
    }
 
    mdc->context = plugin->context_new();
    if (!mdc->context) {
        RZ_LOG_ERROR("msg digest: cannot allocate memory for context.\n");
        free(mdc);
        return NULL;
    }
 
    mdc->digest_size = plugin->digest_size(mdc->context);
    rz_warn_if_fail(mdc->digest_size > 0);
 
    mdc->digest = RZ_NEWS0(ut8, mdc->digest_size);
    if (!mdc->context) {
        RZ_LOG_ERROR("msg digest: cannot allocate memory for digest.\n");
        plugin->context_free(mdc->context);
        free(mdc);
        return NULL;
    }
    mdc->plugin = plugin;
 
    return mdc;
}

References hash_cfg_config_t::context, rz_hash_plugin_t::context_free, rz_hash_plugin_t::context_new, hash_cfg_config_t::digest, hash_cfg_config_t::digest_size, rz_hash_plugin_t::digest_size, free(), NULL, hash_cfg_config_t::plugin, RZ_LOG_ERROR, RZ_NEW0, RZ_NEWS0, rz_return_val_if_fail, and rz_warn_if_fail.

Referenced by rz_hash_cfg_configure().

rz_hash_cfg_calculate_small_block()

RZ_API RZ_OWN ut8* rz_hash_cfg_calculate_small_block	(	RZ_NONNULL RzHash *	rh,
		RZ_NONNULL const char *	name,
		RZ_NONNULL const ut8 *	buffer,
		ut64	bsize,
		RZ_NONNULL RzHashSize *	osize
	)

Returns the digest size of the requested algorithm name.

Returns the digest size of the initialized configuration.

Definition at line 529 of file hash.c.

                                                                                                                                                                                 {
    rz_return_val_if_fail(rh && name && buffer, NULL);
 
    ut8 *result = NULL;
    const RzHashPlugin *plugin = rz_hash_plugin_by_name(rh, name);
    if (!plugin) {
        return NULL;
    }
 
    if (!plugin->small_block(buffer, bsize, &result, osize)) {
        RZ_LOG_ERROR("msg digest: cannot calculate small block with %s.\n", plugin->name);
        return NULL;
    }
    return result;
}

References rz_hash_plugin_t::name, NULL, rz_hash_plugin_by_name(), RZ_LOG_ERROR, rz_return_val_if_fail, and rz_hash_plugin_t::small_block.

Referenced by handle_entropy(), handle_hash_cfg(), parseCodeDirectory(), rz_debug_snap_get_hash(), and rz_hash_cfg_calculate_small_block_string().

rz_hash_cfg_calculate_small_block_string()

RZ_API RZ_OWN char* rz_hash_cfg_calculate_small_block_string	(	RZ_NONNULL RzHash *	rh,
		RZ_NONNULL const char *	name,
		RZ_NONNULL const ut8 *	buffer,
		ut64	bsize,
		RZ_NULLABLE ut32 *	size,
		bool	invert
	)

Definition at line 545 of file hash.c.

                                                                                                                                                                                                {
    rz_return_val_if_fail(rh && name && buffer, NULL);
 
    ut32 pos = 0;
    RzHashSize digest_size = 0;
    ut8 *digest = NULL;
    if (!(digest = rz_hash_cfg_calculate_small_block(rh, name, buffer, bsize, &digest_size))) {
        return NULL;
    }
 
    if (!strncmp(name, "entropy", 7)) {
        double entropy = rz_read_be_double(digest);
        free(digest);
        return rz_str_newf("%.8f", entropy);
    }
 
    char *string = malloc((digest_size * 2) + 1);
    if (!string) {
        RZ_LOG_ERROR("msg digest: cannot find allocate memory for string result.\n");
        free(digest);
        return NULL;
    }
 
    for (ut32 i = 0; i < digest_size; i++) {
        pos = invert ? (digest_size - 1 - i) : i;
        sprintf(&string[i * 2], "%02x", digest[pos]);
    }
    string[digest_size * 2] = 0;
 
    if (size) {
        *size = (digest_size * 2) + 1;
    }
    free(digest);
    return string;
}

References free(), i, invert(), malloc(), NULL, pos, rz_hash_cfg_calculate_small_block(), RZ_LOG_ERROR, rz_read_be_double(), rz_return_val_if_fail, rz_str_newf(), and sprintf.

Referenced by rz_core_bin_create_digests(), and search_hash().

rz_hash_cfg_configure()

RZ_API bool rz_hash_cfg_configure	(	RZ_NONNULL RzHashCfg *	md,
		RZ_NONNULL const char *	name
	)

Allocates and configures the plugin message digest context.

message digest allocates internally a HashCfgConfig which contains all the needed informations to the plugin to work.

Definition at line 199 of file hash.c.

                                                                                         {
    rz_return_val_if_fail(md && name, false);
 
    if (rz_list_find(md->configurations, name, hash_cfg_config_compare)) {
        RZ_LOG_WARN("msg digest: '%s' was already configured; skipping.\n", name);
        return false;
    }
 
    bool is_all = !strcmp(name, "all");
 
    if (is_all && rz_list_length(md->configurations) > 0) {
        RZ_LOG_WARN("msg digest: '%s' was already configured; skipping.\n", name);
        return false;
    }
 
    HashCfgConfig *mdc = NULL;
    RzListIter *it;
    const RzHashPlugin *plugin;
 
    rz_list_foreach (md->hash->plugins, it, plugin) {
        if (is_all || !strcmp(plugin->name, name)) {
            mdc = hash_cfg_config_new(plugin);
            if (!mdc) {
                return false;
            }
 
            if (!rz_list_append(md->configurations, mdc)) {
                RZ_LOG_ERROR("msg digest: cannot allocate memory for list entry.\n");
                hash_cfg_config_free(mdc);
                return false;
            }
 
            if (!is_all) {
                return true;
            }
        }
    }
 
    if (is_all) {
        return true;
    }
 
    RZ_LOG_ERROR("msg digest: '%s' does not exists.\n", name);
    return false;
}

References hash_cfg_config_compare(), hash_cfg_config_free(), hash_cfg_config_new(), benchmark::md, rz_hash_plugin_t::name, NULL, rz_list_append(), rz_list_find(), rz_list_length(), RZ_LOG_ERROR, RZ_LOG_WARN, and rz_return_val_if_fail.

Referenced by calculate_hash(), rz_bin_file_compute_hashes(), and rz_hash_cfg_new_with_algo().

rz_hash_cfg_final()

RZ_API bool rz_hash_cfg_final

(

RZ_NONNULL RzHashCfg *

md

)

Generates the final value of the message digest contextes.

RzHashCfg contains a list of configurations; this method will call the final method of all the plugins stored in its list.

Definition at line 359 of file hash.c.

                                                        {
    rz_return_val_if_fail(md && hash_cfg_can_final(md), false);
 
    RzListIter *iter = NULL;
    HashCfgConfig *mdc = NULL;
    rz_list_foreach (md->configurations, iter, mdc) {
        if (!mdc->plugin->final(mdc->context, mdc->digest)) {
            RZ_LOG_ERROR("msg digest: failed to call final for %s.\n", mdc->plugin->name);
            return false;
        }
 
        if (mdc->hmac_key) {
            RzHashSize block_size = mdc->plugin->block_size(mdc->context);
            ut8 *o_pad = malloc(block_size);
            if (!o_pad) {
                RZ_LOG_ERROR("msg digest: failed to allocate memory for opad.\n");
                return false;
            }
 
            for (ut32 i = 0; i < block_size; i++) {
                o_pad[i] = 0x5c ^ mdc->hmac_key[i];
            }
 
            if (!mdc->plugin->init(mdc->context)) {
                RZ_LOG_ERROR("msg digest: failed to call init for hmac %s opad.\n", mdc->plugin->name);
                free(o_pad);
                return false;
            }
            if (!mdc->plugin->update(mdc->context, o_pad, block_size)) {
                RZ_LOG_ERROR("msg digest: failed to call update for hmac %s opad.\n", mdc->plugin->name);
                free(o_pad);
                return false;
            }
            free(o_pad);
            if (!mdc->plugin->update(mdc->context, mdc->digest, mdc->digest_size)) {
                RZ_LOG_ERROR("msg digest: failed to call update for hmac %s opad.\n", mdc->plugin->name);
                return false;
            }
            if (!mdc->plugin->final(mdc->context, mdc->digest)) {
                RZ_LOG_ERROR("msg digest: failed to call final for hmac %s opad.\n", mdc->plugin->name);
                return false;
            }
        }
    }
 
    md->status = RZ_MSG_DIGEST_STATUS_FINAL;
    return true;
}

References rz_hash_plugin_t::block_size, hash_cfg_config_t::context, hash_cfg_config_t::digest, hash_cfg_config_t::digest_size, rz_hash_plugin_t::final, free(), hash_cfg_can_final, hash_cfg_config_t::hmac_key, i, rz_hash_plugin_t::init, malloc(), benchmark::md, rz_hash_plugin_t::name, NULL, hash_cfg_config_t::plugin, RZ_LOG_ERROR, RZ_MSG_DIGEST_STATUS_FINAL, rz_return_val_if_fail, and rz_hash_plugin_t::update.

Referenced by _createKDNetPacket(), _initializeDatakey(), _verifyhmac(), bin_pe_compute_authentihash(), calculate_hash(), and rz_bin_file_compute_hashes().

rz_hash_cfg_free()

RZ_API void rz_hash_cfg_free

(

RZ_NONNULL RzHashCfg *

md

)

Definition at line 186 of file hash.c.

                                                       {
    rz_return_if_fail(md);
 
    rz_list_free(md->configurations);
    free(md);
}

References free(), benchmark::md, rz_list_free(), and rz_return_if_fail.

Referenced by _createKDNetPacket(), _initializeDatakey(), _verifyhmac(), bin_pe_compute_authentihash(), calculate_hash(), rz_bin_file_compute_hashes(), and rz_hash_cfg_new_with_algo().

rz_hash_cfg_get_result()

RZ_API RZ_BORROW const ut8* rz_hash_cfg_get_result	(	RZ_NONNULL RzHashCfg *	md,
		RZ_NONNULL const char *	name,
		RZ_NONNULL ut32 *	size
	)

Returns the digest value of the requested algorithm name.

RzHashCfg contains a list of configurations; this method will search for the configuration with the given name and if found return the digest value.

Definition at line 445 of file hash.c.

                                                                                                                                 {
    rz_return_val_if_fail(md && name && hash_cfg_has_finshed(md), false);
 
    RzListIter *it = rz_list_find(md->configurations, name, hash_cfg_config_compare);
    if (!it) {
        RZ_LOG_ERROR("msg digest: cannot find configuration for '%s' algorithm.\n", name);
        return NULL;
    }
 
    HashCfgConfig *mdc = (HashCfgConfig *)rz_list_iter_get_data(it);
    rz_return_val_if_fail(mdc, NULL);
 
    if (size) {
        *size = mdc->digest_size;
    }
    return mdc->digest;
}

References hash_cfg_config_t::digest, hash_cfg_config_t::digest_size, hash_cfg_config_compare(), hash_cfg_has_finshed, benchmark::md, NULL, rz_list_find(), rz_list_iter_get_data(), RZ_LOG_ERROR, and rz_return_val_if_fail.

Referenced by _createKDNetPacket(), _initializeDatakey(), _verifyhmac(), add_file_hash(), bin_pe_compute_authentihash(), calculate_hash(), and hash_print_digest().

rz_hash_cfg_get_result_string()

RZ_API RZ_OWN char* rz_hash_cfg_get_result_string	(	RZ_NONNULL RzHashCfg *	md,
		RZ_NONNULL const char *	name,
		RZ_NULLABLE ut32 *	size,
		bool	invert
	)

Returns the digest value of the requested algorithm name.

RzHashCfg contains a list of configurations; this method will search for the configuration with the given name and if found return the digest value.

Definition at line 469 of file hash.c.

                                                                                                                                              {
    rz_return_val_if_fail(md && name && hash_cfg_has_finshed(md), false);
 
    ut32 pos = 0;
    RzListIter *it = rz_list_find(md->configurations, name, hash_cfg_config_compare);
    if (!it) {
        RZ_LOG_ERROR("msg digest: cannot find configuration for '%s' algorithm.\n", name);
        return NULL;
    }
 
    HashCfgConfig *mdc = (HashCfgConfig *)rz_list_iter_get_data(it);
    rz_return_val_if_fail(mdc, NULL);
 
    if (!strncmp(name, "entropy", 7)) {
        double entropy = rz_read_be_double(mdc->digest);
        return rz_str_newf("%.8f", entropy);
    }
 
    char *string = malloc((mdc->digest_size * 2) + 1);
    if (!string) {
        RZ_LOG_ERROR("msg digest: cannot find allocate memory for string result.\n");
        return NULL;
    }
 
    for (ut32 i = 0; i < mdc->digest_size; i++) {
        pos = invert ? (mdc->digest_size - 1 - i) : i;
        sprintf(&string[i * 2], "%02x", mdc->digest[pos]);
    }
    string[mdc->digest_size * 2] = 0;
 
    if (size) {
        *size = (mdc->digest_size * 2) + 1;
    }
    return string;
}

References hash_cfg_config_t::digest, hash_cfg_config_t::digest_size, hash_cfg_config_compare(), hash_cfg_has_finshed, i, invert(), malloc(), benchmark::md, NULL, pos, rz_list_find(), rz_list_iter_get_data(), RZ_LOG_ERROR, rz_read_be_double(), rz_return_val_if_fail, rz_str_newf(), and sprintf.

Referenced by hash_print_digest().

rz_hash_cfg_hmac()

RZ_API bool rz_hash_cfg_hmac	(	RZ_NONNULL RzHashCfg *	md,
		RZ_NONNULL const ut8 *	key,
		ut64	key_size
	)

Sets the key for the hmac algorithm.

message digest sets the hmac key

Definition at line 250 of file hash.c.

                                                                                                 {
    rz_return_val_if_fail(md && key && key_size && hash_cfg_can_hmac(md), false);
 
    RzHashSize block_size = 0;
    RzListIter *iter = NULL;
    HashCfgConfig *mdc = NULL;
    rz_list_foreach (md->configurations, iter, mdc) {
        if (!mdc->plugin->support_hmac) {
            // RZ_LOG_ERROR("msg digest: hmac is not supported by %s.\n", mdc->plugin->name);
            continue;
        }
 
        block_size = mdc->plugin->block_size(mdc->context);
        if (block_size < 1) {
            RZ_LOG_ERROR("msg digest: hmac block size is < 1.\n");
            return false;
        }
 
        mdc->hmac_key = malloc(block_size);
        if (!mdc->hmac_key) {
            RZ_LOG_ERROR("msg digest: cannot allocate memory for hmac key.\n");
            return false;
        }
 
        memset(mdc->hmac_key, 0, block_size);
        if (block_size < key_size) {
            RzHashSize tmp_size;
            ut8 *tmp = NULL;
            if (!mdc->plugin->small_block(key, key_size, &tmp, &tmp_size)) {
                RZ_LOG_ERROR("msg digest: failed to call init for hmac %s key.\n", mdc->plugin->name);
                return false;
            }
            memcpy(mdc->hmac_key, tmp, tmp_size);
            free(tmp);
        } else {
            memcpy(mdc->hmac_key, key, key_size);
        }
    }
 
    return true;
}

References rz_hash_plugin_t::block_size, hash_cfg_config_t::context, free(), hash_cfg_can_hmac, hash_cfg_config_t::hmac_key, key, malloc(), benchmark::md, memcpy(), memset(), rz_hash_plugin_t::name, NULL, hash_cfg_config_t::plugin, RZ_LOG_ERROR, rz_return_val_if_fail, rz_hash_plugin_t::small_block, rz_hash_plugin_t::support_hmac, and autogen_x86imm::tmp.

Referenced by calculate_hash(), and rz_hash_cfg_new_with_algo().

rz_hash_cfg_init()

RZ_API bool rz_hash_cfg_init

(

RZ_NONNULL RzHashCfg *

md

)

Resets/initialize the message digest contextes.

RzHashCfg contains a list of configurations; this method will call the init method of all the plugins stored in its list.

Definition at line 298 of file hash.c.

                                                       {
    rz_return_val_if_fail(md && hash_cfg_can_init(md), false);
 
    RzListIter *iter = NULL;
    HashCfgConfig *mdc = NULL;
    rz_list_foreach (md->configurations, iter, mdc) {
        if (!mdc->plugin->init(mdc->context)) {
            RZ_LOG_ERROR("msg digest: failed to call init for %s.\n", mdc->plugin->name);
            return false;
        }
        if (mdc->hmac_key) {
            RzHashSize block_size = mdc->plugin->block_size(mdc->context);
            ut8 *i_pad = malloc(block_size);
            if (!i_pad) {
                RZ_LOG_ERROR("msg digest: failed to allocate memory for ipad.\n");
                return false;
            }
            for (ut32 i = 0; i < block_size; i++) {
                i_pad[i] = 0x36 ^ mdc->hmac_key[i];
            }
            if (!mdc->plugin->update(mdc->context, i_pad, block_size)) {
                RZ_LOG_ERROR("msg digest: failed to call update for hmac %s ipad.\n", mdc->plugin->name);
                free(i_pad);
                return false;
            }
            free(i_pad);
        }
    }
 
    md->status = RZ_MSG_DIGEST_STATUS_INIT;
    return true;
}

References rz_hash_plugin_t::block_size, hash_cfg_config_t::context, free(), hash_cfg_can_init, hash_cfg_config_t::hmac_key, i, rz_hash_plugin_t::init, malloc(), benchmark::md, rz_hash_plugin_t::name, NULL, hash_cfg_config_t::plugin, RZ_LOG_ERROR, RZ_MSG_DIGEST_STATUS_INIT, rz_return_val_if_fail, and rz_hash_plugin_t::update.

Referenced by calculate_hash(), rz_bin_file_compute_hashes(), and rz_hash_cfg_new_with_algo().

rz_hash_cfg_iterate()

RZ_API bool rz_hash_cfg_iterate	(	RZ_NONNULL RzHashCfg *	md,
		size_t	iterate
	)

Calculate the final hash by iterating its result N times.

RzHashCfg contains a list of configurations; this method will iterate N times each configuration final result.

Definition at line 414 of file hash.c.

                                                                          {
    rz_return_val_if_fail(md && hash_cfg_has_finshed(md), false);
 
    RzListIter *iter = NULL;
    HashCfgConfig *mdc = NULL;
    rz_list_foreach (md->configurations, iter, mdc) {
        for (size_t i = 0; i < iterate; ++i) {
            if (!mdc->plugin->init(mdc->context)) {
                RZ_LOG_ERROR("msg digest: failed to call init %s for iteration.\n", mdc->plugin->name);
                return false;
            }
            if (!mdc->plugin->update(mdc->context, mdc->digest, mdc->digest_size)) {
                RZ_LOG_ERROR("msg digest: failed to call update %s for iteration.\n", mdc->plugin->name);
                return false;
            }
            if (!mdc->plugin->final(mdc->context, mdc->digest)) {
                RZ_LOG_ERROR("msg digest: failed to call final %s for iteration.\n", mdc->plugin->name);
                return false;
            }
        }
    }
 
    return true;
}

References hash_cfg_config_t::context, hash_cfg_config_t::digest, hash_cfg_config_t::digest_size, rz_hash_plugin_t::final, hash_cfg_has_finshed, i, rz_hash_plugin_t::init, benchmark::md, rz_hash_plugin_t::name, NULL, hash_cfg_config_t::plugin, RZ_LOG_ERROR, rz_return_val_if_fail, and rz_hash_plugin_t::update.

Referenced by calculate_hash().

rz_hash_cfg_new()

RZ_API RZ_OWN RzHashCfg* rz_hash_cfg_new

(

RZ_NONNULL RzHash *

rh

)

Definition at line 134 of file hash.c.

                                                                {
    rz_return_val_if_fail(rh, NULL);
 
    RzHashCfg *md = RZ_NEW0(RzHashCfg);
    if (!md) {
        RZ_LOG_ERROR("msg digest: cannot allocate memory.\n");
        return NULL;
    }
 
    md->configurations = rz_list_newf((RzListFree)hash_cfg_config_free);
    if (!md->configurations) {
        RZ_LOG_ERROR("msg digest: cannot allocate memory for the configurations.\n");
        free(md);
        return NULL;
    }
    md->hash = rh;
 
    return md;
}

References free(), hash_cfg_config_free(), benchmark::md, NULL, rz_list_newf(), RZ_LOG_ERROR, RZ_NEW0, and rz_return_val_if_fail.

Referenced by calculate_hash(), rz_bin_file_compute_hashes(), and rz_hash_cfg_new_with_algo().

rz_hash_cfg_new_with_algo()

RZ_API RZ_OWN RzHashCfg* rz_hash_cfg_new_with_algo	(	RZ_NONNULL RzHash *	rh,
		RZ_NONNULL const char *	name,
		RZ_NULLABLE const ut8 *	key,
		ut64	key_size
	)

Returns a message digest context with the give algo already configured.

message digest allocates and configures already the structure with the given algorithm and runs also the algo init. when fails to allocate or configure or initialize, returns NULL.

Definition at line 161 of file hash.c.

                                                                                                                                                  {
    rz_return_val_if_fail(rh && name, NULL);
    RzHashCfg *md = rz_hash_cfg_new(rh);
    if (!md) {
        return NULL;
    }
 
    if (!rz_hash_cfg_configure(md, name)) {
        rz_hash_cfg_free(md);
        return NULL;
    }
 
    if (key && !rz_hash_cfg_hmac(md, key, key_size)) {
        rz_hash_cfg_free(md);
        return NULL;
    }
 
    if (!rz_hash_cfg_init(md)) {
        rz_hash_cfg_free(md);
        return NULL;
    }
 
    return md;
}

References key, benchmark::md, NULL, rz_hash_cfg_configure(), rz_hash_cfg_free(), rz_hash_cfg_hmac(), rz_hash_cfg_init(), rz_hash_cfg_new(), and rz_return_val_if_fail.

Referenced by _createKDNetPacket(), and _verifyhmac().

rz_hash_cfg_size()

RZ_API RzHashSize rz_hash_cfg_size	(	RZ_NONNULL RzHashCfg *	md,
		RZ_NONNULL const char *	name
	)

Returns the digest size of the requested algorithm name.

Returns the digest size of the initialized configuration.

Definition at line 510 of file hash.c.

                                                                                          {
    rz_return_val_if_fail(md && name, 0);
 
    RzListIter *it = rz_list_find(md->configurations, name, hash_cfg_config_compare);
    if (!it) {
        RZ_LOG_ERROR("msg digest: cannot find configuration for '%s' algorithm.\n", name);
        return 0;
    }
 
    HashCfgConfig *mdc = (HashCfgConfig *)rz_list_iter_get_data(it);
    rz_return_val_if_fail(mdc, 0);
    return mdc->plugin->digest_size(mdc->context);
}

References hash_cfg_config_t::context, rz_hash_plugin_t::digest_size, hash_cfg_config_compare(), benchmark::md, hash_cfg_config_t::plugin, rz_list_find(), rz_list_iter_get_data(), RZ_LOG_ERROR, and rz_return_val_if_fail.

rz_hash_cfg_update()

RZ_API bool rz_hash_cfg_update	(	RZ_NONNULL RzHashCfg *	md,
		RZ_NONNULL const ut8 *	data,
		ut64	size
	)

Inserts data into each the message digest contextes.

RzHashCfg contains a list of configurations; this method will call the update method of all the plugins stored in its list.

Definition at line 337 of file hash.c.

                                                                                                {
    rz_return_val_if_fail(md && hash_cfg_can_update(md), false);
 
    RzListIter *iter = NULL;
    HashCfgConfig *mdc = NULL;
    rz_list_foreach (md->configurations, iter, mdc) {
        if (!mdc->plugin->update(mdc->context, data, size)) {
            RZ_LOG_ERROR("msg digest: failed to call update for %s.\n", mdc->plugin->name);
            return false;
        }
    }
 
    md->status = RZ_MSG_DIGEST_STATUS_UPDATE;
    return true;
}

References hash_cfg_config_t::context, hash_cfg_can_update, benchmark::md, rz_hash_plugin_t::name, NULL, hash_cfg_config_t::plugin, RZ_LOG_ERROR, RZ_MSG_DIGEST_STATUS_UPDATE, rz_return_val_if_fail, and rz_hash_plugin_t::update.

Referenced by _createKDNetPacket(), _initializeDatakey(), _verifyhmac(), buf_compute_hashes(), buf_fwd_hash(), and calculate_hash().

rz_hash_entropy()

RZ_API double rz_hash_entropy	(	RZ_NONNULL RzHash *	rh,
		RZ_NONNULL const ut8 *	data,
		ut64	len
	)

Definition at line 32 of file hash.c.

                                                                                           {
    rz_return_val_if_fail(data, 0.0);
    const RzHashPlugin *plugin = &rz_hash_plugin_entropy;
    ut8 *digest = NULL;
    if (!plugin->small_block(data, len, &digest, NULL)) {
        RZ_LOG_ERROR("msg digest: cannot calculate entropy\n");
        return 0.0;
    }
    double e = rz_read_be_double(digest);
    free(digest);
    return e;
}

References e, free(), len, NULL, rz_hash_plugin_entropy, RZ_LOG_ERROR, rz_read_be_double(), rz_return_val_if_fail, and rz_hash_plugin_t::small_block.

Referenced by do_section_search().

rz_hash_entropy_fraction()

RZ_API double rz_hash_entropy_fraction	(	RZ_NONNULL RzHash *	rh,
		RZ_NONNULL const ut8 *	data,
		ut64	len
	)

Definition at line 45 of file hash.c.

                                                                                                    {
    rz_return_val_if_fail(data, 0.0);
    const RzHashPlugin *plugin = &rz_hash_plugin_entropy_fract;
    ut8 *digest = NULL;
    if (!plugin->small_block(data, len, &digest, NULL)) {
        RZ_LOG_ERROR("msg digest: cannot calculate entropy fraction\n");
        return 0.0;
    }
    double e = rz_read_be_double(digest);
    free(digest);
    return e;
}

References e, free(), len, NULL, rz_hash_plugin_entropy_fract, RZ_LOG_ERROR, rz_read_be_double(), rz_return_val_if_fail, and rz_hash_plugin_t::small_block.

Referenced by cmd_p_minus_e(), and cmd_print_bars().

rz_hash_free()

RZ_API void rz_hash_free

(

RzHash *

rh

)

Definition at line 597 of file hash.c.

                                     {
    if (!rh) {
        return;
    }
    rz_list_free(rh->plugins);
    free(rh);
}

References free(), rz_hash_t::plugins, and rz_list_free().

Referenced by hash_context_fini(), iob_net_close(), mach0_free(), rz_analysis_free(), rz_bin_free(), rz_bin_pe_free(), rz_core_fini(), and rz_debug_free().

rz_hash_new()

RZ_API RzHash* rz_hash_new

(

void

)

Create a new RzHash object where plugins can be registered and specific configurations can be created from.

Definition at line 585 of file hash.c.

                                 {
    RzHash *rh = RZ_NEW0(RzHash);
    if (!rh) {
        return NULL;
    }
    rh->plugins = rz_list_new();
    for (int i = 0; i < RZ_ARRAY_SIZE(hash_static_plugins); i++) {
        rz_hash_plugin_add(rh, hash_static_plugins[i]);
    }
    return rh;
}

References hash_static_plugins, i, NULL, rz_hash_t::plugins, RZ_ARRAY_SIZE, rz_hash_plugin_add(), rz_list_new(), and RZ_NEW0.

Referenced by iob_net_open(), rz_analysis_new(), rz_bin_new(), rz_bin_pe_new_buf(), rz_core_init(), rz_debug_new(), and rz_main_rz_hash().

rz_hash_plugin_add()

RZ_API bool rz_hash_plugin_add	(	RZ_NONNULL RzHash *	rh,
		RZ_NONNULL RZ_OWN const RzHashPlugin *	plugin
	)

Add a new plugin to rh so that RzHashCfg can be created using specific algorithms.

Definition at line 609 of file hash.c.

                                                                                                    {
    if (!plugin) {
        return false;
    }
    RzListIter *it;
    RzHashPlugin *p;
 
    rz_list_foreach (rh->plugins, it, p) {
        if (!strcmp(p->name, plugin->name)) {
            return false;
        }
    }
    rz_list_append(rh->plugins, (RzHashPlugin *)plugin);
    return true;
}

References p, and rz_list_append().

Referenced by lib_hash_cb(), and rz_hash_new().

rz_hash_plugin_by_index()

RZ_API RZ_BORROW const RzHashPlugin* rz_hash_plugin_by_index	(	RZ_NONNULL RzHash *	rh,
		size_t	index
	)

Definition at line 104 of file hash.c.

                                                                                                  {
    rz_return_val_if_fail(rh, NULL);
 
    RzListIter *it;
    const RzHashPlugin *rhp;
    size_t i = 0;
 
    rz_list_foreach (rh->plugins, it, rhp) {
        if (i == index) {
            return rhp;
        }
        i++;
    }
    return NULL;
}

References i, NULL, and rz_return_val_if_fail.

Referenced by parse_hash_algorithms(), and rz_hash_show_algorithms().

rz_hash_plugin_by_name()

RZ_API RZ_BORROW const RzHashPlugin* rz_hash_plugin_by_name	(	RZ_NONNULL RzHash *	rh,
		RZ_NONNULL const char *	name
	)

Definition at line 120 of file hash.c.

                                                                                                                {
    rz_return_val_if_fail(name && rh, NULL);
 
    RzListIter *it;
    const RzHashPlugin *rhp;
 
    rz_list_foreach (rh->plugins, it, rhp) {
        if (!strcmp(rhp->name, name)) {
            return rhp;
        }
    }
    return NULL;
}

References rz_hash_plugin_t::name, NULL, and rz_return_val_if_fail.

Referenced by rz_cmd_print_hash_cfg_handler(), rz_core_bin_resources_print(), rz_core_bin_segments_print(), rz_hash_cfg_calculate_small_block(), search_collisions(), and sections_headers_setup().

rz_hash_xxhash()

RZ_API ut32 rz_hash_xxhash	(	RZ_NONNULL RzHash *	rh,
		RZ_NONNULL const ut8 *	input,
		size_t	size
	)

Definition at line 27 of file hash.c.

                                                                                            {
    rz_return_val_if_fail(input, 0);
    return XXH32(input, size, 0);
}

References input(), rz_return_val_if_fail, and XXH32().

Referenced by rz_analysis_block_update_hash(), and rz_analysis_block_was_modified().

RZ_LIB_VERSION()

RZ_LIB_VERSION

(

rz_hash

)

Variable Documentation

hash_static_plugins

const RzHashPlugin* hash_static_plugins[] = { RZ_HASH_STATIC_PLUGINS }

static

Definition at line 25 of file hash.c.

Referenced by rz_hash_new().