rz_hex.h File Reference

#include <rz_types.h>

Go to the source code of this file.

Functions
RZ_API int	rz_hex_pair2bin (const char *arg)
RZ_API int	rz_hex_str2binmask (const char *in, ut8 *out, ut8 *mask)
RZ_API int	rz_hex_str2bin (const char *in, ut8 *out)
	Convert an input string in into the binary form in out. More...
RZ_API int	rz_hex_bin2str (const ut8 *in, int len, char *out)
RZ_API void	rz_hex_ut2st_str (const ut32 in, RZ_INOUT char *out, const int len)
	Takes an unsigned 32bit integer with MSB set to 1 and returns the signed integer in hex format as string. E.g.: 0xffffffff -> "-0x1". More...
RZ_API char *	rz_hex_bin2strdup (const ut8 *in, int len)
RZ_API bool	rz_hex_to_byte (ut8 *val, ut8 c)
RZ_API int	rz_hex_str_is_valid (const char *s)
RZ_API st64	rz_hex_bin_truncate (ut64 in, int n)
RZ_API char *	rz_hex_from_c (const char *code)
RZ_API char *	rz_hex_from_py (const char *code)
RZ_API char *	rz_hex_from_code (const char *code)
RZ_API char *	rz_hex_no_code (const char *code)
RZ_API char *	rz_hex_from_py_str (char *out, const char *code)
RZ_API char *	rz_hex_from_py_array (char *out, const char *code)
RZ_API char *	rz_hex_from_c_str (char *out, const char **code)
RZ_API char *	rz_hex_from_c_array (char *out, const char *code)

Function Documentation

rz_hex_bin2str()

RZ_API int rz_hex_bin2str	(	const ut8 *	in,
		int	len,
		char *	out
	)

Definition at line 382 of file hex.c.

                                                             {
    int i, idx;
    char tmp[8];
    if (len < 0) {
        return 0;
    }
    for (idx = i = 0; i < len; i++, idx += 2) {
        snprintf(tmp, sizeof(tmp), "%02x", in[i]);
        memcpy(out + idx, tmp, 2);
    }
    out[idx] = 0;
    return len;
}

References i, setup::idx, in, len, memcpy(), out, snprintf, and autogen_x86imm::tmp.

Referenced by __dumpSections(), __system(), __write(), add_file_hash(), header(), init_items(), print_instruction_ops(), rabin_dump_symbols(), rz_asm_code_get_hex(), rz_asm_op_get_hex(), rz_asm_op_set_hexbuf(), rz_cmd_cmp_hexpair_string_handler(), rz_cmd_search(), rz_core_visual_asm(), rz_egg_raw(), and rz_egg_raw_prepend().

rz_hex_bin2strdup()

RZ_API char* rz_hex_bin2strdup	(	const ut8 *	in,
		int	len
	)

Definition at line 415 of file hex.c.

                                                       {
    int i, idx;
    char tmp[5], *out;
 
    if ((len + 1) * 2 < len) {
        return NULL;
    }
    out = malloc((len + 1) * 2);
    if (!out) {
        return NULL;
    }
    for (i = idx = 0; i < len; i++, idx += 2) {
        snprintf(tmp, sizeof(tmp), "%02x", in[i]);
        memcpy(out + idx, tmp, 2);
    }
    out[idx] = 0;
    return out;
}

References i, setup::idx, in, len, malloc(), memcpy(), NULL, out, snprintf, and autogen_x86imm::tmp.

Referenced by bin_pe_compute_authentihash(), bin_pe_get_claimed_authentihash(), disassembly_as_table(), print_result_diff(), regstate(), replace_asm_test(), rz_cmd_disassembly_all_possible_opcodes_handler(), rz_cmd_disassembly_all_possible_opcodes_treeview_handler(), rz_core_analysis_bytes(), rz_core_asm_back_disassemble(), rz_core_bin_info_print(), rz_core_io_cache_print(), rz_debug_session_list_memory(), rz_main_rz_find(), rz_test_run_asm_test(), rz_type_format_uleb(), show_analinfo(), and showanalysis().

rz_hex_bin_truncate()

RZ_API st64 rz_hex_bin_truncate	(	ut64	in,
		int	n
	)

