rz-hash.c File Reference

#include <stdio.h>
#include <string.h>
#include <rz_io.h>
#include <rz_main.h>
#include <rz_hash.h>
#include <rz_util/rz_print.h>
#include <rz_util.h>
#include <rz_crypto.h>
#include <rz_lib.h>

Go to the source code of this file.

Classes
struct	RzHashBuffer
struct	RzHashOffset
struct	rz_hash_context

Macros
#define	RZ_HASH_DEFAULT_BLOCK_SIZE   0x1000
#define	rz_hash_bool_error(x, o, f, ...)
#define	rz_hash_error(x, o, f, ...)
#define	rz_hash_set_val(x, k, d, v)
#define	rz_hash_ctx_set_val(x, k, d, v)
#define	rz_hash_ctx_set_bool(x, k, i, t, f)
#define	rz_hash_ctx_set_quiet(x)
#define	rz_hash_ctx_set_signed(x, k, i)
#define	rz_hash_ctx_set_unsigned(x, k, i)
#define	rz_hash_ctx_set_input(x, k, s, h)
#define	rz_hash_ctx_set_mode(x, m)   rz_hash_ctx_set_val(x, mode, RZ_HASH_MODE_STANDARD, m)
#define	rz_hash_ctx_set_op(x, o)   rz_hash_ctx_set_val(x, operation, RZ_HASH_OP_UNKNOWN, o)
#define	rz_hash_ctx_set_str(x, k, s)   rz_hash_ctx_set_val(x, k, NULL, strdup(s))

Typedefs
typedef struct rz_hash_context	RzHashContext
typedef bool(*	RzHashRun) (RzHashContext *ctx, RzIO *io, const char *filename)

Enumerations
enum	RzHashMode {   RZ_HASH_MODE_STANDARD = 0 , RZ_HASH_MODE_JSON , RZ_HASH_MODE_RANDOMART , RZ_HASH_MODE_QUIET ,   RZ_HASH_MODE_VERY_QUIET }
enum	RzHashOp {   RZ_HASH_OP_UNKNOWN = 0 , RZ_HASH_OP_ERROR , RZ_HASH_OP_HELP , RZ_HASH_OP_USAGE ,   RZ_HASH_OP_VERSION , RZ_HASH_OP_LIST_ALGO , RZ_HASH_OP_HASH , RZ_HASH_OP_DECRYPT ,   RZ_HASH_OP_ENCRYPT , RZ_HASH_OP_LUHN }

Functions
static void	rz_hash_show_help (bool usage_only)
static void	rz_hash_show_algorithms (RzHashContext *ctx)
static bool	hash_parse_string (const char *option, const char *string, ut8 **buffer, size_t *bufsize)
static bool	hash_parse_hexadecimal (const char *option, const char *hexadecimal, ut8 **buffer, size_t *bufsize)
static bool	hash_parse_any (RzHashContext *ctx, const char *option, const char *arg, RzHashBuffer *hb)
static void	hash_parse_cmdline (int argc, const char **argv, RzHashContext *ctx)
static void	hash_context_fini (RzHashContext *ctx)
static RzIODesc *	hash_context_create_desc_io_stdin (RzIO *io)
static RzIODesc *	hash_context_create_desc_io_string (RzIO *io, const char *input)
static bool	hash_context_run (RzHashContext *ctx, RzHashRun run)
static void	hash_print_crypto (RzHashContext *ctx, const char *hname, const ut8 *buffer, int len, ut64 from, ut64 to)
static void	hash_print_digest (RzHashContext *ctx, RzHashCfg *md, const char *hname, ut64 from, ut64 to, const char *filename)
static void	hash_context_compare_hashes (RzHashContext *ctx, size_t filesize, bool result, const char *hname, const char *filename)
static RzList *	parse_hash_algorithms (RzHashContext *ctx)
static bool	calculate_hash (RzHashContext *ctx, RzIO *io, const char *filename)
static bool	calculate_decrypt (RzHashContext *ctx, RzIO *io, const char *filename)
static bool	calculate_encrypt (RzHashContext *ctx, RzIO *io, const char *filename)
static bool	calculate_luhn (RzHashContext *ctx, RzIO *io, const char *filename)
static int	lib_hash_cb (RzLibPlugin *pl, void *user, void *data)
static void	hash_load_plugins (RzHashContext *ctx)
RZ_API int	rz_main_rz_hash (int argc, const char **argv)

Macro Definition Documentation

rz_hash_bool_error

#define rz_hash_bool_error	(		x,
			o,
			f,
			...
	)

Value:

    (x)->operation = o; \
    RZ_LOG_ERROR("rz-hash: error, " f, ##__VA_ARGS__); \
    return false;

Definition at line 141 of file rz-hash.c.

rz_hash_ctx_set_bool

#define rz_hash_ctx_set_bool	(		x,
			k,
			i,
			t,
			f
	)

Value:

    do { \
        if (i && !strcmp(i, t)) { \
            (x)->k = true; \
        } else if (i && !strcmp(i, f)) { \
            (x)->k = false; \
        } else { \
            rz_hash_error(x, RZ_HASH_OP_UNKNOWN, "expected '%s' or '%s' but got '%s'\n", t, f, i); \
        } \
    } while (0)

Definition at line 167 of file rz-hash.c.

rz_hash_ctx_set_input

#define rz_hash_ctx_set_input	(		x,
			k,
			s,
			h
	)

Value:

    do { \
        if ((x)->k) { \
            rz_hash_error(x, RZ_HASH_OP_UNKNOWN, "invalid combination of arguments for '-%c'\n", c); \
        } else if (h || strlen(s) < 1) { \
            (x)->k = strdup(s); \
        } else { \
            (x)->k = rz_str_newf("s:%s", s); \
        } \
    } while (0)

Definition at line 207 of file rz-hash.c.

rz_hash_ctx_set_mode

#define rz_hash_ctx_set_mode	(		x,
			m
	)		rz_hash_ctx_set_val(x, mode, RZ_HASH_MODE_STANDARD, m)

Definition at line 218 of file rz-hash.c.

rz_hash_ctx_set_op

#define rz_hash_ctx_set_op	(		x,
			o
	)		rz_hash_ctx_set_val(x, operation, RZ_HASH_OP_UNKNOWN, o)

Definition at line 219 of file rz-hash.c.

rz_hash_ctx_set_quiet

#define rz_hash_ctx_set_quiet

(

x

)

Value:

    do { \
        if ((x)->mode == RZ_HASH_MODE_STANDARD) { \
            (x)->mode = RZ_HASH_MODE_QUIET; \
        } else if ((x)->mode == RZ_HASH_MODE_QUIET) { \
            (x)->mode = RZ_HASH_MODE_VERY_QUIET; \
        } else if ((x)->mode == RZ_HASH_MODE_JSON) { \
            rz_hash_error(x, RZ_HASH_OP_UNKNOWN, "can't be quiet when json mode is selected\n"); \
        } else if ((x)->mode == RZ_HASH_MODE_RANDOMART) { \
            rz_hash_error(x, RZ_HASH_OP_UNKNOWN, "can't be quiet when openssh mode is selected\n"); \
        } \
    } while (0)

Definition at line 178 of file rz-hash.c.

rz_hash_ctx_set_signed

#define rz_hash_ctx_set_signed	(		x,
			k,
			i
	)

Value:

    do { \
        (x)->k = strtoll((i), NULL, 0); \
        if ((x)->k < 1) { \
            rz_hash_error(x, RZ_HASH_OP_UNKNOWN, "argument must be > 0\n"); \
        } \
    } while (0)

Definition at line 191 of file rz-hash.c.

rz_hash_ctx_set_str

#define rz_hash_ctx_set_str	(		x,
			k,
			s
	)		rz_hash_ctx_set_val(x, k, NULL, strdup(s))

Definition at line 220 of file rz-hash.c.

rz_hash_ctx_set_unsigned

#define rz_hash_ctx_set_unsigned	(		x,
			k,
			i
	)

Value:

    do { \
        (x)->k = strtoull((i), NULL, 0); \
        if ((x)->k < 1) { \
            rz_hash_error(x, RZ_HASH_OP_UNKNOWN, "argument must be > 0\n"); \
        } \
    } while (0)

Definition at line 199 of file rz-hash.c.

rz_hash_ctx_set_val

#define rz_hash_ctx_set_val	(		x,
			k,
			d,
			v
	)

