crypto.c File Reference

#include <rz_crypto.h>
#include "config.h"
#include <rz_util.h>

Go to the source code of this file.

Macros
#define	RZ_CRYPTO_OUTPUT_SIZE   4096

Functions
	RZ_LIB_VERSION (rz_crypto)
RZ_API const char *	rz_crypto_name (const RzCryptoSelector bit)
RZ_API const char *	rz_crypto_codec_name (const RzCryptoSelector bit)
RZ_API const RzCryptoPlugin *	rz_crypto_plugin_by_index (size_t index)
RZ_API int	rz_crypto_add (RzCrypto *cry, RzCryptoPlugin *h)
RZ_API int	rz_crypto_del (RzCrypto *cry, RzCryptoPlugin *h)
RZ_API RzCrypto *	rz_crypto_new (void)
RZ_API void	rz_crypto_free (RzCrypto *cry)
RZ_API bool	rz_crypto_use (RzCrypto *cry, const char *algo)
RZ_API bool	rz_crypto_set_key (RzCrypto *cry, const ut8 *key, int keylen, int mode, int direction)
RZ_API bool	rz_crypto_set_iv (RzCrypto *cry, const ut8 *iv, int ivlen)
RZ_API int	rz_crypto_update (RzCrypto *cry, const ut8 *buf, int len)
RZ_API int	rz_crypto_final (RzCrypto *cry, const ut8 *buf, int len)
RZ_API int	rz_crypto_append (RzCrypto *cry, const ut8 *buf, int len)
RZ_API const ut8 *	rz_crypto_get_output (RzCrypto *cry, int *size)

Variables
static RzCryptoPlugin *	crypto_static_plugins [] = { RZ_CRYPTO_STATIC_PLUGINS }
struct {
const char *   name
RzCryptoSelector   bit
}	crypto_name_bytes []
struct {
const char *   name
RzCryptoSelector   bit
}	codec_name_bytes []

Macro Definition Documentation

RZ_CRYPTO_OUTPUT_SIZE

#define RZ_CRYPTO_OUTPUT_SIZE   4096

Definition at line 8 of file crypto.c.

Function Documentation

rz_crypto_add()

RZ_API int rz_crypto_add	(	RzCrypto *	cry,
		RzCryptoPlugin *	h
	)

Definition at line 72 of file crypto.c.

                                                           {
    // add a check ?
    rz_list_append(cry->plugins, h);
    return true;
}

References h, rz_crypto_t::plugins, and rz_list_append().

Referenced by rz_crypto_new().

rz_crypto_append()

RZ_API int rz_crypto_append	(	RzCrypto *	cry,
		const ut8 *	buf,
		int	len
	)

Definition at line 175 of file crypto.c.

                                                                    {
    if (!cry || !buf) {
        return -1;
    }
    if (cry->output_len + len > cry->output_size) {
        cry->output_size += 4096 + len;
        cry->output = realloc(cry->output, cry->output_size);
    }
    if (!cry->output) {
        rz_warn_if_reached();
        cry->output_size = 0;
        return 0;
    }
    memcpy(cry->output + cry->output_len, buf, len);
    cry->output_len += len;
    return cry->output_len;
}

References len, memcpy(), rz_crypto_t::output, rz_crypto_t::output_len, rz_crypto_t::output_size, realloc(), and rz_warn_if_reached.

Referenced by update().

rz_crypto_codec_name()

RZ_API const char* rz_crypto_codec_name

(

const RzCryptoSelector

bit

)

Definition at line 54 of file crypto.c.

                                                                    {
    size_t i;
    for (i = 1; i < RZ_ARRAY_SIZE(codec_name_bytes); i++) {
        if (bit == codec_name_bytes[i].bit) {
            return codec_name_bytes[i].name;
        }
    }
    return "";
}

References bit, codec_name_bytes, i, and RZ_ARRAY_SIZE.

rz_crypto_del()

RZ_API int rz_crypto_del	(	RzCrypto *	cry,
		RzCryptoPlugin *	h
	)

Definition at line 78 of file crypto.c.

                                                           {
    rz_list_delete_data(cry->plugins, h);
    return true;
}

References h, rz_crypto_t::plugins, and rz_list_delete_data().

rz_crypto_final()

RZ_API int rz_crypto_final	(	RzCrypto *	cry,
		const ut8 *	buf,
		int	len
	)

Definition at line 170 of file crypto.c.

                                                                   {
    return (cry && cry->h && cry->h->final) ? cry->h->final(cry, buf, len) : 0;
}

References rz_crypto_plugin_t::final, rz_crypto_t::h, and len.

Referenced by _decrypt(), _encrypt(), calculate_decrypt(), calculate_encrypt(), and encrypt_or_decrypt_block().

rz_crypto_free()

RZ_API void rz_crypto_free

(

RzCrypto *

cry

)

Definition at line 116 of file crypto.c.

                                          {
    if (!cry) {
        return;
    }
    if (cry->h && cry->h->fini && !cry->h->fini(cry)) {
        RZ_LOG_ERROR("[!] crypto: error terminating '%s' plugin\n", cry->h->name);
    }
    rz_list_free(cry->plugins);
    free(cry->output);
    free(cry->key);
    free(cry->iv);
    free(cry);
}