Definition at line 525 of file hex.c.

                                                {
    switch (n) {
    case 1:
        if ((in & UT8_GT0)) {
            return UT64_8U | in;
        }
        return in & UT8_MAX;
    case 2:
        if ((in & UT16_GT0)) {
            return UT64_16U | in;
        }
        return in & UT16_MAX;
    case 4:
        if ((in & UT32_GT0)) {
            return UT64_32U | in;
        }
        return in & UT32_MAX;
    case 8:
        return in & UT64_MAX;
    }
    return in;
}

References in, n, UT16_GT0, UT16_MAX, UT32_GT0, UT32_MAX, UT64_16U, UT64_32U, UT64_8U, UT64_MAX, UT8_GT0, and UT8_MAX.

rz_hex_from_c()

RZ_API char* rz_hex_from_c

(

const char *

code

)

Definition at line 214 of file hex.c.

                                             {
    if (!code) {
        return NULL;
    }
    char *const ret = malloc(strlen(code) * 3);
    if (!ret) {
        return NULL;
    }
    *ret = '\0';
    char *out = ret;
    const char *tmp_code = strchr(code, '=');
    if (tmp_code) {
        code = tmp_code;
    }
    for (; *code != '\0' && *code != '{' && *code != '"'; code++) {
        code = skip_comment_c(code);
    }
    if (*code == '{') {
        out = rz_hex_from_c_array(out, code);
    } else if (*code == '"') {
        const char *s1, *s2;
        s1 = code;
        do {
            code = s1;
            out = rz_hex_from_c_str(out, &code);
            if (!out) {
                break;
            }
            s1 = strchr(code + 1, '"');
            s2 = strchr(code + 1, ';');
        } while (s1 && s2 && (s1 <= s2));
    }
    if (!out) {
        free(ret);
        return NULL;
    }
    *out = '\0';
    return ret;
}

References code, free(), malloc(), NULL, out, rz_hex_from_c_array(), rz_hex_from_c_str(), s1, s2, and skip_comment_c().

Referenced by rz_hex_from_code().

rz_hex_from_c_array()

RZ_API char* rz_hex_from_c_array	(	char *	out,
		const char *	code
	)

Definition at line 177 of file hex.c.

                                                              {
    const char abc[] = "0123456789abcdef";
    if (*code != '{' || !strchr(code, '}')) {
        return NULL;
    }
    code++;
    for (; *code; code++) {
        const char *comma = strchr(code, ',');
        if (!comma) {
            comma = strchr(code, '}');
        }
        char *_word = rz_str_ndup(code, comma - code);
        const char *word = _word;
        word = skip_comment_c(word);
        while (*word == ' ' || *word == '\t' || *word == '\n') {
            word++;
            word = skip_comment_c(word);
        }
        if (IS_DIGIT(*word)) {
            ut8 n = (ut8)rz_num_math(NULL, word);
            *out++ = abc[(n >> 4) & 0xf];
            *out++ = abc[n & 0xf];
        }
        free(_word);
        code = comma;
        if (code && *code == '}') {
            break;
        }
    }
    return out;
}

References code, comma, free(), IS_DIGIT, n, NULL, out, rz_num_math(), rz_str_ndup(), skip_comment_c(), and ut8.

Referenced by rz_hex_from_c().

rz_hex_from_c_str()

RZ_API char* rz_hex_from_c_str	(	char *	out,
		const char **	code
	)

Definition at line 106 of file hex.c.

                                                             {
    const char abc[] = "0123456789abcdefABCDEF";
    const char *iter = *code;
    if (*iter != '\'' && *iter != '"') {
        return NULL;
    }
    const char end_char = *iter;
    iter++;
    for (; *iter && *iter != end_char; iter++) {
        if (*iter == '\\') {
            iter++;
            switch (iter[0]) {
            case 'e':
                *out++ = '1';
                *out++ = 'b';
                break;
            case 'r':
                *out++ = '0';
                *out++ = 'd';
                break;
            case 'n':
                *out++ = '0';
                *out++ = 'a';
                break;
            case 'x': {
                ut8 c1 = iter[1];
                ut8 c2 = iter[2];
                iter += 2;
                if (c1 == '\0' || c2 == '\0') {
                    return NULL;
                } else if (strchr(abc, c1) && strchr(abc, c2)) {
                    *out++ = tolower(c1);
                    *out++ = tolower(c2);
                } else {
                    return NULL;
                }
                break;
            }
            default:
                if (iter[0] == end_char) {
                    *out++ = abc[*iter >> 4];
                    *out++ = abc[*iter & 0xf];
                }
                return NULL;
            }
        } else {
            *out++ = abc[*iter >> 4];
            *out++ = abc[*iter & 0xf];
        }
    }
    *code = iter;
    return out;
}