Value:

    do { \
        if ((x)->k != (d)) { \
            rz_hash_error(x, RZ_HASH_OP_UNKNOWN, "invalid combination of arguments for '-%c' (expected " #d " but found something else)\n", c); \
        } \
        (x)->k = (v); \
    } while (0)

Definition at line 159 of file rz-hash.c.

RZ_HASH_DEFAULT_BLOCK_SIZE

#define RZ_HASH_DEFAULT_BLOCK_SIZE   0x1000

Definition at line 14 of file rz-hash.c.

rz_hash_error

#define rz_hash_error	(		x,
			o,
			f,
			...
	)

Value:

    (x)->operation = o; \
    RZ_LOG_ERROR("rz-hash: error, " f, ##__VA_ARGS__); \
    return;

Definition at line 146 of file rz-hash.c.

rz_hash_set_val

#define rz_hash_set_val	(		x,
			k,
			d,
			v
	)

Value:

    do { \
        if ((k) != (d)) { \
            rz_hash_error(x, RZ_HASH_OP_UNKNOWN, "invalid combination of arguments for '-%c' (expected " #d " but found something else)\n", c); \
        } \
        (k) = (v); \
    } while (0)

Definition at line 151 of file rz-hash.c.

Typedef Documentation

RzHashContext

typedef struct rz_hash_context RzHashContext

RzHashRun

typedef bool(* RzHashRun) (RzHashContext *ctx, RzIO *io, const char *filename)

Definition at line 70 of file rz-hash.c.

Enumeration Type Documentation

RzHashMode

enum RzHashMode

Enumerator
RZ_HASH_MODE_STANDARD
RZ_HASH_MODE_JSON
RZ_HASH_MODE_RANDOMART
RZ_HASH_MODE_QUIET
RZ_HASH_MODE_VERY_QUIET

Definition at line 21 of file rz-hash.c.

             {
    RZ_HASH_MODE_STANDARD = 0,
    RZ_HASH_MODE_JSON,
    RZ_HASH_MODE_RANDOMART,
    RZ_HASH_MODE_QUIET,
    RZ_HASH_MODE_VERY_QUIET,
} RzHashMode;

RzHashOp

enum RzHashOp

Enumerator
RZ_HASH_OP_UNKNOWN
RZ_HASH_OP_ERROR
RZ_HASH_OP_HELP
RZ_HASH_OP_USAGE
RZ_HASH_OP_VERSION
RZ_HASH_OP_LIST_ALGO
RZ_HASH_OP_HASH
RZ_HASH_OP_DECRYPT
RZ_HASH_OP_ENCRYPT
RZ_HASH_OP_LUHN

Definition at line 29 of file rz-hash.c.

             {
    RZ_HASH_OP_UNKNOWN = 0,
    RZ_HASH_OP_ERROR,
    RZ_HASH_OP_HELP,
    RZ_HASH_OP_USAGE,
    RZ_HASH_OP_VERSION,
    RZ_HASH_OP_LIST_ALGO,
    RZ_HASH_OP_HASH,
    RZ_HASH_OP_DECRYPT,
    RZ_HASH_OP_ENCRYPT,
    RZ_HASH_OP_LUHN,
} RzHashOp;

Function Documentation

calculate_decrypt()

static bool calculate_decrypt ( RzHashContext *  ctx, RzIO *  io, const char *  filename  )

static

Definition at line 977 of file rz-hash.c.

                                                                                  {
    RzCrypto *cry = NULL;
    bool result = false;
    ut8 *iv = NULL;
    size_t ivlen = 0;
    ut64 filesize = 0;
    ut64 bsize = 0;
    ut8 *block = NULL;
 
    if (ctx->iv) {
        if (!strncmp(ctx->iv, "s:", 2)) {
            if (!hash_parse_string("-I", ctx->iv + 2, &iv, &ivlen)) {
                goto calculate_decrypt_end;
            }
        } else {
            if (!hash_parse_hexadecimal("-I", ctx->iv, &iv, &ivlen)) {
                goto calculate_decrypt_end;
            }
        }
    }
 
    cry = rz_crypto_new();
    if (!cry) {
        RZ_LOG_ERROR("rz-hash: error, failed to allocate memory\n");
        goto calculate_decrypt_end;
    }
 
    if (!rz_crypto_use(cry, ctx->algorithm)) {
        RZ_LOG_ERROR("rz-hash: error, unknown encryption algorithm '%s'\n", ctx->algorithm);
        goto calculate_decrypt_end;
    }
 
    if (!rz_crypto_set_key(cry, ctx->key.buf, ctx->key.len, 0, RZ_CRYPTO_DIR_DECRYPT)) {
        RZ_LOG_ERROR("rz-hash: error, invalid key\n");
        goto calculate_decrypt_end;
    }
 
    if (iv && !rz_crypto_set_iv(cry, iv, ivlen)) {
        RZ_LOG_ERROR("rz-hash: error, invalid IV.\n");
        goto calculate_decrypt_end;
    }
 
    filesize = rz_io_desc_size(io->desc);
    if (filesize < 1) {
        RZ_LOG_ERROR("rz-hash: error, file size is less than 1\n");
        goto calculate_decrypt_end;
    }
 
    bsize = ctx->block_size;
    block = malloc(bsize);
    if (!block) {
        RZ_LOG_ERROR("rz-hash: error, cannot allocate block memory\n");
        goto calculate_decrypt_end;
    }
 
    ut64 to = ctx->offset.to ? ctx->offset.to : filesize;
    for (ut64 j = ctx->offset.from; j < to; j += bsize) {
        int read = rz_io_pread_at(io, j, block, to - j > bsize ? bsize : (to - j));
        rz_crypto_update(cry, block, read);
    }
 
    rz_crypto_final(cry, NULL, 0);
 
    int plaintext_size = 0;
    const ut8 *plaintext = rz_crypto_get_output(cry, &plaintext_size);
 
    hash_print_crypto(ctx, ctx->algorithm, plaintext, plaintext_size, ctx->offset.from, to);
    result = true;
 
calculate_decrypt_end:
    free(block);
    free(iv);
    rz_crypto_free(cry);
    return result;
}

References rz_io_t::desc, free(), hash_parse_hexadecimal(), hash_parse_string(), hash_print_crypto(), malloc(), NULL, read(), RZ_CRYPTO_DIR_DECRYPT, rz_crypto_final(), rz_crypto_free(), rz_crypto_get_output(), rz_crypto_new(), rz_crypto_set_iv(), rz_crypto_set_key(), rz_crypto_update(), rz_crypto_use(), rz_io_desc_size(), rz_io_pread_at(), RZ_LOG_ERROR, to, and ut64().

Referenced by rz_main_rz_hash().

calculate_encrypt()

static bool calculate_encrypt ( RzHashContext *  ctx, RzIO *  io, const char *  filename  )

static

Definition at line 1053 of file rz-hash.c.

                                                                                  {
    RzCrypto *cry = NULL;
    bool result = false;
    ut8 *iv = NULL;
    size_t ivlen = 0;
    ut64 filesize = 0;
    ut64 bsize = 0;
    ut8 *block = NULL;
 
    bool requires_key = !strncmp("base", ctx->algorithm, 4) || !strcmp("punycode", ctx->algorithm);
    if (!requires_key && ctx->key.len < 1) {
        RZ_LOG_ERROR("rz-hash: error, cannot encrypt without a key\n");
        goto calculate_encrypt_end;
    }
 
    if (ctx->iv) {
        if (!strncmp(ctx->iv, "s:", 2)) {
            if (!hash_parse_string("-I", ctx->iv + 2, &iv, &ivlen)) {
                goto calculate_encrypt_end;
            }
        } else {
            if (!hash_parse_hexadecimal("-I", ctx->iv, &iv, &ivlen)) {
                goto calculate_encrypt_end;
            }
        }
    }
 
    cry = rz_crypto_new();
    if (!cry) {
        RZ_LOG_ERROR("rz-hash: error, failed to allocate memory\n");
        goto calculate_encrypt_end;
    }
 
    if (!rz_crypto_use(cry, ctx->algorithm)) {
        RZ_LOG_ERROR("rz-hash: error, unknown encryption algorithm '%s'\n", ctx->algorithm);
        goto calculate_encrypt_end;
    }
 
    if (!rz_crypto_set_key(cry, ctx->key.buf, ctx->key.len, 0, RZ_CRYPTO_DIR_ENCRYPT)) {
        RZ_LOG_ERROR("rz-hash: error, invalid key\n");
        goto calculate_encrypt_end;
    }
 
    if (iv && !rz_crypto_set_iv(cry, iv, ivlen)) {
        RZ_LOG_ERROR("rz-hash: error, invalid IV.\n");
        goto calculate_encrypt_end;
    }
 
    filesize = rz_io_desc_size(io->desc);
    if (filesize < 1) {
        RZ_LOG_ERROR("rz-hash: error, file size is less than 1\n");
        goto calculate_encrypt_end;
    }
 
    bsize = ctx->block_size;
    block = malloc(bsize);
    if (!block) {
        RZ_LOG_ERROR("rz-hash: error, cannot allocate block memory\n");
        goto calculate_encrypt_end;
    }
 
    ut64 to = ctx->offset.to ? ctx->offset.to : filesize;
    for (ut64 j = ctx->offset.from; j < to; j += bsize) {
        int read = rz_io_pread_at(io, j, block, to - j > bsize ? bsize : (to - j));
        rz_crypto_update(cry, block, read);
    }
 
    rz_crypto_final(cry, NULL, 0);
 
    int ciphertext_size = 0;
    const ut8 *ciphertext = rz_crypto_get_output(cry, &ciphertext_size);
 
    hash_print_crypto(ctx, ctx->algorithm, ciphertext, ciphertext_size, ctx->offset.from, to);
    result = true;
 
calculate_encrypt_end:
    free(block);
    free(iv);
    rz_crypto_free(cry);
    return result;
}

References rz_io_t::desc, free(), hash_parse_hexadecimal(), hash_parse_string(), hash_print_crypto(), malloc(), NULL, read(), RZ_CRYPTO_DIR_ENCRYPT, rz_crypto_final(), rz_crypto_free(), rz_crypto_get_output(), rz_crypto_new(), rz_crypto_set_iv(), rz_crypto_set_key(), rz_crypto_update(), rz_crypto_use(), rz_io_desc_size(), rz_io_pread_at(), RZ_LOG_ERROR, to, and ut64().

Referenced by rz_main_rz_hash().

calculate_hash()

static bool calculate_hash ( RzHashContext *  ctx, RzIO *  io, const char *  filename  )

static

Definition at line 800 of file rz-hash.c.

                                                                               {
    bool result = false;
    const char *algorithm;
    RzList *algorithms = NULL;
    RzListIter *it;
    RzHashCfg *md = NULL;
    ut64 bsize = 0;
    ut64 filesize;
    ut8 *block = NULL;
    ut8 *cmphash = NULL;
    const ut8 *digest = NULL;
    RzHashSize digest_size = 0;
 
    algorithms = parse_hash_algorithms(ctx);
    if (!algorithms || rz_list_length(algorithms) < 1) {
        RZ_LOG_ERROR("rz-hash: error, empty list of hash algorithms\n");
        goto calculate_hash_end;
    }
 
    filesize = rz_io_desc_size(io->desc);
 
    md = rz_hash_cfg_new(ctx->rh);
    if (!md) {
        RZ_LOG_ERROR("rz-hash: error, cannot allocate hash context memory\n");
        goto calculate_hash_end;
    }
 
    if (ctx->offset.to > filesize) {
        RZ_LOG_ERROR("rz-hash: error, -t value is greater than file size\n");
        goto calculate_hash_end;
    }
 
    if (ctx->offset.from > filesize) {
        RZ_LOG_ERROR("rz-hash: error, -f value is greater than file size\n");
        goto calculate_hash_end;
    }
 
    bsize = ctx->block_size;
    block = malloc(bsize);
    if (!block) {
        RZ_LOG_ERROR("rz-hash: error, cannot allocate block memory\n");
        goto calculate_hash_end;
    }
 
    rz_list_foreach (algorithms, it, algorithm) {
        if (!rz_hash_cfg_configure(md, algorithm)) {
            goto calculate_hash_end;
        }
    }
 
    if (ctx->key.len > 0 && !rz_hash_cfg_hmac(md, ctx->key.buf, ctx->key.len)) {
        goto calculate_hash_end;
    }
 
    if (ctx->compare) {
        ut64 to = ctx->offset.to ? ctx->offset.to : filesize;
        size_t cmphashlen = 0;
        bool result = false;
 
        if (!hash_parse_hexadecimal("-c", ctx->compare, &cmphash, &cmphashlen)) {
            // RZ_LOG_ERROR("rz-hash: error, cannot allocate block memory\n");
            goto calculate_hash_end;
        }
 
        if (!rz_hash_cfg_init(md)) {
            goto calculate_hash_end;
        }
 
        if (ctx->as_prefix && ctx->seed.buf &&
            !rz_hash_cfg_update(md, ctx->seed.buf, ctx->seed.len)) {
            goto calculate_hash_end;
        }
 
        for (ut64 j = ctx->offset.from; j < to; j += bsize) {
            int read = rz_io_pread_at(io, j, block, to - j > bsize ? bsize : (to - j));
            if (!rz_hash_cfg_update(md, block, read)) {
                goto calculate_hash_end;
            }
        }
 
        if (!ctx->as_prefix && ctx->seed.buf &&
            !rz_hash_cfg_update(md, ctx->seed.buf, ctx->seed.len)) {
            goto calculate_hash_end;
        }
        if (!rz_hash_cfg_final(md) ||
            !rz_hash_cfg_iterate(md, ctx->iterate)) {
            goto calculate_hash_end;
        }
 
        rz_list_foreach (algorithms, it, algorithm) {
            digest = rz_hash_cfg_get_result(md, algorithm, &digest_size);
            if (digest_size != cmphashlen) {
                result = false;
            } else {
                result = !memcmp(cmphash, digest, digest_size);
            }
 
            if (ctx->mode == RZ_HASH_MODE_JSON) {
                pj_o(ctx->pj);
            }
            hash_context_compare_hashes(ctx, filesize, result, algorithm, filename);
            if (ctx->mode == RZ_HASH_MODE_JSON) {
                pj_end(ctx->pj);
            }
        }
    } else if (ctx->show_blocks) {
        ut64 to = ctx->offset.to ? ctx->offset.to : filesize;
        for (ut64 j = ctx->offset.from; j < to; j += bsize) {
            int read = rz_io_pread_at(io, j, block, to - j > bsize ? bsize : (to - j));
            if (!rz_hash_cfg_init(md) ||
                !rz_hash_cfg_update(md, block, read) ||
                !rz_hash_cfg_final(md) ||
                !rz_hash_cfg_iterate(md, ctx->iterate)) {
                goto calculate_hash_end;
            }
 
            rz_list_foreach (algorithms, it, algorithm) {
                digest = rz_hash_cfg_get_result(md, algorithm, &digest_size);
                if (ctx->mode == RZ_HASH_MODE_JSON) {
                    pj_o(ctx->pj);
                }
                hash_print_digest(ctx, md, algorithm, j, j + bsize, filename);
                if (ctx->mode == RZ_HASH_MODE_JSON) {
                    pj_end(ctx->pj);
                }
            }
        }
    } else {
        ut64 to = ctx->offset.to ? ctx->offset.to : filesize;
        if (!rz_hash_cfg_init(md)) {
            goto calculate_hash_end;
        }
 
        if (ctx->as_prefix && ctx->seed.buf &&
            !rz_hash_cfg_update(md, ctx->seed.buf, ctx->seed.len)) {
            goto calculate_hash_end;
        }
 
        for (ut64 j = ctx->offset.from; j < to; j += bsize) {
            int read = rz_io_pread_at(io, j, block, to - j > bsize ? bsize : (to - j));
            if (!rz_hash_cfg_update(md, block, read)) {
                goto calculate_hash_end;
            }
        }
 
        if (!ctx->as_prefix && ctx->seed.buf &&
            !rz_hash_cfg_update(md, ctx->seed.buf, ctx->seed.len)) {
            goto calculate_hash_end;
        }
 
        if (!rz_hash_cfg_final(md) ||
            !rz_hash_cfg_iterate(md, ctx->iterate)) {
            goto calculate_hash_end;
        }
 
        rz_list_foreach (algorithms, it, algorithm) {
            digest = rz_hash_cfg_get_result(md, algorithm, &digest_size);
 
            if (ctx->mode == RZ_HASH_MODE_JSON) {
                pj_o(ctx->pj);
            }
            hash_print_digest(ctx, md, algorithm, ctx->offset.from, to, filename);
            if (ctx->mode == RZ_HASH_MODE_JSON) {
                pj_end(ctx->pj);
            }
        }
    }
    result = true;
 
calculate_hash_end:
    rz_list_free(algorithms);
    free(block);
    free(cmphash);
    rz_hash_cfg_free(md);
    return result;
}

References rz_io_t::desc, free(), hash_context_compare_hashes(), hash_parse_hexadecimal(), hash_print_digest(), malloc(), benchmark::md, NULL, parse_hash_algorithms(), pj_end(), pj_o(), read(), rz_hash_cfg_configure(), rz_hash_cfg_final(), rz_hash_cfg_free(), rz_hash_cfg_get_result(), rz_hash_cfg_hmac(), rz_hash_cfg_init(), rz_hash_cfg_iterate(), rz_hash_cfg_new(), rz_hash_cfg_update(), RZ_HASH_MODE_JSON, rz_io_desc_size(), rz_io_pread_at(), rz_list_free(), rz_list_length(), RZ_LOG_ERROR, to, and ut64().

Referenced by rz_main_rz_hash().

calculate_luhn()

static bool calculate_luhn ( RzHashContext *  ctx, RzIO *  io, const char *  filename  )

static

Definition at line 1135 of file rz-hash.c.

                                                                               {
    char value[128];
    const char *input = ctx->input + 2;
    ut64 to = ctx->offset.to ? ctx->offset.to : strlen(input);
    ut64 from = ctx->offset.from;
    ut64 result = 0;
 
    if (!rz_calculate_luhn_value(input, &result)) {
        RZ_LOG_ERROR("rz-hash: error, input string is not a number\n");
        return false;
    }
 
    snprintf(value, sizeof(value), "%" PFMT64u, result);
    switch (ctx->mode) {
    case RZ_HASH_MODE_JSON:
        pj_o(ctx->pj);
        pj_kb(ctx->pj, "seed", false);
        pj_kb(ctx->pj, "hmac", false);
        pj_kn(ctx->pj, "from", from);
        pj_kn(ctx->pj, "to", to);
        pj_ks(ctx->pj, "name", ctx->algorithm);
        pj_ks(ctx->pj, "value", value);
        pj_end(ctx->pj);
        break;
    case RZ_HASH_MODE_STANDARD:
        printf("%s: 0x%08" PFMT64x "-0x%08" PFMT64x " %s: %s\n", filename, from, to, ctx->algorithm, value);
        break;
    case RZ_HASH_MODE_RANDOMART:
    case RZ_HASH_MODE_QUIET:
        printf("%s: %s: %s\n", filename, ctx->algorithm, value);
        break;
    case RZ_HASH_MODE_VERY_QUIET:
        puts(value);
        break;
    }
    return true;
}

References from, input(), PFMT64u, PFMT64x, pj_end(), pj_kb(), pj_kn(), pj_ks(), pj_o(), printf(), rz_calculate_luhn_value(), RZ_HASH_MODE_JSON, RZ_HASH_MODE_QUIET, RZ_HASH_MODE_RANDOMART, RZ_HASH_MODE_STANDARD, RZ_HASH_MODE_VERY_QUIET, RZ_LOG_ERROR, snprintf, to, ut64(), and value.

Referenced by rz_main_rz_hash().

hash_context_compare_hashes()

static void hash_context_compare_hashes ( RzHashContext *  ctx, size_t  filesize, bool  result, const char *  hname, const char *  filename  )

static

Definition at line 760 of file rz-hash.c.

                                                                                                                                   {
    ut64 to = ctx->offset.to ? ctx->offset.to : filesize;
    const char *hmac = ctx->key.len > 0 ? "hmac-" : "";
    switch (ctx->mode) {
    case RZ_HASH_MODE_JSON:
        pj_kb(ctx->pj, "seed", ctx->seed.len > 0);
        pj_kb(ctx->pj, "hmac", ctx->key.len > 0);
        pj_kb(ctx->pj, "compare", result);
        pj_kn(ctx->pj, "from", ctx->offset.from);
        pj_kn(ctx->pj, "to", to);
        pj_ks(ctx->pj, "name", hname);
        break;
    case RZ_HASH_MODE_RANDOMART:
    case RZ_HASH_MODE_STANDARD:
        printf("%s: 0x%08" PFMT64x "-0x%08" PFMT64x " %s%s: computed hash %s the expected one\n", filename, ctx->offset.from, to, hmac, hname, result ? "matches" : "doesn't match");
        break;
    case RZ_HASH_MODE_QUIET:
        printf("%s: %s%s: computed hash %s the expected one\n", filename, hmac, hname, result ? "matches" : "doesn't match");
        break;
    case RZ_HASH_MODE_VERY_QUIET:
        printf("%s", result ? "true" : "false");
        break;
    }
}

References PFMT64x, pj_kb(), pj_kn(), pj_ks(), printf(), RZ_HASH_MODE_JSON, RZ_HASH_MODE_QUIET, RZ_HASH_MODE_RANDOMART, RZ_HASH_MODE_STANDARD, RZ_HASH_MODE_VERY_QUIET, to, and ut64().

Referenced by calculate_hash().

hash_context_create_desc_io_stdin()

static RzIODesc* hash_context_create_desc_io_stdin ( RzIO *  io )

static

Definition at line 500 of file rz-hash.c.

                                                             {
    RzIODesc *desc = NULL;
    int size;
    char *uri = NULL;
    ut8 *buffer = NULL;
 
    buffer = (ut8 *)rz_stdin_slurp(&size);
    if (size < 1 || !buffer) {
        goto rz_hash_context_create_desc_io_stdin_end;
    }
 
    uri = rz_str_newf("malloc://%d", size);
    if (!uri) {
        rz_warn_if_reached();
        goto rz_hash_context_create_desc_io_stdin_end;
    }
 
    desc = rz_io_open_nomap(io, uri, RZ_PERM_R, 0);
    if (!desc) {
        RZ_LOG_ERROR("rz-hash: error, cannot open malloc://%d\n", size);
        goto rz_hash_context_create_desc_io_stdin_end;
    }
 
    if (rz_io_pwrite_at(io, 0, buffer, size) != size) {
        RZ_LOG_ERROR("rz-hash: error, cannot write into malloc://%d buffer\n", size);
        rz_io_desc_close(desc);
        desc = NULL;
        goto rz_hash_context_create_desc_io_stdin_end;
    }
 
rz_hash_context_create_desc_io_stdin_end:
    free(buffer);
    free(uri);
    return desc;
}

References desc, free(), NULL, rz_io_desc_close(), rz_io_open_nomap(), rz_io_pwrite_at(), RZ_LOG_ERROR, RZ_PERM_R, rz_stdin_slurp(), rz_str_newf(), and rz_warn_if_reached.

Referenced by hash_context_run().

hash_context_create_desc_io_string()

static RzIODesc* hash_context_create_desc_io_string ( RzIO *  io, const char *  input  )

static

Definition at line 536 of file rz-hash.c.

                                                                                 {
    RzIODesc *desc = NULL;
    char *uri = NULL;
    ut8 *buffer = NULL;
    size_t size;
 
    bool is_string = !strncmp(input, "s:", 2);
 
    if (is_string) {
        if (!hash_parse_string("-s", input + 2, &buffer, &size)) {
            goto rz_hash_context_create_desc_io_string_end;
        }
    } else {
        if (!hash_parse_hexadecimal("-x", input, &buffer, &size)) {
            goto rz_hash_context_create_desc_io_string_end;
        }
    }
    if (!buffer || (!is_string && size < 1)) {
        rz_warn_if_reached();
        goto rz_hash_context_create_desc_io_string_end;
    } else if (is_string && size < 1) {
        goto rz_hash_context_create_desc_io_string_end;
    }
 
    uri = rz_str_newf("malloc://%" PFMTSZu, size);
    if (!uri) {
        rz_warn_if_reached();
        goto rz_hash_context_create_desc_io_string_end;
    }
 
    desc = rz_io_open_nomap(io, uri, RZ_PERM_R, 0);
    if (!desc) {
        RZ_LOG_ERROR("rz-hash: error, cannot open malloc://%" PFMTSZu "\n", size);
        goto rz_hash_context_create_desc_io_string_end;
    }
 
    if (rz_io_pwrite_at(io, 0, buffer, size) != size) {
        RZ_LOG_ERROR("rz-hash: error, cannot write into malloc://%" PFMTSZu " buffer\n", size);
        rz_io_desc_close(desc);
        desc = NULL;
        goto rz_hash_context_create_desc_io_string_end;
    }
 
rz_hash_context_create_desc_io_string_end:
    free(buffer);
    free(uri);
    return desc;
}

References desc, free(), hash_parse_hexadecimal(), hash_parse_string(), input(), is_string(), NULL, PFMTSZu, rz_io_desc_close(), rz_io_open_nomap(), rz_io_pwrite_at(), RZ_LOG_ERROR, RZ_PERM_R, rz_str_newf(), and rz_warn_if_reached.

Referenced by hash_context_run().

hash_context_fini()

static void hash_context_fini ( RzHashContext *  ctx )

static

Definition at line 489 of file rz-hash.c.

                                                  {
    free(ctx->algorithm);
    free(ctx->compare);
    free(ctx->iv);
    free(ctx->input);
    free((char **)ctx->files);
    free(ctx->seed.buf);
    pj_free(ctx->pj);
    rz_hash_free(ctx->rh);
}

References free(), pj_free(), and rz_hash_free().

Referenced by rz_main_rz_hash().

hash_context_run()

static bool hash_context_run ( RzHashContext *  ctx, RzHashRun  run  )

static

Definition at line 585 of file rz-hash.c.

                                                                {
    bool result = false;
    RzIODesc *desc = NULL;
 
    RzIO *io = rz_io_new();
    if (!io) {
        rz_warn_if_reached();
        return false;
    }
 
    if (ctx->mode == RZ_HASH_MODE_JSON) {
        ctx->pj = pj_new();
        if (!ctx->pj) {
            RZ_LOG_ERROR("rz-hash: error, failed to allocate JSON memory.\n");
            goto rz_hash_context_run_end;
        }
        pj_o(ctx->pj);
    }
    if (ctx->use_stdin) {
        desc = hash_context_create_desc_io_stdin(io);
        if (!desc) {
            RZ_LOG_ERROR("rz-hash: error, cannot read stdin\n");
            goto rz_hash_context_run_end;
        }
        if (ctx->mode == RZ_HASH_MODE_JSON) {
            pj_ka(ctx->pj, "stdin");
        }
        if (!run(ctx, io, "stdin")) {
            goto rz_hash_context_run_end;
        }
        if (ctx->mode == RZ_HASH_MODE_JSON) {
            pj_end(ctx->pj);
        }
    } else if (ctx->input) {
        if (strlen(ctx->input) > 0) {
            desc = hash_context_create_desc_io_string(io, ctx->input);
            if (!desc) {
                RZ_LOG_ERROR("rz-hash: error, cannot read string\n");
                goto rz_hash_context_run_end;
            }
        }
        if (ctx->mode == RZ_HASH_MODE_JSON) {
            pj_ka(ctx->pj, !strncmp(ctx->input, "s:", 2) ? "string" : "hexadecimal");
        }
        if (!run(ctx, io, !strncmp(ctx->input, "s:", 2) ? "string" : "hexadecimal")) {
            goto rz_hash_context_run_end;
        }
        if (ctx->mode == RZ_HASH_MODE_JSON) {
            pj_end(ctx->pj);
        }
    } else {
        for (ut32 i = 0; i < ctx->nfiles; ++i) {
            desc = rz_io_open_nomap(io, ctx->files[i], RZ_PERM_R, 0);
            if (!desc) {
                RZ_LOG_ERROR("rz-hash: error, cannot open file '%s'\n", ctx->files[i]);
                goto rz_hash_context_run_end;
            }
            if (ctx->mode == RZ_HASH_MODE_JSON) {
                pj_ka(ctx->pj, ctx->files[i]);
            }
            if (!run(ctx, io, ctx->files[i])) {
                goto rz_hash_context_run_end;
            }
            if (ctx->mode == RZ_HASH_MODE_JSON) {
                pj_end(ctx->pj);
            }
            rz_io_desc_close(desc);
            desc = NULL;
        }
    }
    if (ctx->mode == RZ_HASH_MODE_JSON) {
        pj_end(ctx->pj);
        printf("%s\n", pj_string(ctx->pj));
    }
    result = true;
 
rz_hash_context_run_end:
    rz_io_desc_close(desc);
    rz_io_free(io);
    return result;
}

References desc, hash_context_create_desc_io_stdin(), hash_context_create_desc_io_string(), i, NULL, pj_end(), pj_ka(), pj_new(), pj_o(), pj_string(), printf(), run(), RZ_HASH_MODE_JSON, rz_io_desc_close(), rz_io_free(), rz_io_new(), rz_io_open_nomap(), RZ_LOG_ERROR, RZ_PERM_R, and rz_warn_if_reached.

Referenced by rz_main_rz_hash().

hash_load_plugins()

static void hash_load_plugins ( RzHashContext *  ctx )

static

Definition at line 1179 of file rz-hash.c.

                                                  {
    char *tmp = rz_sys_getenv("RZ_ASM_NOPLUGINS");
    if (tmp) {
        free(tmp);
        return;
    }
    RzLib *rl = rz_lib_new(NULL, NULL);
    rz_lib_add_handler(rl, RZ_LIB_TYPE_HASH, "hash plugins", &lib_hash_cb, NULL, ctx);
 
    char *path = rz_sys_getenv(RZ_LIB_ENV);
    if (!RZ_STR_ISEMPTY(path)) {
        rz_lib_opendir(rl, path, false);
    }
 
    char *homeplugindir = rz_path_home_prefix(RZ_PLUGINS);
    char *sysplugindir = rz_path_system(RZ_PLUGINS);
    rz_lib_opendir(rl, homeplugindir, false);
    rz_lib_opendir(rl, sysplugindir, false);
    free(homeplugindir);
    free(sysplugindir);
 
    free(path);
    rz_lib_free(rl);
    free(tmp);
}

References free(), lib_hash_cb(), NULL, path, rz_lib_add_handler(), RZ_LIB_ENV, rz_lib_free(), rz_lib_new(), rz_lib_opendir(), RZ_LIB_TYPE_HASH, rz_path_home_prefix(), rz_path_system(), RZ_PLUGINS, RZ_STR_ISEMPTY, rz_sys_getenv(), and autogen_x86imm::tmp.

Referenced by rz_main_rz_hash().

hash_parse_any()

static bool hash_parse_any ( RzHashContext *  ctx, const char *  option, const char *  arg, RzHashBuffer *  hb  )

static

Definition at line 290 of file rz-hash.c.

                                                                                                      {
    ssize_t arglen = strlen(arg);
    if (arglen < 1) {
        rz_hash_bool_error(ctx, RZ_HASH_OP_ERROR, "option %s is empty.\n", option);
    }
    if (!strcmp(arg, "-")) {
        int stdinlen = 0;
        hb->buf = (ut8 *)rz_stdin_slurp(&stdinlen);
        hb->len = stdinlen;
    } else if (arg[0] == '@') {
        hb->buf = (ut8 *)rz_file_slurp(arg + 1, &hb->len);
    } else if (!strncmp(arg, "s:", 2)) {
        if (!hash_parse_string(option, arg + 2, &hb->buf, &hb->len)) {
            ctx->operation = RZ_HASH_OP_ERROR;
            return false;
        }
    } else {
        if (!hash_parse_hexadecimal(option, arg, &hb->buf, &hb->len)) {
            ctx->operation = RZ_HASH_OP_ERROR;
            return false;
        }
    }
    if (!hb->buf) {
        rz_hash_bool_error(ctx, RZ_HASH_OP_ERROR, "failed to allocate buffer memory for %s option.\n", option);
    }
    return true;
}

References RzHashBuffer::buf, hash_parse_hexadecimal(), hash_parse_string(), RzHashBuffer::len, rz_file_slurp(), rz_hash_bool_error, RZ_HASH_OP_ERROR, and rz_stdin_slurp().

Referenced by hash_parse_cmdline().

hash_parse_cmdline()

static void hash_parse_cmdline ( int  argc, const char **  argv, RzHashContext *  ctx  )

static

Definition at line 318 of file rz-hash.c.

                                                                                {
    const char *seed = NULL;
    const char *key = NULL;
 
    RzGetopt opt;
    int c;
    rz_getopt_init(&opt, argc, argv, "jD:e:vE:a:i:I:S:K:s:x:b:nBhf:t:kLqc:");
    while ((c = rz_getopt_next(&opt)) != -1) {
        switch (c) {
        case 'q': rz_hash_ctx_set_quiet(ctx); break;
        case 'i': rz_hash_ctx_set_signed(ctx, iterate, opt.arg); break;
        case 'j': rz_hash_ctx_set_mode(ctx, RZ_HASH_MODE_JSON); break;
        case 'S': rz_hash_set_val(ctx, seed, NULL, opt.arg); break;
        case 'K': rz_hash_set_val(ctx, key, NULL, opt.arg); break;
        case 'I': rz_hash_ctx_set_str(ctx, iv, opt.arg); break;
        case 'D':
            rz_hash_ctx_set_str(ctx, algorithm, opt.arg);
            rz_hash_ctx_set_op(ctx, RZ_HASH_OP_DECRYPT);
            break;
        case 'E':
            rz_hash_ctx_set_str(ctx, algorithm, opt.arg);
            rz_hash_ctx_set_op(ctx, RZ_HASH_OP_ENCRYPT);
            break;
        case 'L': rz_hash_ctx_set_op(ctx, RZ_HASH_OP_LIST_ALGO); break;
        case 'e': rz_hash_ctx_set_bool(ctx, little_endian, opt.arg, "little", "big"); break;
        case 'k': rz_hash_ctx_set_mode(ctx, RZ_HASH_MODE_RANDOMART); break;
        case 'a':
            rz_hash_ctx_set_str(ctx, algorithm, opt.arg);
            rz_hash_ctx_set_op(ctx, RZ_HASH_OP_HASH);
            break;
        case 'B': ctx->show_blocks = true; break;
        case 'b': rz_hash_ctx_set_unsigned(ctx, block_size, opt.arg); break;
        case 'f': rz_hash_ctx_set_unsigned(ctx, offset.from, opt.arg); break;
        case 't': rz_hash_ctx_set_unsigned(ctx, offset.to, opt.arg); break;
        case 'v': ctx->operation = RZ_HASH_OP_VERSION; break;
        case 'h': ctx->operation = RZ_HASH_OP_HELP; break;
        case 's': rz_hash_ctx_set_input(ctx, input, opt.arg, false); break;
        case 'x': rz_hash_ctx_set_input(ctx, input, opt.arg, true); break;
        case 'c': rz_hash_ctx_set_str(ctx, compare, opt.arg); break;
        default:
            rz_hash_error(ctx, RZ_HASH_OP_ERROR, "unknown flag '%c'\n", c);
        }
    }
 
    if (ctx->operation == RZ_HASH_OP_HELP ||
        ctx->operation == RZ_HASH_OP_VERSION ||
        ctx->operation == RZ_HASH_OP_LIST_ALGO) {
        return;
    }
 
    if (opt.ind >= argc && !ctx->input) {
        ctx->operation = RZ_HASH_OP_USAGE;
        return;
    }
 
    if (!ctx->algorithm) {
        rz_hash_ctx_set_str(ctx, algorithm, "sha256");
        rz_hash_ctx_set_op(ctx, RZ_HASH_OP_HASH);
    }
 
    if (!ctx->input && !strcmp(argv[argc - 1], "-")) {
        ctx->use_stdin = true;
    } else {
        ctx->files = RZ_NEWS(const char *, argc - opt.ind);
        if (!ctx->files) {
            rz_hash_error(ctx, RZ_HASH_OP_ERROR, "failed to allocate file array memory.\n");
        }
        ctx->nfiles = 0;
        for (int i = opt.ind; i < argc; ++i) {
            if (IS_NULLSTR(argv[i])) {
                rz_hash_error(ctx, RZ_HASH_OP_ERROR, "cannot open a file without a name.\n");
            }
            if (rz_file_is_directory(argv[i])) {
                rz_hash_error(ctx, RZ_HASH_OP_ERROR, "cannot open directories (%s).\n", argv[i]);
            }
            ctx->files[ctx->nfiles++] = argv[i];
        }
    }
 
    if (ctx->nfiles < 1 && !ctx->use_stdin && !ctx->input) {
        ctx->operation = RZ_HASH_OP_USAGE;
        return;
    }
 
    if (strstr(ctx->algorithm, "luhn")) {
        if (strchr(ctx->algorithm, ',')) {
            rz_hash_error(ctx, RZ_HASH_OP_ERROR, "algorithm 'luhn' is incompatible with multiple algorithms.\n");
        }
        if (!ctx->input || strncmp(ctx->input, "s:", 2)) {
            rz_hash_error(ctx, RZ_HASH_OP_ERROR, "algorithm 'luhn' requires -s option.\n");
        }
        if (ctx->mode == RZ_HASH_MODE_RANDOMART) {
            rz_hash_error(ctx, RZ_HASH_OP_ERROR, "algorithm 'luhn' is incompatible with -k option.\n");
        }
        if (ctx->show_blocks) {
            rz_hash_error(ctx, RZ_HASH_OP_ERROR, "algorithm 'luhn' is incompatible with -B option.\n");
        }
        if (ctx->block_size < strlen(ctx->algorithm + 2)) {
            ctx->block_size = strlen(ctx->algorithm + 2);
        }
        if (ctx->compare) {
            rz_hash_error(ctx, RZ_HASH_OP_ERROR, "algorithm 'luhn' is incompatible with -c option.\n");
        }
        if (seed) {
            rz_hash_error(ctx, RZ_HASH_OP_ERROR, "algorithm 'luhn' is incompatible with -S option.\n");
        }
        if (key) {
            rz_hash_error(ctx, RZ_HASH_OP_ERROR, "algorithm 'luhn' is incompatible with -K option.\n");
        }
        ctx->operation = RZ_HASH_OP_LUHN;
    } else if (ctx->operation == RZ_HASH_OP_ENCRYPT || ctx->operation == RZ_HASH_OP_DECRYPT) {
        if (!key && strncmp("base", ctx->algorithm, 4) && strcmp("punycode", ctx->algorithm)) {
            rz_hash_error(ctx, RZ_HASH_OP_ERROR, "option -K is required for algorithm '%s'.\n", ctx->algorithm);
        }
        if (ctx->compare) {
            ssize_t len = strlen(ctx->compare);
            if (!strncmp(ctx->algorithm, "base", 4)) {
                rz_hash_error(ctx, RZ_HASH_OP_ERROR, "option -c is incompatible with -E or -D with algorithm base64 or base91.\n");
            } else if (strchr(ctx->algorithm, ',')) {
                rz_hash_error(ctx, RZ_HASH_OP_ERROR, "option -c incompatible with multiple algorithms.\n");
            } else if (len < 1 || c & 1) {
                rz_hash_error(ctx, RZ_HASH_OP_ERROR, "option -c value length is not multiple of 2 (expected hexadecimal value).\n");
            }
        }
        if (ctx->show_blocks) {
            rz_hash_error(ctx, RZ_HASH_OP_ERROR, "option -B is incompatible with -E/-D.\n");
        }
        if (ctx->mode == RZ_HASH_MODE_RANDOMART) {
            rz_hash_error(ctx, RZ_HASH_OP_ERROR, "option -k is incompatible with -E/-D.\n");
        }
    } else if (ctx->operation == RZ_HASH_OP_HASH) {
        if (ctx->iv) {
            rz_hash_error(ctx, RZ_HASH_OP_ERROR, "option -I is incompatible with -a; use -S to define a seed or -K to define an hmac key.\n");
        }
        if (ctx->show_blocks && ctx->compare) {
            rz_hash_error(ctx, RZ_HASH_OP_ERROR, "option -B is incompatible with -c option.\n");
        }
        if (ctx->mode == RZ_HASH_MODE_RANDOMART && ctx->compare) {
            rz_hash_error(ctx, RZ_HASH_OP_ERROR, "option -c is incompatible with -k option.\n");
        }
        if (ctx->mode == RZ_HASH_MODE_RANDOMART && strchr(ctx->algorithm, ',')) {
            rz_hash_error(ctx, RZ_HASH_OP_ERROR, "option -a with multiple algorithms is incompatible with -k option.\n");
        }
    }
 
    if (ctx->offset.from && ctx->offset.to && ctx->offset.from >= ctx->offset.to) {
        rz_hash_error(ctx, RZ_HASH_OP_ERROR, "option -f value (%" PFMT64u ") is greater or equal to -t value (%" PFMT64u ").\n", ctx->offset.from, ctx->offset.to);
    }
    if (ctx->block_size && ctx->offset.from && ctx->offset.to && (ctx->offset.to - ctx->offset.from) % ctx->block_size) {
        rz_hash_error(ctx, RZ_HASH_OP_ERROR, "range between %" PFMT64u " and %" PFMT64u " is not a multiple of %" PFMT64u ".\n", ctx->offset.from, ctx->offset.to, ctx->block_size);
    }
 
    if (seed) {
        if (seed[0] == '^') {
            seed++;
            ctx->as_prefix = true;
        }
        if (!hash_parse_any(ctx, "-S", seed, &ctx->seed)) {
            return;
        }
    }
 
    if (key && !hash_parse_any(ctx, "-K", key, &ctx->key)) {
        return;
    }
 
    if (!ctx->block_size) {
        ctx->block_size = RZ_HASH_DEFAULT_BLOCK_SIZE;
    }
}

References rz_getopt_t::arg, argv, c, compare(), hash_parse_any(), i, rz_getopt_t::ind, input(), IS_NULLSTR, key, len, NULL, PFMT64u, rz_file_is_directory(), rz_getopt_init(), rz_getopt_next(), rz_hash_ctx_set_bool, rz_hash_ctx_set_input, rz_hash_ctx_set_mode, rz_hash_ctx_set_op, rz_hash_ctx_set_quiet, rz_hash_ctx_set_signed, rz_hash_ctx_set_str, rz_hash_ctx_set_unsigned, RZ_HASH_DEFAULT_BLOCK_SIZE, rz_hash_error, RZ_HASH_MODE_JSON, RZ_HASH_MODE_RANDOMART, RZ_HASH_OP_DECRYPT, RZ_HASH_OP_ENCRYPT, RZ_HASH_OP_ERROR, RZ_HASH_OP_HASH, RZ_HASH_OP_HELP, RZ_HASH_OP_LIST_ALGO, RZ_HASH_OP_LUHN, RZ_HASH_OP_USAGE, RZ_HASH_OP_VERSION, rz_hash_set_val, and RZ_NEWS.

Referenced by rz_main_rz_hash().

hash_parse_hexadecimal()

static bool hash_parse_hexadecimal ( const char *  option, const char *  hexadecimal, ut8 **  buffer, size_t *  bufsize  )

static

Definition at line 254 of file rz-hash.c.

                                                                                                               {
    char *sstdin = NULL;
    int hexlen = 0;
    if (!strcmp(hexadecimal, "-")) {
        hexadecimal = sstdin = rz_stdin_slurp(&hexlen);
    } else {
        hexlen = strlen(hexadecimal);
    }
 
    if (hexlen < 1 || !hexadecimal) {
        RZ_LOG_ERROR("rz-hash: error, option %s is empty.\n", option);
        free(sstdin);
        return false;
    } else if (hexlen & 1) {
        RZ_LOG_ERROR("rz-hash: error, option %s is not a valid hexadecimal (len is not pair: %d).\n", option, hexlen);
        free(sstdin);
        return false;
    }
    *buffer = NULL;
    st64 binlen = hexlen >> 1;
    ut8 *b = (ut8 *)malloc(binlen);
    if (b) {
        *bufsize = rz_hex_str2bin(hexadecimal, b);
        if (*bufsize < 1) {
            RZ_LOG_ERROR("rz-hash: error, option %s is not a valid hexadecimal.\n", option);
            free(b);
            free(sstdin);
            return false;
        }
        *buffer = b;
    }
 
    free(sstdin);
    return true;
}

References b, free(), malloc(), NULL, rz_hex_str2bin(), RZ_LOG_ERROR, rz_stdin_slurp(), and st64.

Referenced by calculate_decrypt(), calculate_encrypt(), calculate_hash(), hash_context_create_desc_io_string(), and hash_parse_any().

hash_parse_string()

static bool hash_parse_string ( const char *  option, const char *  string, ut8 **  buffer, size_t *  bufsize  )

static

Definition at line 222 of file rz-hash.c.

                                                                                                     {
    char *sstdin = NULL;
    int stringlen = 0;
    if (!strcmp(string, "-")) {
        string = sstdin = rz_stdin_slurp(&stringlen);
    } else {
        stringlen = strlen(string);
    }
    if (stringlen < 1 || !string) {
        RZ_LOG_ERROR("rz-hash: error, option %s is empty.\n", option);
        free(sstdin);
        return false;
    }
 
    ut8 *b = (ut8 *)malloc(stringlen + 1);
    if (!b) {
        RZ_LOG_ERROR("rz-hash: error, failed to allocate string in memory.\n");
        free(sstdin);
        return false;
    }
 
    memcpy(b, string, stringlen);
    b[stringlen] = 0;
    stringlen = rz_str_unescape((char *)b);
 
    *buffer = b;
    *bufsize = stringlen;
    free(sstdin);
 
    return true;
}

References b, free(), malloc(), memcpy(), NULL, RZ_LOG_ERROR, rz_stdin_slurp(), and rz_str_unescape().

Referenced by calculate_decrypt(), calculate_encrypt(), hash_context_create_desc_io_string(), and hash_parse_any().

hash_print_crypto()

static void hash_print_crypto ( RzHashContext *  ctx, const char *  hname, const ut8 *  buffer, int  len, ut64  from, ut64  to  )

static

Definition at line 667 of file rz-hash.c.

                                                                                                                     {
    char *value = ctx->operation == RZ_HASH_OP_ENCRYPT ? malloc(len * 2 + 1) : malloc(len + 1);
    if (!value) {
        RZ_LOG_ERROR("rz-hash: error, cannot allocate value memory\n");
        return;
    }
 
    if (ctx->operation == RZ_HASH_OP_ENCRYPT) {
        for (int i = 0, bsize; i < len; i++) {
            bsize = (len - i) * 2 + 1;
            snprintf(value + (i * 2), bsize, "%02x", buffer[i]);
        }
    } else {
        memcpy(value, buffer, len);
        value[len] = 0;
    }
 
    switch (ctx->mode) {
    case RZ_HASH_MODE_JSON:
        pj_kn(ctx->pj, "from", from);
        pj_kn(ctx->pj, "to", to);
        pj_ks(ctx->pj, "name", hname);
        pj_ks(ctx->pj, "value", value);
        break;
    case RZ_HASH_MODE_RANDOMART:
    case RZ_HASH_MODE_STANDARD:
        printf("0x%08" PFMT64x "-0x%08" PFMT64x " %s: ", from, to, hname);
        fflush(stdout);
        if (write(1, buffer, len) != len) {
            RZ_LOG_ERROR("rz-hash: error, cannot write on stdout\n");
        }
        printf("\n");
        break;
    case RZ_HASH_MODE_QUIET:
        printf("%s: ", hname);
        fflush(stdout);
        if (write(1, buffer, len) != len) {
            RZ_LOG_ERROR("rz-hash: error, cannot write on stdout\n");
        }
        printf("\n");
        break;
    case RZ_HASH_MODE_VERY_QUIET:
        if (write(1, buffer, len) != len) {
            RZ_LOG_ERROR("rz-hash: error, cannot write on stdout\n");
        }
        break;
    }
    free(value);
}

References free(), from, i, len, malloc(), memcpy(), PFMT64x, pj_kn(), pj_ks(), printf(), RZ_HASH_MODE_JSON, RZ_HASH_MODE_QUIET, RZ_HASH_MODE_RANDOMART, RZ_HASH_MODE_STANDARD, RZ_HASH_MODE_VERY_QUIET, RZ_HASH_OP_ENCRYPT, RZ_LOG_ERROR, snprintf, to, value, and write.

Referenced by calculate_decrypt(), and calculate_encrypt().

hash_print_digest()

static void hash_print_digest ( RzHashContext *  ctx, RzHashCfg *  md, const char *  hname, ut64  from, ut64  to, const char *  filename  )

static

Definition at line 717 of file rz-hash.c.

                                                                                                                              {
    RzHashSize len = 0;
    char *value = NULL;
    char *rndart = NULL;
    const ut8 *buffer;
 
    buffer = rz_hash_cfg_get_result(md, hname, &len);
    value = rz_hash_cfg_get_result_string(md, hname, NULL, ctx->little_endian);
    if (!value || !buffer) {
        free(value);
        return;
    }
 
    bool has_seed = !ctx->iv && ctx->seed.len > 0;
    const char *hmac = ctx->key.len > 0 ? "hmac-" : "";
 
    switch (ctx->mode) {
    case RZ_HASH_MODE_JSON:
        pj_kb(ctx->pj, "seed", has_seed);
        pj_kb(ctx->pj, "hmac", ctx->key.len > 0);
        pj_kn(ctx->pj, "from", from);
        pj_kn(ctx->pj, "to", to);
        pj_ks(ctx->pj, "name", hname);
        pj_ks(ctx->pj, "value", value);
        break;
    case RZ_HASH_MODE_STANDARD:
        printf("%s: 0x%08" PFMT64x "-0x%08" PFMT64x " %s%s: %s%s\n", filename, from, to, hmac, hname, value, has_seed ? " with seed" : "");
        break;
    case RZ_HASH_MODE_RANDOMART:
        rndart = rz_hash_cfg_randomart(buffer, len, from);
        printf("%s%s\n%s\n", hmac, hname, rndart);
        break;
    case RZ_HASH_MODE_QUIET:
        printf("%s: %s%s: %s\n", filename, hmac, hname, value);
        break;
    case RZ_HASH_MODE_VERY_QUIET:
        puts(value);
        break;
    }
    free(value);
    free(rndart);
}

References free(), from, len, benchmark::md, NULL, PFMT64x, pj_kb(), pj_kn(), pj_ks(), printf(), rz_hash_cfg_get_result(), rz_hash_cfg_get_result_string(), rz_hash_cfg_randomart(), RZ_HASH_MODE_JSON, RZ_HASH_MODE_QUIET, RZ_HASH_MODE_RANDOMART, RZ_HASH_MODE_STANDARD, RZ_HASH_MODE_VERY_QUIET, to, and value.

Referenced by calculate_hash().

lib_hash_cb()

static int lib_hash_cb ( RzLibPlugin *  pl, void *  user, void *  data  )

static

Definition at line 1173 of file rz-hash.c.

                                                                {
    RzHashPlugin *hand = (RzHashPlugin *)data;
    RzHashContext *ctx = (RzHashContext *)user;
    return rz_hash_plugin_add(ctx->rh, hand);
}

References rz_hash_plugin_add().

Referenced by hash_load_plugins().

parse_hash_algorithms()

static RzList* parse_hash_algorithms ( RzHashContext *  ctx )

static

Definition at line 785 of file rz-hash.c.

                                                         {
    if (!strcmp(ctx->algorithm, "all")) {
        const RzHashPlugin *plugin;
        RzList *list = rz_list_newf(NULL);
        if (!list) {
            return NULL;
        }
        for (ut64 i = 0; (plugin = rz_hash_plugin_by_index(ctx->rh, i)); ++i) {
            rz_list_append(list, (void *)plugin->name);
        }
        return list;
    }
    return rz_str_split_list(ctx->algorithm, ",", 0);
}

References i, list(), rz_hash_plugin_t::name, NULL, rz_hash_plugin_by_index(), rz_list_append(), rz_list_newf(), rz_str_split_list(), and ut64().

Referenced by calculate_hash().

rz_hash_show_algorithms()

static void rz_hash_show_algorithms ( RzHashContext *  ctx )

static

Definition at line 109 of file rz-hash.c.

                                                        {
    char flags[7] = { 0 };
 
    printf("flags  algorithm      license    author\n");
 
    const RzHashPlugin *rmdp;
    for (size_t i = 0; (rmdp = rz_hash_plugin_by_index(ctx->rh, i)); ++i) {
        snprintf(flags, sizeof(flags), "____h%c", rmdp->support_hmac ? 'm' : '_');
        printf("%6s %-14s %-10s %s\n", flags, rmdp->name, rmdp->license, rmdp->author);
    }
 
    const RzCryptoPlugin *rcp;
    for (size_t i = 0; (rcp = rz_crypto_plugin_by_index(i)); i++) {
        if (!strncmp("base", rcp->name, 4) || !strcmp("punycode", rcp->name)) {
            snprintf(flags, sizeof(flags), "__ed__");
        } else if (!strcmp("rol", rcp->name)) {
            snprintf(flags, sizeof(flags), "E_____");
        } else if (!strcmp("ror", rcp->name)) {
            snprintf(flags, sizeof(flags), "_D____");
        } else {
            snprintf(flags, sizeof(flags), "ED____");
        }
        printf("%6s %-14s %-10s %s\n", flags, rcp->name, rcp->license, rcp->author);
    }
    printf(
        "\n"
        "flags legenda:\n"
        "    E = encryption, D = decryption\n"
        "    e = encoding, d = encoding\n"
        "    h = hash, m = hmac\n");
}

References rz_crypto_plugin_t::author, rz_hash_plugin_t::author, flags, i, rz_crypto_plugin_t::license, rz_hash_plugin_t::license, rz_crypto_plugin_t::name, rz_hash_plugin_t::name, printf(), rz_crypto_plugin_by_index(), rz_hash_plugin_by_index(), snprintf, and rz_hash_plugin_t::support_hmac.

Referenced by rz_main_rz_hash().

rz_hash_show_help()

static void rz_hash_show_help ( bool  usage_only )

static

Definition at line 72 of file rz-hash.c.

                                               {
    printf("Usage: rz-hash [-vhBkjLq] [-b S] [-a A] [-c H] [-E A] [-D A] [-s S] [-x S] [-f O] [-t O] [files|-] ...\n");
    if (usage_only) {
        return;
    }
    printf(
        " -v          Shows version\n"
        " -h          Shows this help page\n"
        " -           Input read from stdin instead from a file\n"
        " -a algo     Hash algorithm to use and you can specify multiple ones by\n"
        "             appending a comma (example: sha1,md4,md5,sha256)\n"
        " -B          Outputs the calculated value for each block\n"
        " -b size     Sets the block size\n"
        " -c value    Compare calculated value with a given one (hexadecimal)\n"
        " -e endian   Sets the endianness (default: 'big' accepted: 'big' or 'little')\n"
        " -D algo     Decrypt the given input; use -S to set key and -I to set IV (if needed)\n"
        " -E algo     Encrypt the given input; use -S to set key and -I to set IV (if needed)\n"
        " -f from     Starts the calculation at given offset\n"
        " -t to       Stops the calculation at given offset\n"
        " -I iv       Sets the initialization vector (IV)\n"
        " -i times    Repeat the calculation N times\n"
        " -j          Outputs the result as a JSON structure\n"
        " -k          Outputs the calculated value using openssh's randomkey algorithm\n"
        " -L          List all algorithms\n"
        " -q          Sets quiet mode (use -qq to get only the calculated value)\n"
        " -S seed     Sets the seed for -a, use '^' to append it before the input, use '@'\n"
        "             prefix to load it from a file and '-' from read it\n"
        " -K key      Sets the hmac key for -a and the key for -E/-D, use '@' prefix to\n"
        "             load it from a file and '-' from read it\n"
        "             from stdin (you can combine them)\n"
        " -s string   Input read from a zero-terminated string instead from a file\n"
        " -x hex      Input read from a hexadecimal value instead from a file\n"
        "\n"
        "             All the inputs (besides -s/-x/-c) can be hexadecimal or strings\n"
        "             if 's:' prefix is specified\n");
}

References printf().

Referenced by rz_main_rz_hash().

rz_main_rz_hash()

RZ_API int rz_main_rz_hash	(	int	argc,
		const char **	argv
	)

Definition at line 1205 of file rz-hash.c.

                                                        {
    int result = 1;
    RzHashContext ctx = { 0 };
    ctx.rh = rz_hash_new();
    hash_load_plugins(&ctx);
 
    hash_parse_cmdline(argc, argv, &ctx);
 
    switch (ctx.operation) {
    case RZ_HASH_OP_LIST_ALGO:
        rz_hash_show_algorithms(&ctx);
        break;
    case RZ_HASH_OP_LUHN:
        if (!hash_context_run(&ctx, calculate_luhn)) {
            goto rz_main_rz_hash_end;
        }
        break;
    case RZ_HASH_OP_HASH:
        if (!hash_context_run(&ctx, calculate_hash)) {
            goto rz_main_rz_hash_end;
        }
        break;
    case RZ_HASH_OP_DECRYPT:
        if (!hash_context_run(&ctx, calculate_decrypt)) {
            goto rz_main_rz_hash_end;
        }
        break;
    case RZ_HASH_OP_ENCRYPT:
        if (!hash_context_run(&ctx, calculate_encrypt)) {
            goto rz_main_rz_hash_end;
        }
        break;
    case RZ_HASH_OP_VERSION:
        rz_main_version_print("rz-hash");
        break;
    case RZ_HASH_OP_USAGE:
        rz_hash_show_help(true);
        goto rz_main_rz_hash_end;
    case RZ_HASH_OP_ERROR:
        goto rz_main_rz_hash_end;
    case RZ_HASH_OP_HELP:
        result = 0;
        /* fall-thru */
    default:
        rz_hash_show_help(false);
        goto rz_main_rz_hash_end;
    }
 
    result = 0;
 
rz_main_rz_hash_end:
    hash_context_fini(&ctx);
    return result;
}

References argv, calculate_decrypt(), calculate_encrypt(), calculate_hash(), calculate_luhn(), hash_context_fini(), hash_context_run(), hash_load_plugins(), hash_parse_cmdline(), rz_hash_new(), RZ_HASH_OP_DECRYPT, RZ_HASH_OP_ENCRYPT, RZ_HASH_OP_ERROR, RZ_HASH_OP_HASH, RZ_HASH_OP_HELP, RZ_HASH_OP_LIST_ALGO, RZ_HASH_OP_LUHN, RZ_HASH_OP_USAGE, RZ_HASH_OP_VERSION, rz_hash_show_algorithms(), rz_hash_show_help(), and rz_main_version_print().

Referenced by MAIN_NAME().