References rz_crypto_plugin_t::fini, free(), rz_crypto_t::h, rz_crypto_t::iv, rz_crypto_t::key, rz_crypto_plugin_t::name, rz_crypto_t::output, rz_crypto_t::plugins, rz_list_free(), and RZ_LOG_ERROR.

Referenced by _decrypt(), _encrypt(), calculate_decrypt(), calculate_encrypt(), encrypt_or_decrypt_block(), and rz_crypto_new().

rz_crypto_get_output()

RZ_API const ut8* rz_crypto_get_output	(	RzCrypto *	cry,
		int *	size
	)

Definition at line 193 of file crypto.c.

                                                                 {
    if (cry->output_size < 1 || !cry->output) {
        if (size) {
            *size = 0;
        }
        return NULL;
    }
    if (size) {
        *size = cry->output_len;
    }
    return cry->output;
}

References NULL, rz_crypto_t::output, rz_crypto_t::output_len, and rz_crypto_t::output_size.

Referenced by _decrypt(), _encrypt(), calculate_decrypt(), calculate_encrypt(), and encrypt_or_decrypt_block().

rz_crypto_name()

RZ_API const char* rz_crypto_name

(

const RzCryptoSelector

bit

)

Definition at line 44 of file crypto.c.

                                                              {
    size_t i;
    for (i = 1; i < RZ_ARRAY_SIZE(crypto_name_bytes); i++) {
        if (bit == crypto_name_bytes[i].bit) {
            return crypto_name_bytes[i].name;
        }
    }
    return "";
}

References bit, crypto_name_bytes, i, and RZ_ARRAY_SIZE.

rz_crypto_new()

RZ_API RzCrypto* rz_crypto_new

(

void

)

Definition at line 83 of file crypto.c.

                                     {
    RzCrypto *cry = RZ_NEW0(RzCrypto);
    if (!cry) {
        goto rz_crypto_new_bad;
    }
 
    cry->output_size = RZ_CRYPTO_OUTPUT_SIZE;
    cry->output = malloc(RZ_CRYPTO_OUTPUT_SIZE);
    if (!cry->output) {
        goto rz_crypto_new_bad;
    }
 
    cry->plugins = rz_list_newf((RzListFree)free);
    if (!cry->plugins) {
        goto rz_crypto_new_bad;
    }
 
    for (ut32 i = 0; i < RZ_ARRAY_SIZE(crypto_static_plugins); i++) {
        RzCryptoPlugin *p = RZ_NEW0(RzCryptoPlugin);
        if (!p) {
            goto rz_crypto_new_bad;
        }
        memcpy(p, crypto_static_plugins[i], sizeof(RzCryptoPlugin));
        rz_crypto_add(cry, p);
    }
    return cry;
 
rz_crypto_new_bad:
    RZ_LOG_ERROR("[!] crypto: failed to allocate\n");
    rz_crypto_free(cry);
    return NULL;
}

References crypto_static_plugins, free(), i, malloc(), memcpy(), NULL, rz_crypto_t::output, rz_crypto_t::output_size, p, rz_crypto_t::plugins, RZ_ARRAY_SIZE, rz_crypto_add(), rz_crypto_free(), RZ_CRYPTO_OUTPUT_SIZE, rz_list_newf(), RZ_LOG_ERROR, and RZ_NEW0.

Referenced by _decrypt(), _encrypt(), calculate_decrypt(), calculate_encrypt(), and encrypt_or_decrypt_block().

rz_crypto_plugin_by_index()

RZ_API const RzCryptoPlugin* rz_crypto_plugin_by_index

(

size_t

index

)

Definition at line 64 of file crypto.c.

                                                                     {
    const size_t size = RZ_ARRAY_SIZE(crypto_static_plugins);
    if (index >= size) {
        return NULL;
    }
    return crypto_static_plugins[index];
}

References crypto_static_plugins, NULL, and RZ_ARRAY_SIZE.

Referenced by rz_hash_show_algorithms().

rz_crypto_set_iv()

RZ_API bool rz_crypto_set_iv	(	RzCrypto *	cry,
		const ut8 *	iv,
		int	ivlen
	)

Definition at line 161 of file crypto.c.

                                                                      {
    return (cry && cry->h && cry->h->set_iv) ? cry->h->set_iv(cry, iv, ivlen) : 0;
}

References rz_crypto_t::h, and rz_crypto_plugin_t::set_iv.

Referenced by _decrypt(), _encrypt(), calculate_decrypt(), calculate_encrypt(), and encrypt_or_decrypt_block().

rz_crypto_set_key()

RZ_API bool rz_crypto_set_key	(	RzCrypto *	cry,
		const ut8 *	key,
		int	keylen,
		int	mode,
		int	direction
	)

Definition at line 151 of file crypto.c.

                                                                                                  {
    if (keylen < 0) {
        keylen = strlen((const char *)key);
    }
    if (!cry || !cry->h || !cry->h->set_key) {
        return false;
    }
    return cry->h->set_key(cry, key, keylen, mode, direction);
}