References c1, c2, code, NULL, out, and tolower.

Referenced by rz_hex_from_c(), rz_hex_from_py_str(), and rz_hex_no_code().

rz_hex_from_code()

RZ_API char* rz_hex_from_code

(

const char *

code

)

Definition at line 342 of file hex.c.

                                                {
    if (!strchr(code, '=')) {
        return rz_hex_no_code(code);
    }
    /* C language */
    if (strstr(code, "char") || strstr(code, "int")) {
        return rz_hex_from_c(code);
    }
    /* JavaScript */
    if (strstr(code, "var")) {
        return rz_hex_from_js(code);
    }
    /* Python */
    return rz_hex_from_py(code);
}

References rz_hex_from_c(), rz_hex_from_js(), rz_hex_from_py(), and rz_hex_no_code().

Referenced by rax().

rz_hex_from_py()

RZ_API char* rz_hex_from_py

(

const char *

code

)

Definition at line 76 of file hex.c.

                                              {
    if (!code) {
        return NULL;
    }
    char *const ret = malloc(strlen(code) * 3);
    if (!ret) {
        return NULL;
    }
    *ret = '\0';
    char *out = ret;
    const char *tmp_code = strchr(code, '=');
    if (tmp_code) {
        code = tmp_code;
    }
    for (; *code && *code != '[' && *code != '\'' && *code != '"'; code++) {
        code = skip_comment_py(code);
    }
    if (*code == '[') {
        out = rz_hex_from_py_array(out, code);
    } else if (*code == '"' || *code == '\'') {
        out = rz_hex_from_py_str(out, code);
    }
    if (!out) {
        free(ret);
        return NULL;
    }
    *out = '\0';
    return ret;
}

References free(), malloc(), NULL, out, rz_hex_from_py_array(), rz_hex_from_py_str(), and skip_comment_py().

Referenced by rz_hex_from_code().

rz_hex_from_py_array()

RZ_API char* rz_hex_from_py_array	(	char *	out,
		const char *	code
	)

Definition at line 42 of file hex.c.

                                                               {
    const char abc[] = "0123456789abcdef";
    if (*code != '[' || !strchr(code, ']')) {
        return NULL;
    }
    code++;
    for (; *code; code++) {
        char *comma = strchr(code, ',');
        if (!comma) {
            comma = strchr(code, ']');
        }
        if (!comma) {
            break;
        }
        char *_word = rz_str_ndup(code, comma - code);
        const char *word = _word;
        while (*word == ' ' || *word == '\t' || *word == '\n') {
            word++;
            word = skip_comment_py(word);
        }
        if (IS_DIGIT(*word)) {
            ut8 n = (ut8)rz_num_math(NULL, word);
            *out++ = abc[(n >> 4) & 0xf];
            *out++ = abc[n & 0xf];
        }
        free(_word);
        code = comma;
        if (*code == ']') {
            break;
        }
    }
    return out;
}

References code, comma, free(), IS_DIGIT, n, NULL, out, rz_num_math(), rz_str_ndup(), skip_comment_py(), and ut8.

Referenced by rz_hex_from_py().

rz_hex_from_py_str()

RZ_API char* rz_hex_from_py_str	(	char *	out,
		const char *	code
	)

Definition at line 23 of file hex.c.

                                                             {
    if (!strncmp(code, "'''", 3)) {
        const char *s = code + 2;
        return rz_hex_from_c_str(out, &s);
    }
    return rz_hex_from_c_str(out, &code);
}

References out, rz_hex_from_c_str(), and s.

Referenced by rz_hex_from_py().

rz_hex_no_code()

RZ_API char* rz_hex_no_code

(

const char *

code

)

Definition at line 317 of file hex.c.

                                              {
    if (!code) {
        return NULL;
    }
    char *const ret = calloc(1, strlen(code) * 3);
    if (!ret) {
        return NULL;
    }
    *ret = '\0';
    char *out = ret;
    out = rz_hex_from_c_str(out, &code);
    code = strchr(code + 1, '"');
    if (!out) {
        free(ret);
        return NULL;
    }
    *out = '\0';
    while (out && code) {
        *out = '\0';
        out = rz_hex_from_c_str(out, &code);
        code = strchr(code + 1, '"');
    }
    return ret;
}

References calloc(), free(), NULL, out, and rz_hex_from_c_str().

Referenced by rz_hex_from_code().

rz_hex_pair2bin()

RZ_API int rz_hex_pair2bin

(

const char *

arg

)

Definition at line 360 of file hex.c.

                                            {
    ut8 *ptr, c = 0, d = 0;
    ut32 j = 0;
 
    for (ptr = (ut8 *)arg;; ptr = ptr + 1) {
        if (!*ptr || *ptr == ' ' || j == 2) {
            break;
        }
        d = c;
        if (*ptr != '.' && rz_hex_to_byte(&c, *ptr)) {
            eprintf("Invalid hexa string at char '%c' (%s).\n",
                *ptr, arg);
            return -1;
        }
        c |= d;
        if (j++ == 0) {
            c <<= 4;
        }
    }
    return (int)c;
}

References c, d, eprintf, and rz_hex_to_byte().

Referenced by rcc_pushstr(), and rz_print_hexpair().

rz_hex_str2bin()

RZ_API int rz_hex_str2bin	(	const char *	in,
		ut8 *	out
	)

Convert an input string in into the binary form in out.

Convert an input string in the hexadecimal form (e.g. "41424344") into the raw binary form (e.g. "ABCD")

Parameters

in	Input string in hexadecimal form. An optional "0x" prefix may be present.
out	Output buffer having at least strlen(in) / 2 bytes available

Returns

number of bytes written into out

Definition at line 444 of file hex.c.

                                                    {
    long nibbles = 0;
 
    while (in && *in) {
        ut8 tmp;
        /* skip hex prefix */
        if (*in == '0' && in[1] == 'x') {
            in += 2;
        }
        /* read hex digits */
        while (!rz_hex_to_byte(out ? &out[nibbles / 2] : &tmp, *in)) {
            nibbles++;
            in++;
        }
        if (*in == '\0') {
            break;
        }
        /* comments */
        if (*in == '#' || (*in == '/' && in[1] == '/')) {
            if ((in = strchr(in, '\n'))) {
                in++;
            }
            continue;
        } else if (*in == '/' && in[1] == '*') {
            if ((in = strstr(in, "*/"))) {
                in += 2;
            }
            continue;
        } else if (!IS_WHITESPACE(*in) && *in != '\n') {
            /* this is not a valid string */
            return 0;
        }
        /* ignore character */
        in++;
    }
 
    if (nibbles % 2) {
        if (out) {
            rz_hex_to_byte(&out[nibbles / 2], '0');
        }
        return -(nibbles + 1) / 2;
    }
 
    return nibbles / 2;
}

References in, IS_WHITESPACE, out, rz_hex_to_byte(), and autogen_x86imm::tmp.

Referenced by __open(), __read(), __reg_read(), bochs_read(), cmd_analysis_esil(), DEFINE_HANDLE_TS_FCN_AND_SYMBOL(), encrypt_or_decrypt_block(), getstr(), hash_parse_hexadecimal(), old_transform_op(), rasm_disasm(), rax(), run_old_command(), rz_analysis_op_hexstr(), rz_analyze_bytes_handler(), rz_asm_massemble(), rz_asm_mdisassemble_hexstr(), rz_asm_op_set_hex(), rz_assembly_of_hex_handler(), rz_cmd_cmp_hexpair_string_handler(), rz_cmd_debug(), rz_cmd_help(), rz_cmd_search(), rz_core_cmd_subst_i(), rz_core_search_preludes(), rz_core_write_base64_at(), rz_core_write_hexpair(), rz_core_yank_hexpair(), rz_debug_dmp_init(), rz_esil_of_hex_handler(), rz_hex_str2binmask(), rz_main_rz_bin(), rz_main_rz_gg(), rz_reg_arena_set_bytes(), rz_reg_arenas_write_hex_handler(), rz_search_keyword_new_hex(), rz_search_keyword_new_str(), rz_search_keyword_new_wide(), rz_test_load_asm_test_file(), rz_test_run_asm_test(), rz_write_block_handler(), rz_write_extend_hexbytes_handler(), rz_write_mask_set_handler(), rz_write_unified_patch_handler(), show_analinfo(), visual_search(), and write_op_val().