References rz_crypto_t::h, key, and rz_crypto_plugin_t::set_key.

Referenced by _decrypt(), _encrypt(), calculate_decrypt(), calculate_encrypt(), and encrypt_or_decrypt_block().

rz_crypto_update()

RZ_API int rz_crypto_update	(	RzCrypto *	cry,
		const ut8 *	buf,
		int	len
	)

Definition at line 166 of file crypto.c.

                                                                    {
    return (cry && cry->h && cry->h->update) ? cry->h->update(cry, buf, len) : 0;
}

References rz_crypto_t::h, len, and rz_crypto_plugin_t::update.

Referenced by calculate_decrypt(), calculate_encrypt(), and encrypt_or_decrypt_block().

rz_crypto_use()

RZ_API bool rz_crypto_use	(	RzCrypto *	cry,
		const char *	algo
	)

Definition at line 130 of file crypto.c.

                                                           {
    RzListIter *iter;
    RzCryptoPlugin *h;
    if (cry->h && cry->h->fini && !cry->h->fini(cry)) {
        RZ_LOG_ERROR("[!] crypto: error terminating '%s' plugin\n", cry->h->name);
    }
    rz_list_foreach (cry->plugins, iter, h) {
        rz_warn_if_fail(h && h->use);
        if (h && h->use(algo)) {
            if (h->init && !h->init(cry)) {
                RZ_LOG_ERROR("[!] crypto: error initializing '%s' plugin\n", cry->h->name);
                return false;
            }
 
            cry->h = h;
            return true;
        }
    }
    return false;
}

References rz_crypto_plugin_t::fini, rz_crypto_t::h, h, rz_crypto_plugin_t::name, rz_crypto_t::plugins, RZ_LOG_ERROR, and rz_warn_if_fail.

Referenced by _decrypt(), _encrypt(), calculate_decrypt(), calculate_encrypt(), and encrypt_or_decrypt_block().

RZ_LIB_VERSION()

RZ_LIB_VERSION

(

rz_crypto

)

Variable Documentation

bit

RzCryptoSelector bit

Definition at line 16 of file crypto.c.

Referenced by address_bit(), analop_esil(), avr_il_bld(), avr_il_bst(), avr_il_check_carry_flag_subtraction(), avr_il_check_half_carry_flag_addition(), avr_il_check_half_carry_flag_subtraction(), avr_il_set_sreg_bit_from_reg(), avr_il_sreg_bit_as_imm(), been_here(), bin_pe_init_sections(), bitmapClearBit(), bitmapSetBit(), bitmapTestBit(), clusterGenNodeDescription(), clusterReplyMultiBulkSlots(), es_add_ck(), es_sign_n_64(), esil_bf(), esil_cf(), esil_of(), esil_sign_extend(), find_block_at_xref_addr(), get_literal_price(), literal_matched(), print_insn_sparc(), rc_bit(), rc_bit_price(), rc_bittree(), rc_bittree_price(), rc_bittree_reverse(), rc_bittree_reverse_price(), rd_character(), rz_analysis_block_automerge(), rz_bitmap_set(), rz_bitmap_test(), rz_bitmap_unset(), rz_bv_set_from_bytes_be(), rz_bv_set_from_bytes_le(), rz_core_visual_bit_editor(), rz_crypto_codec_name(), rz_crypto_name(), rz_num_to_bits(), rz_reg_set_value(), rz_str_bits(), rz_str_bits64(), rz_str_bits_from_string(), sh_il_get_status_reg_bit(), sign_extend(), and writebit().

const { ... } codec_name_bytes[]

Initial value:

= {
    { "all", UT64_MAX },
    { "base64", RZ_CODEC_B64 },
    { "base91", RZ_CODEC_B91 },
    { "punycode", RZ_CODEC_PUNYCODE },
}

Referenced by rz_crypto_codec_name().

const { ... } crypto_name_bytes[]

Initial value:

= {
    { "all", UT64_MAX },
    { "rc2", RZ_CRYPTO_RC2 },
    { "rc4", RZ_CRYPTO_RC4 },
    { "rc6", RZ_CRYPTO_RC6 },
    { "aes-ecb", RZ_CRYPTO_AES_ECB },
    { "aes-cbc", RZ_CRYPTO_AES_CBC },
    { "ror", RZ_CRYPTO_ROR },
    { "rol", RZ_CRYPTO_ROL },
    { "rot", RZ_CRYPTO_ROT },
    { "blowfish", RZ_CRYPTO_BLOWFISH },
    { "cps2", RZ_CRYPTO_CPS2 },
    { "des-ecb", RZ_CRYPTO_DES_ECB },
    { "xor", RZ_CRYPTO_XOR },
    { "serpent-ecb", RZ_CRYPTO_SERPENT },
}

Referenced by rz_crypto_name().

crypto_static_plugins

RzCryptoPlugin* crypto_static_plugins[] = { RZ_CRYPTO_STATIC_PLUGINS }

static

Definition at line 12 of file crypto.c.

Referenced by rz_crypto_new(), and rz_crypto_plugin_by_index().

name

const char* name

Definition at line 15 of file crypto.c.