rz_hex_str2binmask()

RZ_API int rz_hex_str2binmask	(	const char *	in,
		ut8 *	out,
		ut8 *	mask
	)

Definition at line 490 of file hex.c.

                                                                   {
    ut8 *ptr;
    int len, ilen = strlen(in) + 1;
    int has_nibble = 0;
    memcpy(out, in, ilen);
    for (ptr = out; *ptr; ptr++) {
        if (*ptr == '.') {
            *ptr = '0';
        }
    }
    len = rz_hex_str2bin((char *)out, out);
    if (len < 0) {
        has_nibble = 1;
        len = -(len + 1);
    }
    if (len != -1) {
        memcpy(mask, in, ilen);
        if (has_nibble) {
            memcpy(mask + ilen, "f0", 3);
        }
        for (ptr = mask; *ptr; ptr++) {
            if (IS_HEXCHAR(*ptr)) {
                *ptr = 'f';
            } else if (*ptr == '.') {
                *ptr = '0';
            }
        }
        len = rz_hex_str2bin((char *)mask, mask);
        if (len < 0) {
            len++;
        }
    }
    return len;
}

References in, IS_HEXCHAR, len, mask, memcpy(), out, and rz_hex_str2bin().

Referenced by rz_search_keyword_new_hexmask().

rz_hex_str_is_valid()

RZ_API int rz_hex_str_is_valid

(

const char *

s

)

Definition at line 549 of file hex.c.

                                                {
    int i;
    int len = 0;
    if (!strncmp(str, "0x", 2)) {
        str += 2;
    }
    for (i = 0; str[i] != '\0'; i++) {
        if (IS_HEXCHAR(str[i])) {
            len++;
        }
        if (IS_HEXCHAR(str[i]) || IS_WHITESPACE(str[i])) {
            continue;
        }
        return -1; // if we're here, then str isn't valid
    }
    return len;
}

References i, IS_HEXCHAR, IS_WHITESPACE, len, and cmd_descs_generate::str.

Referenced by rz_reg_arena_set_bytes().

rz_hex_to_byte()

RZ_API bool rz_hex_to_byte	(	ut8 *	val,
		ut8	c
	)

Definition at line 10 of file hex.c.

                                            {
    if (IS_DIGIT(c)) {
        *val = (ut8)(*val) * 16 + (c - '0');
    } else if (c >= 'A' && c <= 'F') {
        *val = (ut8)(*val) * 16 + (c - 'A' + 10);
    } else if (c >= 'a' && c <= 'f') {
        *val = (ut8)(*val) * 16 + (c - 'a' + 10);
    } else {
        return 1;
    }
    return 0;
}

References c, IS_DIGIT, ut8, and val.

Referenced by rgbnum(), rz_hex_pair2bin(), rz_hex_str2bin(), rz_str_unescape(), and unescape_string().

rz_hex_ut2st_str()

RZ_API void rz_hex_ut2st_str	(	const ut32	in,
		RZ_INOUT char *	out,
		const int	len
	)

Takes an unsigned 32bit integer with MSB set to 1 and returns the signed integer in hex format as string. E.g.: 0xffffffff -> "-0x1".

Parameters

in	The integer to convert to the signed string.
out	The buffer to write the signed hex string to.
len	Length of the out buffer.

Returns

char* The signed integer as hex string.

Definition at line 405 of file hex.c.

                                                                               {
    char tmp[12];
    if (len < sizeof(tmp)) {
        RZ_LOG_FATAL("Output buffer too small for negative 32bit value.\n");
    }
    snprintf(tmp, sizeof(tmp), "-0x%" PFMT32x, ~in + 1);
    memcpy(out, tmp, sizeof(tmp));
    return;
}

References in, len, memcpy(), out, PFMT32x, RZ_LOG_FATAL, snprintf, and autogen_x86imm::tmp.

Referenced by hex_disasm_with_templates().